请帮助我理解在 C# 中使用泛型时的多态性

Question

我在理解使用泛型时多态性如何工作时遇到问题。作为一个例子，我定义了以下程序：

public interface IMyInterface
{
    void MyMethod();
}

public class MyClass : IMyInterface
{
    public void MyMethod()
    {
    }
}

public class MyContainer<T> where T : IMyInterface
{
    public IList<T> Contents;
}

然后我可以这样做，效果很好：

MyContainer<MyClass> container = new MyContainer<MyClass>();
container.Contents.Add(new MyClass());

我有许多实现 MyInterface 的类。我想编写一个可以接受所有 MyContainer 对象的方法：

public void CallAllMethodsInContainer(MyContainer<IMyInterface> container)
{
    foreach (IMyInterface myClass in container.Contents)
    {
        myClass.MyMethod();
    }
}

现在，我想调用这个方法。

MyContainer<MyClass> container = new MyContainer<MyClass>();
container.Contents.Add(new MyClass());
this.CallAllMethodsInContainer(container);

那行不通。当然，因为 MyClass 实现了 IMyInterface，所以我应该能够强制转换它？

MyContainer<IMyInterface> newContainer = (MyContainer<IMyInterface>)container;

那也没用。我绝对可以将普通的 MyClass 转换为 IMyInterface：

MyClass newClass = new MyClass();
IMyInterface myInterface = (IMyInterface)newClass;

所以，至少我没有完全误解这一点。我不确定如何编写一个方法来接受符合同一接口的类的通用集合。

如果需要的话，我有一个计划来完全解决这个问题，但我真的更愿意正确地做到这一点。

先感谢您。

Answer 1

注意：在所有情况下，您都必须将 Contents 字段初始化为实现 IList 的具体对象。

当您保留通用约束时，您可以执行以下操作：

public IList<T> Contents = new List<T>();

如果不这样做，您可以执行以下操作：

public IList<MyInterface> Contents = new List<MyInterface>();

方法 1：

将方法更改为：

public void CallAllMethodsInContainer<T>(MyContainer<T> container) where T : IMyInterface
{
    foreach (T myClass in container.Contents)
    {
        myClass.MyMethod();
    }
}

并将代码段更改为：

MyContainer<MyClass> container = new MyContainer<MyClass>();
container.Contents.Add(new MyClass());
this.CallAllMethodsInContainer(container);

方法 2：

或者，移动 CallAllMethodsInContainer 方法到 MyContainer 类，如下所示：

public void CallAllMyMethodsInContents()
    {
        foreach (T myClass in Contents)
        {
            myClass.MyMethod();
        }
    }

并将代码片段更改为：

MyContainer<MyClass> container = new MyContainer<MyClass>();
container.Contents.Add(new MyClass());
container.CallAllMyMethodsInContents();

方法 3：

编辑：另一种选择是从 < code>MyContainer 类如下所示：

public class MyContainer
{
    public IList<MyInterface> Contents;
}

并将方法签名更改为

  public void CallAllMethodsInContainer(MyContainer container)

然后代码片段应按以下方式工作：

MyContainer container = new MyContainer();
container.Contents.Add(new MyClass());
this.CallAllMethodsInContainer(container);

请注意，使用此替代方案，容器的 Contents 列表将接受实现的对象的任意组合我的界面。

Answer 2

哇，这个问题最近出现很多。

简短的回答：不，这是不可能的。这就是可能的可能性：

public void CallAllMethodsInContainer<T>(MyContainer<T> container) where T : IMyInterface
{
    foreach (IMyInterface myClass in container.Contents)
    {
        myClass.MyMethod();
    }
}

这就是为什么您尝试的不可能可能的原因（摘自我最近的回答)：

考虑 List 类型。假设您有一个 List 和一个 List

var strings = new List<string>();

// If this cast were possible...
var objects = (List<object>)strings;

// ...crap! then you could add a DateTime to a List<string>!
objects.Add(new DateTime(2010, 8, 23));23));

上面的代码说明了成为（和不成为） 协变类型。请注意，将类型 T 转换为另一个类型 T（其中 D 派生自 B）是如果 T 是协变，则可能（在 .NET 4.0 中）；如果泛型类型参数仅以输出形式出现（即只读属性和函数返回值），则泛型类型是协变的。

可以这样想：如果某种类型 T 总是提供 B，那么总是提供 D< /code> (T) 将能够作为 T 运行，因为所有 D 都是 B 。

顺便说一句，如果一个类型的泛型类型参数仅以输入（即方法参数）的形式出现，那么该类型就是逆变的。如果类型 T 是逆变的，那么它可以转换为 T，尽管这看起来很奇怪。

可以这样想：如果某种类型 T 总是需要 B，那么它可以介入始终需要 B 的类型D 因为所有 D 都是 B。

您的 MyContainer 类既不是协变也不是逆变，因为它的类型参数出现在两个上下文中——作为输入（通过 Contents.Add）和输出（通过 Contents 属性本身）。

Answer 3

这是协方差问题

http://msdn.microsoft.com/en-us /library/dd799517.aspx

您无法将 MyContainer 转换为 MyContainer 因为这样您就可以执行诸如 Contents.添加（新的 AnotherClassThatImplementsIMyInterface()）