协方差如何比多态性更酷......并且不冗余？

Question

.NET 4 引入了协方差。我想它是有用的。毕竟，MS 历尽千辛万苦才把它添加到 C# 语言中。但是，为什么协方差比传统的多态性更有用呢？

我写这个例子是为了理解为什么我应该实现协方差，但我仍然不明白。请赐教。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Sample
{
    class Demo
    {
        public delegate void ContraAction<in T>(T a);

        public interface IContainer<out T>
        {
            T GetItem();
            void Do(ContraAction<T> action);
        }

        public class Container<T> : IContainer<T>
        {
            private T item;

            public Container(T item)
            {
                this.item = item;
            }

            public T GetItem()
            {
                return item;
            }

            public void Do(ContraAction<T> action)
            {
                action(item);
            }
        }

        public class Shape
        {
            public void Draw()
            {
                Console.WriteLine("Shape Drawn");
            }
        }

        public class Circle:Shape
        {
            public void DrawCircle()
            {
                Console.WriteLine("Circle Drawn");
            }
        }

        public static void Main()
        {
            Circle circle = new Circle();
            IContainer<Shape> container = new Container<Circle>(circle);
            container.Do(s => s.Draw());//calls shape

            //Old school polymorphism...how is this not the same thing?
            Shape shape = new Circle();
            shape.Draw();
        }
    }
}

Answer 1

考虑一个需要 IContainer 的 API：

public void DrawShape(IContainer<Shape> container>) { /* ... */ }

您有一个 Container。如何将容器传递给 DrawShape API？如果没有协变，类型 Container 无法转换为 IContainer，需要您重新包装该类型或提出其他解决方法。

在使用大量通用参数的 API 中，这并不是一个罕见的问题。

Answer 2

协方差比多态性更酷，就像长耳大野兔比溜冰鞋更酷一样：它们不是同一件事。

协变和逆变（以及不变性和...全变性...任何人？）处理泛型在继承方面可以走的“方向”。在您的示例中，您正在做同样的事情，但这不是一个有意义的示例。

例如，考虑 IEnumerable 是 out T 的事实。这让我们可以做这样的事情：

public void PrintToString(IEnumerable<object> things)
{
    foreach(var obj in things)
    {
        Console.WriteLine(obj.ToString());
    }
}

public static void Main()
{
    List<string> strings = new List<string>() { "one", "two", "three" };
    List<MyClass> myClasses = new List<MyClass>();

    // add elements to myClasses

    PrintToString(strings);
    PrintToString(myClasses);
}

在以前的 C# 版本中，这是不可能的，因为 List 实现 IEnumerable 和 IEnumerable< /code>，不是 IEnumerable

在某些情况下，可以在以前的版本中解决这种问题，方法是使函数本身通用并使用通用类型推断，在许多情况下产生相同的语法。然而，这并没有解决更大的问题，也绝不是 100% 的解决方法。

Answer 3

这是泛型版本：

object[] arr = new string[5];

我想说是否真的需要它是一个意见问题，因为它可能会引入像这样的错误时发生的错误：

arr[0] = new object(); //Run-time error

但有时它可以非常方便，因为它可以让你重新 -更好地使用代码。

---

编辑：

我忘了 - 如果正确使用的话，您可以通过使用 out 和 in 关键字来防止这些错误。所以没有太大的缺点。