Question

关于我对.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>();

您现在知道构成对象的类型，如果您尝试调用x.GetAllAsString(0, "hello", "world");

此类对象可能对您不起作用，并且它的适用性不是我的问题的主题。我的问题是关于这种方法的名称以及在这种情况下的代码重用。

Answer 1

[简洁;为了我的答案，我将只关注'添加'方法，因为问题/解决方案适用于整个模型]

不幸的是，我不相信你可以简化已经实施的内容。实际上，您的目标是将运行时的类型（'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) { ... }
}

但是，你不能以这种方式真正使用泛型。真正实现这一目标的唯一方法就是以你的方式接近它;使用一堆派生类型，每个派生类型为您的类型添加另一个约束方法。

通用继承

1 个答案: