.NET 4 泛型中的Covariance 和 Contravariance

在介绍.NET 4泛型的covariance和contravariance之前，先介绍下编程语言类型系统的variance的概念。简单的说covariance使得你能够用一个更具体的类来替代一个本该父层的类。在C#中，引用类型的数组是covariant的，这是从当时的Java中学来的特性，例如:

namespace variance2
{
    public class Animal { }
    public class Dog : Animal { }
    class Program
    {
        static void Main(string[] args)
        {
            Animal[] animals = new Dog[10];
            animals[0] = new Animal();
        }
    }
}

当给animals数组初始化的时候，可以使用它的子类Dog，这里是covariance的。这段代码可以编译通过，但是运行的时候会报如下错误：

Attempted to access an element as a type incompatible with the array.

因为一旦给数组赋值了Dog，实际上它就是一个Dog数组，所以不能再给他赋值Animal。一段能编译通过的代码再运行时发生类型错误并不是好事情，所以在.Net 2引入泛型的时候.net的泛型是invariant的。

List<Animal> listAnimals = new List<Dog>();

这样是不能通过编译的。

List<Dog> listDogs = new List<Dog>();
listDogs.Add(new Animal());

这样也不能通过编译。

.NET2 这样做避免了一些问题，但同时也带来了一些问题，例如:

List<Dog> listDogs = new List<Dog>();
IEnumerable<Animal> enumAnimals = listDogs;

这样是不能编译通过的。实际上，这种编程场景很常见，而且事实上这是类型安全的，因为通过IEnumerable接口，我们只能从enumAnimals中获取值，而不能给他赋值。

 

下面举一个contravariance的例子:

public class Animal
   {
       public int Weight
       {
           get;set;
       }

       public string Name
       {
           get;set;
       }

       public Animal(string name,int weight)
       {
           Name=name; Weight=weight;
       }
   }
   public class Dog : Animal 
   {
       public Dog(string name,int weight):base(name,weight)
       {
       }
   }

   public class WeightComparer : IComparer<Animal>
   {
       public int Compare(Animal x, Animal y)
       {
           return x.Weight - y.Weight;
       }
   }

给动物类加上一个重量的属性，并且实现一个根据重量排序的IComparer类。

class Program
{
    static void Main(string[] args)
    {
        WeightComparer comparer = new WeightComparer();
        List<Animal> animals = new List<Animal>();
        animals.Add(new Animal("Dog", 4));
        animals.Add(new Animal("Mouse", 1));
        animals.Add(new Animal("Tiger",44));
        animals.Sort(comparer);   //works fine
        animals.ForEach(e=>Console.WriteLine(e.Name+" "+e.Weight));

        List<Dog> dogs = new List<Dog>();
        dogs.Add(new Dog("DogA", 12));
        dogs.Add(new Dog("DogB", 10));
        dogs.Sort(comparer);     //compile error
        dogs.ForEach(e => Console.WriteLine(e.Name + " " + e.Weight));
    }
}

注意如果在.net 2中运行，第一段程序是可以正常运行的。第二段程序会导致编译错误，这里本应该的对象是 IComparer<Dog>,但是实际上传给他的是ICompaer<Animal>,是contravariance,这在.net 2中是不允许的,实际上，这种情况也是类型安全的。

 

.Net 4中在泛型参数前可以加上in或者out关键字。in 关键字可以使参数变成contravariant的。out 关键字可以使参数变成covariant的。在.net 类库中，很多泛型接口和委托的声明已经改变。例如，使用out关键字的有:

IEnumerable(Of T), IEnumerator(Of T), IQueryable(Of T) IGrouping(Of TKey, TElement)

使用in关键字的有:

IComparer(Of T), IComparable(Of T), IEqualityComparer(Of T).

因此，上文中的涉及到泛型接口的代码在.NET4中都是可以运行成功的。

 

.Net4中还有一些常用的委托也使用了in,out关键字来声明泛型参数。例如:

Action<in T> 委托，其声明为:

public delegate void Action<in T>( T obj )
可以使用contravariance:

static void Main(string[] args)
{
    Action<Animal> animal = (obj) => { Console.WriteLine(obj.GetType().ToString()); };
    Action<Dog> dog = animal;
    dog(new Dog("Test",1));
}

再例如，Func<T,TResult>委托，声明为:

public delegate TResult Func<in T, out TResult>( T arg )

传入参数可以是contravariant，返回值可以是covariant的。

public class Type1 {}
public class Type2 : Type1 {}
public class Type3 : Type2 {}

public class Program
{
    public static Type3 MyMethod(Type1 t)
    {
        return t as Type3 ?? new Type3();
    }

    static void Main() 
    {
        Func<Type2, Type2> f1 = MyMethod;

        // Covariant return type and contravariant parameter type.
        Func<Type3, Type1> f2 = f1;
        Type1 t1 = f2(new Type3());
        Console.WriteLine(t1.GetType());
    }
}

运行结果是 Type3.