具有继承模板类参数的集合

Question

对我来说这样做是完美的：

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

public class C
{
    public List<A> b = new List<B>();
}

List 期望元素属于 A 类，对于 List 也是如此。我知道存在类型不匹配，但从逻辑上讲，编译器允许这种不匹配是完全合理的。为什么不呢？

Answer 1

List<B> 不能分配给 List<A> 是有充分理由的。

让我们假设不匹配是允许的，让我们想象一下你的类C中的以下假想方法：

public void DoSomething()
{
    b.Add(new A()); // (1)
    List<B> tmp = (List<B>)b; // (2)
    foreach (B item in tmp) { // (3)
        // ...
    }
}

• 第 (1) 行有效，因为 b 被键入为 A 项目的列表，所以很自然，我们可以向 b 添加一个新的 A 实例。
• 第 (2) 行有效，因为b 引用的实例实际上是List<B> 的实例，所以强制转换是有效的。
• 第 (3) 行将崩溃，因为 b 包含不属于 B 类型的项目。 tmp 是 List<B> 类型的事实保证列表中的所有项目都是 B 类型，但如果允许将 List<B> 分配给 List<A>，则不再是这种情况。

因此，编译器不允许这种不匹配。

Answer 2

您期望 List<T> 在 T 中是协变的，但事实并非如此。

在 C# 中，一些接口 是协变的，但类不是。上面有A和B，可以这么说

IEnumerable<A> b = new List<B>();

或

IReadOnlyList<A> b = new List<B>();

因为有问题的接口是协变的，即像 in 一样用“out”声明

public interface IEnumerable<out T> ...

public interface IReadOnlyLies<out T> ...

Answer 3

因为如果列表存储在List<A> 变量中，程序希望能够将A 类型的对象放入该变量中。将List<B> 对象存储在List<A> 变量中会阻止您将A 类型的对象放入明确声明能够保存A 类型的列表中。

即：

List<A> b = new List<B>()
// compiler knows list should be of type A, so it expects this to work:
b.add(new A());

但是，如果您可以将 List<B> 分配给 List<A> 变量，则会产生类型错误，即使编译器知道变量 b 的类型为 List<A>所以应该能够持有A 类型的对象。

相反，您只需使用new List<A> 并向其中添加B 类型的元素，这是允许的，或者您将变量的类型更改为List<B>。

Answer 4

这取决于通用容器是否设置了 covariant 或 contravariant 通用参数。

您可以查看 MSDN 以了解它是如何声明的。

Answer 5

您无法使用类来实现这一点。您可以使用接口（查找协变和逆变），但不能在使用List/IList 时使用。想象以下场景：

public class MyClass<T> 
{
    T GetT() { /* Blah blah */ }
    void SetT(T value) { /* Blah Blah */ }
}

这样写：

MyClass<object> example = new MyClass<string>();

这适用于第一种方法； example 应该返回一个object，MyClass<string> 返回一个字符串，由于多态性，这是合法的。

第二种方法问题更大。假设你后来写了这个：

example.SetT(new object());

这是非法的，因为 MyClass<string> 期望 string 但得到 object。不好。

您可以使用前面提到的协变和逆变来使接口工作。你可以这样写一个界面：

public interface Covariant<out T>
{
    T FunctionReturningT();
}

public class MyInterfaceImplementation<T> : Covariant<T>
{
    public T FunctionReturningT() { /* Blah Blah */ }
}

使界面协变，意思是写是合法的：

Covariant<object> example = new MyInterfaceImplementation<string>();

而您也可以编写以下内容：

public interface Contravariant<in T>
{
    void FunctionAskingForT(T value);
}

public class MyInterfaceImplementation<T> : Contravariant<T>
{
    public void FunctionAskingForT(T value) { /* Blah Blah */ }
}

您刚刚使该接口逆变，这意味着这样写是合法的：

Contravariant<string> example = new MyInterfaceImplementation<object>();