泛型类型的协变（covariant）和逆变

官网：http://msdn.microsoft.com/zh-cn/library/dd799517.aspx

原文链接：http://book.51cto.com/art/201112/308570.htm

 参考链接：http://www.cnblogs.com/yukaizhao/archive/2011/10/27/xiebian-nibian.html

1.3.4  泛型类型的协变（covariant）和逆变（contravariant）

在.NET 4.0之前的版本中，泛型类型是不支持协变和逆变的，但是委托类型的参数是支持协变和逆变的。什么是协变和逆变呢？在编程语言中，“协变”是指能够使用与原始指定的派生类型相比派生程度更大的类型；“逆变”则是指能够使用派生程度更小的类型。

下面的代码很好地演示了委托类型的协变。假定有一个类Animals，从其派生出一个子类Dogs，那么当定义一个委托，该委托返回Animals。用户也可以将一个返回Dogs的委托赋值给该委托，称之为协变，见代码1.4。

代码1.4  委托的协变

1. class Program  
2.     {  
3.         public delegate Animals HandlerMethod();    //返回Animals的委托  
4.         public static Animals FirstHandler()        //返回Animals的方法实现  
5.         {  
6.             Console.WriteLine("返回Animals的委托");  
7.             return null;  
8.         }  
9.         public static Dogs Secondhandler()          //返回Dogs的方法实现  
10.         {  
11.             Console.WriteLine("返回Dogs的委托");  
12.             return null;  
13.         }  
14.         static void Main(string[] args)  
15.         {  
16.             HandlerMethod handler1 = FirstHandler;  //标准委托  
17.             HandlerMethod handler2 = Secondhandler; //委托协变  
18.         }  
19.     }  
20.     // 定义一个Animals的类  
21.     public class Animals  
22.     {  
23.         public string  Location { get; set; }  
24.     }  
25.     // 定义一个派生自Animals的Dogs类  
26.     public class Dogs : Animals  
27.     {  
28.         public string Cry { get; set; }  
29.     } 

在上面的代码中，首先定义了Animals类和Dogs类，然后定义了一个名为HandlerMethod的委托，该委托返回Animals类型的 值。在Main()方法中，分别赋给一个返回Animals类型的值和一个返回Dogs类型值的方法。可以看到，由于委托的协变特性，使得本来返回一个 Animals的委托可以接受一个返回Dogs的委托。

.NET 4.0引入了in/out参数，使泛型类型的协变和逆变得以实现。比如定义一个泛型接口或者是泛型委托，可以使用out关键字，将泛型类型参数声明为协变。协变类型必须满足条件：类型仅用作接口方法的返回类型，不用作方法参数的类型。

可以使用in关键字，将泛型类型参数声明为逆变。逆变类型只能用作方法参数的类型，不能用作接口方法的返回类型。逆变类型还可用于泛型约束。下面的示例演示了如何使用in/out参数来设置泛型类型的协变和逆变。协变的使用见代码1.5。

代码1.5  泛型的协变

1. interface ITest<out T>                  //定义一个支持协变的接口  
2. {  
3.     T X { get; }                            //属性  
4.     T M();                                  //返回T类型的方法  
5. }  
6. //定义一个实现接口的泛型类  
7. class TestClass<T> : ITest<T> 
8.   where T : Base, new()                 //约束T要派生自Base，具有构造函数  
9. {  
10.     public T X { get; set; }  
11.     //实现泛型方法  
12.     public T M()  
13.     {  
14.         return new T();  
15.     }  
16. }  
17. //定义两个类  
18. class Base { }  
19. class Derived : Base { }  
20. class Program  
21. {  
22.     static void Main(string[] args)  
23.     {  
24.         ITest<Derived> _derived =   
25.             new TestClass<Derived> { X = new Derived() };                                       //使用对象初始化语法赋初值  
26.         ITest<Base> _base = _derived;   //泛型协变  
27.         Base x = _base.X;   
28.         Base m = _base.M();  
29.     }  
30. } 

在上面的代码中，定义了一个泛型接口ITest，注意使用了out参数以支持协变。然后TestClass泛型类实现了接口，并且定义了泛型约束指 定T类型必须是派生自Base类的子类。可以看到在Main主窗体中，定义了一个ITest的接口，然后利用泛型的协变特性来进行泛型类型之间的变换。

与协变相反的是，逆变是将基类转换为派生类，泛型逆变有如下两条规则：

泛型参数受in关键字约束，只能用于属性设置或委托（方法）参数。

隐式转换目标的泛型参数类型必须是当前类型的“继承类”。

例如，代码1.6定义了一个接口，演示了哪些是允许协变，哪些是允许逆变的。

代码1.6  接口的逆变

1. interface ITest<in T> 
2. {  
3.     T X  
4.     {  
5.         get;    //获取属性不允许逆变  
6.         set;    //设置属性允许逆变!  
7.     }  
8.     T M(T o);   //只允许方法参数，不能作用于方法返回值  
9. } 

与协变相反，逆变符合多态性的规律，逆变有些令人费解，不过逆变主要是为泛型委托准备的。逆变的使用如代码1.7所示。

代码1.7  委托的逆变

1. class Program  
2. {  
3.     static void Main(string[] args)  
4.     {  
5.         Action<Base> _base = (o) => Console.WriteLine(o);//定义一个Base基类  
6.         Action<Derived> _derived = _base;       //使用协变将基类转换为派生类  
7.         _derived(new Derived());                    //逆变的效果  
8.     }  
9. } 

以上代码中创建了一个委托，是基于Base类，但是在后面的赋值语句中，将基类赋给派生类，形成了逆变。