我什么时候应该或不应该使用泛型类型约束？

Question

我有一个基类：

public abstract class StuffBase
{
    public abstract void DoSomething();
}

和两个派生类

public class Stuff1 : StuffBase
{
    public void DoSomething()
    {
        Console.WriteLine("Stuff 1 did something cool!");
    }
    public Stuff1()
    {
        Console.WriteLine("New stuff 1 reporting for duty!");
    }
}

public class Stuff2 : StuffBase
{
    public void DoSomething()
    {
        Console.WriteLine("Stuff 2 did something cool!");
    }
    public Stuff1()
    {
        Console.WriteLine("New stuff 2 reporting for duty!");
    }
}

好吧，现在说我有一个项目列表：

var items = new List<StuffBase>();
items.Add(new Stuff1());
items.Add(new Stuff2());

我希望它们都调用它们的 DoSomething() 方法。 我可以期望只迭代列表并调用它们的 DoSomething() 方法，所以假设我有一个名为 AllDoSomething() 的方法，它只是迭代列表并完成工作

public static void AllDoSomething(List<StuffBase> items)
{
    items.ForEach(i => i.DoSomething());
}

：以下方法？

public static void AllDoSomething<T>(List<T> items) where T: StuffBase
{
    items.ForEach(i => i.DoSomething());
}

尽管语法不同，但这两种方法实际上都在做同样的事情。

它们只是做同一件事的不同方式吗？ 我了解泛型和类型约束，但不明白为什么在这种情况下我会使用一种方法而不是另一种方法。

Answer 1

这是因为到目前为止，C# 还不支持协方差。

更正式地说，在 C# v2.0 中，如果 T 是
U 的子类型，则 T[] 是以下的子类型
U[]，但 G 不是 G 的子类型
（其中 G 是任何泛型类型）。 在
类型论术语，我们描述
通过说 C# 数组来实现此行为
类型是“协变”和通用的
类型是“不变的”。

参考：http://blogs.msdn.com /rmbyers/archive/2005/02/16/375079.aspx

如果您有以下方法：

public static void AllDoSomething(List<StuffBase> items)
{
    items.ForEach(i => i.DoSomething());
}

var items = new List<Stuff2>();
x.AllDoSomething(items); //Does not compile

就好像您使用泛型类型约束一样，它会的。

有关协变和逆变的详细信息]，请查看 Eric Lippert 的系列帖子。

---

其他值得一读的帖子：

• http://www.pabich.eu/blog/archive/2008/02/12/c-generics---parameter-variance-its-constraints-and-how-it.aspx
• http://blogs.msdn.com/ rmbyers/archive/2006/06/01/613690.aspx
• http://msdn.microsoft.com/en-us/library/ms228359(VS.80).aspx
• http://www.csharp411.com/convert- Between-generic-ienumerablet/
• http://research.microsoft.com/apps/pubs/default.aspx?id=64042
• 为什么无法列出= 列表<子>?

Answer 2

假设您有一个列表：

List<Stuff1> l = // get from somewhere

现在尝试：

AllDoSomething(l);

使用通用版本，它将被允许。 对于非通用的，则不会。 这就是本质的区别。 Stuff1 列表不是 StuffBase 列表。 但在一般情况下，您不需要它完全是 StuffBase 的列表，因此它更灵活。

您可以通过首先将 Stuff1 列表复制到 StuffBase 列表中来解决此问题，以使其与非通用版本兼容。 但假设您有一个方法：

List<T> TransformList<T>(List<T> input) where T : StuffBase
{
    List<T> output = new List<T>();

    foreach (T item in input)
    {
        // examine item and decide whether to discard it,
        // make new items, whatever
    }

    return output;
}

如果没有泛型，您可以接受 StuffBase 列表，但随后您必须返回 StuffBase 列表。 如果调用者知道这些项确实属于派生类型，则必须使用强制转换。 因此，泛型允许您保留参数的实际类型，并通过方法将其引导到返回类型。

Answer 3

在您提供的示例中，没有区别，但请尝试以下操作：

List<Stuff1> items = new List<Stuff1>();
items.Add(new Stuff1());
AllDoSomething(items);
AllDoSomething<StuffBase>(items);

第一个调用运行良好，但第二个调用由于通用协方差而无法编译