c# - 在 C# 中，如何实现一个在函数中调用自身的抽象类，例如比如一类 Addable 对象？

Question

假设我们要定义一个允许基本算术的类，称为“Addable”。可以添加可添加的东西。

abstract class Addable
{
   public abstract Addable Add(Addable X, Addable Y)
}

实现 Addable 的正确方法是什么？以下不起作用，它给出:

Number does not implement inherited abstract member Addable.Add(Addable, Addable).

class Number : Addable
{
     public int Value;

     public Number(int Val)
     {
        Value = Val;
     }

     public Number Add(Number X, Number Y)
     {
         return new Number(X.Value + Y.Value);
     }
}

我认为问题在于 Add 将 (Number,Number) 作为参数，它不够通用，但我不知道如何进行。

编辑:由于有些人要求知道它的用途，让我详细说明一下。我正在使用一种算法，该算法依赖于获取多个对象的最大值。根据用例，这些对象是数字或分布。为了继续上面的例子，我会假装我需要添加这些数字或分布。所以我想要的代码看起来像这样:

Addable LongAlgorithm(Addable X, Other parameters)
{
   ... // Lots of code that may contain X
   Z = Add(X,Y)
   ... // Code Using Z.

   return Answer // Answer is of the same type as X in the input.
}

编辑 2:根据给出的反馈，这个问题似乎正在进入“Interface vs Base class”的领域。也许其他读过这个问题的人可能会发现这个问题很有启发性。

我希望问题很清楚，我是 S.O. 的新手。尽管我已尝试尽可能地遵守指南，但我很乐意修改问题以使其更清楚。

Answer 1

这完全取决于你为什么想要那个 Addable基类，以及如何使用它。值得更新您的问题来解释这一点。这是一种可能不符合您的用例的可能性:

public interface IAddable<T>
{
    T Add(T x, T y);
}

public class Number : IAddable<Number>
{
    public int Value { get; set; }

    public Number(int value)
    {
        Value = value;
    }

    public Number Add(Number other)
    {
        return new Number(Value + other.Value);
    }
}

如果需要，您当然也可以在这里使用抽象基类:

public abstract class Addable<T>
{
    public abstract T Add(T x, T y);
}

如果你想确保类型只能做 class Foo : IAddable<Foo>而不是 class Foo : IAddable<Bar> , 那么你可以添加一个泛型类型限制:

public interface IAddable<T> where T : IAddable<T>
{
    T Add(T x, T y);
}

---

回应您的编辑:

使用上面的类型并执行此操作:

T LongAlgorithm<T>(T x, Other parameters) where T : IAddable<T>
{
   ... // Lots of code that may contain x
   T z = x.Add(y);
   ... // Code Using z

   return z;
}

请注意，我已经更改了您的 Add方法，因此它是一个实例方法，它将自身添加到另一个实例。

如果您想将签名保留为 Add(x, y) ，你可能想要这样的东西:

public class Number
{
    public int Value { get; set; }
    public Number(int value)
    {
        Value = value;
    }
}

public interface IAdder<T>
{
    T Add(T x, T y);
}

public class NumberAdder : IAdder<Number>
{
    public static readonly NumberAdder Instance = new NumberAdder();
    private NumberAdder() { }
    public Number Add(Number x, Number y)
    {
        return new Number(x.Value + y.Value);
    }
}

T LongAlgorithm<T>(T x, IAdder<T> adder, Other parameters)
{
   ... // Lots of code that may contain x
   T z = adder.Add(x, y);
   ... // Code Using z

   return z;
}

然后像这样调用它

Number z = LongAlgorithm(new Number(3), NumberAdder.Instance, ...);