通用继承

如何解决通用继承

| 关于我对.NET领域的理解，我有几个问题。 请考虑以下模型：

interface IListInterface<T>
{
    //brevity
}

interface IClassInterface
{
    int Count { get; }
}

class A<T> : IClassInterface
{
    List<IListInterface<T>> MyList = new List<IListInterface<T>>();
    public virtual int Count { get { return MyList.Count; } }
    public void Add(IListInterface<T> item) { MyList.Add(item); }
    public IEnumerable<String> GetAllAsString(T source) { return MyList.Select(o=>o.ToString()); }
}

class B<T1,T2> : A<T1>
{
    List<IListInterface<T2>> MyList = new List<IListInterface<T2>>();
    public override int Count { get { return base.Count + MyList.Count; } }
    public void Add(IListInterface<T2> item) { MyList.Add(item); }
    public IEnumerable<String> GetAllAsString(T1 source1,T2 source2)
    {
        return base.GetAllAsString(source1).Union(MyList.Select(o => o.ToString()));
    }
}

class C<T1,T2,T3> : B<T1,T2>
{
    List<IListInterface<T3>> MyList = new List<IListInterface<T3>>();
    public override int Count { get { return base.Count + MyList.Count; } }
    public void Add(IListInterface<T3> item) { MyList.Add(item); }
    public IEnumerable<String> GetAllAsString(T1 source1,T2 source2,T3 source3)
    {
        return base.GetAllAsString(source1,source2).Union(MyList.Select(o => o.ToString()));
    }
}

我的问题是： 用于描述B类和C类正在做什么的术语是什么？泛型类型重载继承？ 在编写这样的对象时，往往会有很多重复的代码，尤其是当添加更多的方法而最终只是调用其对象并将其自身的信息添加到返回中时。有没有更好的方法可以实现更易于维护的类文件？ 编辑以解决此方法的必要性 通过使用这种类型的继承，可以定义单个对象，该对象将约束数据输入的要求并解释其用法。

var x = new C<String,int,DateTime>();

现在，您知道了组成对象的类型，并且如果您尝试调用ѭ2will，则会出现编译时错误。 此类对象可能对您不起作用，其适用性也不是我的问题。我的问题是关于此方法的名称以及在这种情况下的代码重用。     

解决方法

        [为简洁起见；为了我的回答，我将仅关注\'Add \'方法，因为问题/解决方案适用于您的整个模型] 不幸的是，我不相信您可以简化已经实现的内容。实际上，您的目标是在运行时将类型（\'C \'）约束为一组可用的类型，（如果可行！）这将为您提供Add / GetAllAsString方法的有限子集。 因此，在经历了编译器之后，听起来您希望使用一个方法来打开一个类，例如：

public class Base<T>
{ 
    Add(IListInterface<T> o);
}

进入运行时对象，该对象公开了类似的接口；

public class C
{
    Add(IListInterface<string> o) { ... }
    Add(IListInterface<DateTime> o) { ... }
    Add(IListInterface<int> o) { ... }
}

但是，您不能真的那样使用泛型。真正做到这一点的唯一方法是按照自己的方式来实现。带有一堆派生类型，每个派生类型都为您的类型添加了另一个约束方法。