C# 中具有方差的通用方法？

Question

考虑以下类（继承树）：

public class A {}
public class B: A {}

而这种方法：

public IList<A> MyMethod(){
    IList<B> result = new List<B>();

    //add some items to result

    return result;
}

编译器不高兴。错误是无法转换表达式类型IList；返回类型 IList。我该如何解决这个问题？换句话说，如何指定 MyMethod 将返回 T 的 IList，其中 T 可以是任何继承自 A 或 A 本身的实例？

Answer 1

您所要求的是不可能的，因为 IList 不支持方差 - 您不能在任何需要 IList 的地方使用 IList ;。您必须解释更多您想要的细节才能找到解决方案。

可能的解决方案是：

public IList<A> MyMethod(){
    IList<A> result = new List<A>();

    //add some items to result

    return result;
}

或者

public IEnumerable<A> MyMethod(){
    IList<B> result = new List<B>();

    //add some items to result

    return result;
}

Answer 2

您无法将 IList 转换为到 IList，即使 B 继承自 A。否则，用户可能会尝试将不是 B 的 A 实例添加到列表中。

public void Example(){
    IList<B> listB = new List<B>();
    IList<A> listA = listB;
    listA.Add(new A()); // Can't insert A into a list of B
}

你能返回 IEnumerable 吗？而不是 IList？ IEnumerable与 IList 不同，它是协变的。

Answer 3

如何指定 MyMethod 将返回 T 的 IList，其中 T 可以是从 A 继承的任何内容或 A 本身的实例？

---

您不必这样做，

您只需声明它返回 IList 即可。为什么？因为 - 假设 B 继承自 A - B 的每一项都可以在所需类型为 A 的地方传递。

称之为继承多态性、里氏替换原理或方法方差，名称并不重要。重要的是以下内容有效（在 LinqPad 上测试）：

public class A {}
public class B: A {}

public IList<A> MyMethod()
{
    var result = new List<A>();

    //add some items to result
    result.Add(new B());

    return result;
}

---

遗传替代方案

事实上，您可以知道您将返回一个 IList 并请求一些派生类型 (TB, TC...) 来填充它。是的，下面的示例也适用（在 LinqPad 上测试）：

void Main()
{
    MyMethod<A, B, C>();
}

public class A {}
public class B: A {}
public class C: A {}

public IList<TA> MyMethod<TA, TB, TC>()
    where TB : TA, new()
    where TC : TA, new()
    where TA : class
{
    var result = new List<TA>();

    //add some items to result
    result.Add(new B() as TA);
    result.Add(new C() as TA);

    return result;
}

或者，如果您想保留特定的基类型（假设您想返回一个 IList 但它实际上包含以下类的项目）从 A 派生，那么你可以这样做：

void Main()
{
    MyMethod<B, C>();
}

public class A {}
public class B: A {}
public class C: A {}

public IList<A> MyMethod<T1, T2>()
    where T1 : A, new()
    where T2 : A, new()
{
    var result = new List<A>();

    //add some items to result
    result.Add(new T1() as A);
    result.Add(new T2() as A);

    return result;
}

---

你不必这样做，但是

如果你真的想说它返回 IList 其中T： A 然后说！

void Main()
{
    MyMethod<B>();
}

public class A {}
public class B: A {}
//public class C: A {} //Even if I don't add that class

public IList<T> MyMethod<T>()
    where T : A, new()
{
    var result = new List<T>();

    //add some items to result
    result.Add(new T());

    return result;
}

是的，那个不能返回 T 类型的项目和 A 类型的项目，因为它说它返回 >IList 并且并非 A 类型的每个项目也是 T 类型的项目

---

您的代码会发生什么情况

查看您的代码：

public IList<A> MyMethod(){
    IList<B> result = new List<B>();

    //add some items to result

    return result;
}

您是尝试返回 IList当您说您要返回一个 IList 时，我们假设这有效...那么您的方法的调用者会发生什么？让我们看看：

public class A {}
public class B: A {}
public class C: A {}

void Main()
{
    //Hmmm... I need a IList<T>, let's call MyMethod!
    IList<A> list = MyMethod();
    //Cool, I got an IList<A>, now let's add some items...
    var item = new C();
    //Well, item is of type C...
    // and C inherits from A, so I must be able to add it...
    list.Add(item); //BOOM!
    //It was actually an IList<B>!
    // and C doesn't dervive from B, so you can't add it.
}

DFTBA！