在带有泛型的继承类中实现加法

Question

通过结构..

abstract class Unit
{
 int Id;
}

class Measure : Unit
{
 int Current;
 int Baseline;
}

class Weight : Unit
{
 int Minimum;
 int Maximum;
 int Current;
}

我基本上想添加一个“添加”方法，用于将两个度量相加，或将两个权重相加。但它需要位于 Unit 基类中。所以基本上，如果我

List<Units> units = new List<Unit>();
List<Units> otherUnits = new List<Unit>();

// populate units with various Measures and Weights.
// populate otherUnits with various Measures and Weights.
foreach(Unit u in units)
{
 u.Add( 
         // add something from the otherUnits collection. Typesafe, etc.
      ); 
} 

在 Unit 类中尝试过 ..

public abstract T Add<T>(T unit) where T : Unit;

，但是当我尝试用适当的类填充“T”时，我会收到关于它在继承类中不是适当标识符的错误。有什么想法吗？

Answer 1

我实际上是从 GenericTypeTea 那里得到这个想法的，但我突然想到尝试一种不同的方法。

public interface IUnit
{
    T Add<T>(T unit) where T : IUnit<T>;
}

public interface IUnit<T>
{
    T Add(T unit);
}

    abstract class Unit : IUnit
    {
    }

    class Measure : Unit, IUnit<Measure>
    {
    public Measure Add(Measure unit)
    {
        throw new NotImplementedException();
    } 
    }

    class Weight : Unit, IUnit<Weight>
    {
    public Weight Add(Weight unit)
    {
        throw new NotImplementedException();
    }
    }

Answer 2

如果您绝对必须使用基类的两个列表：

public abstract class Unit()
{
    public abstract Unit Add(Unit other);

    public void MatchType(Unit other)
    {
        if(this.GetType() != other.GetType()) 
            throw new ArgumentException("Units not of same type");
    }
}

...然后在每个派生类中实现以下内容：

public override void Add(Unit other)
{
   MatchType(other);

   //actual implementation
}

然后使用实际的 Add 实现在派生类中扩展此功能。

老实说，我不明白你想做的事情有什么意义。除非两个列表仅包含度量或仅包含重量，否则它不会起作用，并且您只是通过将类型检查放入单位来向消费者隐藏这一事实。那只是自找麻烦。

我将定义包含这两个列表的代码，如下所示：

public List<T> AddLists<T>(List<T> firstList, List<T> secondList) where T:Unit
{
   //your code to add elements
}

...然后使用通用的 Unit.Add() 方法，如下所示：

public static void Add<T>(this T item, T other) where T:Unit
{
   //perform something that works like item += other
}

您必须使用强类型化为“重量”或“测量”的列表。您可以尝试使用 Linq 转换列表的通用参数：

listOfMeasures = listOfUnits.OfType<Weight>().ToList();

当然，这会导致权重从列表中过滤掉，但这对您有利：

listOfWeights = listOfUnits.OfType<Weight>().ToList();
listOfMeasures = listOfUnits.OfType<Measure>().ToList();

var addedListOfMeasures = AddLists(listOfMeasures, otherListOfMeasures);
var addedListOfWeights = AddLists(listofWeights, otherListOfWeights);

上面的代码与通用 AddLists 和 Unit.Add() 方法一起使用我布局，将是类型安全的，因此不会抛出任何运行时异常。并没有带来好处；您创建的任何新单元都需要添加更多代码来处理每种新类型。

Answer 3

您需要更改您的 Unit 抽象类以采用泛型类型：

abstract class Unit<T>

然后您可以添加 Add 抽象方法：

void Add(T unit);

因此您的测量和重量类现在如下所示：

class Measure : Unit<Measure>
class Weight : Unit<Weight>

或者，将以下抽象方法添加到 Unit 中：

abstract void Add(Unit unit);

然后您需要在继承类中使用类型检查来约束它：

void Add(Unit unit)
{
    if (unit.GetType() != this.GetType())
    {
        throw new ArgumentException("You can only add measurements.");
    }
}

Answer 4

如果你的层次结构足够稳定，你可以使用访问者模式的想法来提出这样的想法：

abstract class Unit {
  public abstract Unit Add(Unit unit);
  public virtual Measure Add(Measure unit) { return unit; }
  public virtual Weight Add(Weight unit) { return unit; }
}

class Measure : Unit {
  public override Measure Add(Measure unit) { 
    // ...
  }
  public override Unit Add(Unit unit) {
    return unit.Add(this);
  }
}

class Weight : Unit {
  public override Weight Add(Weight unit) {
    // ...
  }
  public override Unit Add(Unit unit) {
    return unit.Add(this);
  }
}

如果你预计其他行为会发生，你甚至可以使用真正的访问者并将其与 Unit 类分开。稍后添加到层次结构中。

注意：如果Add会改变当前实例，那么应该返回void。