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

Question

假设我们要定义一个允许基本算术的类,称为"可添加".可以添加可添加的东西.

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

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

Number没有实现继承的抽象成员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:根据给出的反馈,这个问题似乎正在进入" 接口与基类 " 的范畴.也许读过这个问题的其他人可能会发现这个问题很有启发性

我希望这个问题很清楚,我是新手,尽管我尽可能地坚持这些指导方针,但我很乐意修改这个问题,使其更加清晰.

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, ...);