C#4.0新特性：协变与逆变中的编程思想

现在我们接着来谈谈C#4.0中一个重要的新特性：协变（Covariance）与逆变（Contravariance）。对于协变与逆变，大家肯定不会感到陌生，但是我相信有很多人不能很清晰地说出他们之间的区别。我希望通过这篇文章能够让读者更加深刻的认识协变与逆变。但是也不排除另一种可能，那就是读者这篇文章你对这两个概念更加模糊。文章一些内容仅代表个人观点，如有不妥，还望指正。

1、两个概念：强类型与弱类型

为了后面叙述方便，我现在这里自定义两个概念：强类型和弱类型。在本篇文章中，强类型和弱类型指的是两个具有直接或者间接继承关系的两个类。如果一个类是另一个类的直接或者间接基类，那么它为弱类型，直接或者间接子类为强类型。后续的介绍中会用到的两个类Foo和Bar先定义在这里。Bar继承自Foo。Foo是弱类型，而Bar则是强类型。

public class Foo { //Others Members... }

public class Bar:Foo { //Others Members... }

有了强类型和弱类型的概念，我们就可以这样的定义协变和逆变：如果类型TBar是基于强类型Bar的类型（比如类型参数为Bar的泛型类型，或者是参数/返回值类型为Bar的委托），而类型TFoo是基于弱类型Foo的类型，协变就是将TBar类型的实例赋值给TFoo类型的变量，而逆变则是将TFoo类型的实例赋值给TBar类型的变量。

2、委托中的协变与逆变的使用

协变和逆变主要体现在两个地方：接口和委托，先来看看在委托中如何使用协变和逆变。现在我们定义了如下一个表示无参函数的泛型委托Function，类型参数为函数返回值的类型。泛型参数之前添加了一个out关键字表示T是一个协变变体。那么在使用过程中，基于强类型的委托Fucntion实例就可以赋值给基于弱类型的委托Fucntion变量。

public delegate T Function<out T>();

class Program
         {
                   static void Main()
                   {
                            Function funcBar = new Function(GetInstance);
                            Function funcFoo = funcBar;
                            Foo foo = funcFoo();
                   }
                   static Bar GetInstance()
                   {
                            return new Bar();
                   }
          }

接下来介绍逆变委托的用法。下面定义了一个名称为Operate的泛型委托，接受一个具有泛型参数类型的参数。在定义泛型参数前添加了in关键字，表示T是一个基于逆变的变体。由于使用了逆变，我们就可以将基于弱类型的委托Operate实例就可以赋值给基于强类型的委托Operate变量。

public delegate void Operate<in T>(T instance);

class Program
          {
                   static void Main()
                   {
                            Operate opFoo = new Operate(DoSth);
                            Operate opBar = opFoo;
                            opBar(new Bar());
                   }
                   static void DoSth(Foo foo)
                   { //Others... }
          }

 3、接口中的协变与逆变的使用

接下来我们同样通过一个简单的例子来说明在接口中如何使用协变和逆变。下面定义了一个继承自 IEnumerable接口的IGroup集合类型，和上面一样，泛型参数T之前的out关键字表明这是一个协变。既然是协变，我们就可以将一个基于强类型的委托IGroup实例就可以赋值给基于弱类型的委托IGroup变量。

public interface IGroup<out T> : IEnumerable
        { }
        public class Group : List, IGroup
         { }
         public delegate void Operate<in T>(T instance); 
        class Program 
        {
                 static void Main() 
                {
                         IGroup groupOfBar = new Group();
                         IGroup groupOfFoo = groupOfBar;
                         //Others...
                 }
         }

下面是一个逆变接口的例子。首先定义了一个IPaintable的接口，里面定义了一个可读写的Color属性，便是实现该接口的类型的对象具有自己的颜色，并可以改变颜色。类型Car实现了该接口。接口IBrush定义了一把刷子，泛型类型需要实现IPaintable接口，in关键字表明这是一个逆变。方法Paint用于将指定的对象粉刷成相应的颜色，表示被粉刷的对象的类型为泛型参数类型。Brush实现了该接口。由于IBrush定义成逆变，我们就可以将基于强类型的委托IBrush实例就可以赋值给基于弱类型的委托IBrush变量。

public interface IPaintable 
        {
                 Color Color
                 {
                         get;
                         set;
                 }
         }
         public class Car : IPaintable
         {
                 public Color Color { get; set; }
          }
         public interface IBrush<in T> where T : IPaintable
         {
                 void Paint(T objectToPaint, Color color);
         }
         public class Brush : IBrush where T : IPaintable 
        {
                 public void Paint(T objectToPaint, Color color)
                 {
                         objectToPaint.Color = color; 
                }
         }
         class Program 
        {
                 static void Main() 
                {
                         IBrush brush = new Brush();
                         IBrush carBrush = brush;
                         Car car = new Car(); 
                        carBrush.Paint(car, Color.Red);
                         Console.WriteLine(car.Color.Name); 
                }
         }

4、从Func看协变与逆变的本质

接下来我们来谈谈协变和逆变的本质区别是什么。在这里我们以我们非常熟悉的一个委托Func作为例子，下面给出了该委托的定义。我们可以看到Func定义的两个泛型参数分别属于逆变和协变。具体来说输入参数类型为逆变，返回值类型为协变。

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

再重申以下这句话“输入参数类型为逆变，返回值类型为协变”。然后，你再想想为什么逆变用in关键字，而协变用out关键字。这两个不是偶然，实际上我们可以将协变/逆变与输出/输入匹配起来。

我们再从另一个角度来理解协变与逆变。我们知道接口代表一种契约，当一个类型实现一个接口的时候就相当于签署了这份契约，所以必须是实现接口中所有的成员。实际上类型继承也属于一种契约关系，基类定义契约，子类“签署”该契约。对于类型系统来说，接口实现和类型继承本质上是一致的。契约是弱类型，签署这份契约的是强类型。

将契约的观点应用在委托上面，委托实际上定义了一个方法的签名（参数列表和返回值），那么参数和返回值的类型就是契约，现在的关键是谁去履行这份契约。所有参数是外界传入的，所以基于参数的契约履行者来源于外部，也就是被赋值变量的类型，所以被赋值变量类型是强类型。而对于代理本身来说，参数是一种输入，也就是一种采用in关键字表示的逆变。

而对于委托的返回值，这是给外部服务的，是委托自身对外界的一种承诺，所以它自己是契约的履行着，因此它自己应该是强类型。相应地，对于代理本身来说，返回值是一种输出，也就是一种采用out关键字定义的协变。

也正式因为这个原因，对于一个委托，你不能将参数类型定义成成协变，也不能将返回类型定义成逆变。下面两中变体定义