C#4.0泛型的协变，逆变深入剖析

 
     C#4.0中有一个新特性：协变与逆变。可能很多人在开发过程中不常用到，但是深入的了解他们，肯定是有好处的。
     协变和逆变体现在泛型的接口和委托上面，也就是对泛型参数的声明，可以声明为协变，或者逆变。什么？泛型的参数还能声明？对，如果有了参数的声明，则该泛型接口或者委托称为“变体”。

1. List<汽车> 一群汽车 = new List<汽车>();
2. List<车子> 一群车子 = 一群汽车;

复制代码

     显然，上面那段代码是会报错的， 虽然汽车继承于车子，可以隐士转换为车子，但是List并不继承于List，所以上面的转换，是行不通的。

1. IEnumerable<汽车> 一群汽车 = new List<汽车>();
2. IEnumerable<车子> 一群车子 = 一群汽车;

复制代码

然而这样却是可以的。那么IEnumerable接口有什么不同呢，我们且看编译器的提示：

我们可以看到，泛型参数的，用了一个“out”关键字作为声明。看来，关键是这个在起作用了。
 “协变”是指能够使用与原始指定的派生类型相比，派生程度更大的类型。 

 “逆变”则是指能够使用派生程度更小的类型。逆变，逆于常规的变。

协变和逆变，使用“out”，和“in”两个关键字。但是只能用在接口和委托上面，对泛型的类型进行声明

当声明为“out”时，代表它是用来返回的，只能作为结果返回，中途不能更改。

当声明为"in"时，代表它是用来输入的，只能作为参数输入，不能被返回。

回到上面的例子，正因为“IEnumerable”接口声明了out，所以，代表参数T只能被返回，中途不会被修改，所以，IEnumerable 一群车子 = 一群汽车；  这样的强制转换

是合法的，IL中实际上是作了强制转换的。

 IEnumerable是NET中自带的，其余还有如下接口和委托：

1. 接口：           <br>            IQueryable<out T>
2.             IEnumerator<out T>
3.             IGrouping<out TKey,out TElement>
4.             IComparer<in T>
5.             IEqualityComparer<in T>
6.             IComparable<in T>
7. 委托：<br>            System.Action<in T>
8.             System.Func<Out Tresult>
9.             Predicate<in T>
10.             Comparison<in T>
11.             Converter<in TInput,out TOutput>

复制代码

此外，我们自己定义泛型接口的时候也可以使用协变和逆变，我们不妨来看一个示例，来体现协变的特征

1.     interface 接口<out T>
2.     {
3.         T 属性 { get; set; }
4.     }

复制代码

我定义一个接口，一个具有get和set访问器的属性，然而，编译是报错的，提示：变体无效: 类型参数“T”必须为对于“test.接口.属性”有效的 固定式。“T”为 协变。
正因为我声明了T为协变，所以，T只能被返回，不允许被修改，所以，如果去掉“set”访问器，才可以编译通过。
同样，如果我在“接口”中声明一个方法
void 方法(T t);
同样是会报错的，T被声明了协变，“方法(T t)”的存在就不可取。

1. class Program
2.     {
3.         static void Main(string[] args)
4.         {
5.             接口<汽车> 一群汽车 = new 类<汽车>();
6.             接口<车子> 一群车子 = 一群汽车;
7.         }
8.     }
9.     interface 接口<out T>
10.     {
11.         T 属性
12.         {
13.             get;
14.         }
15.     }
16.     class 类<T> : 接口<T>
17.     {
18.         public T 属性
19.         {
20.             get { return default(T); }
21.         }
22.     }

复制代码

上面的代码是可以编译通过的，因为泛型接口“接口”声明了协变，所以“接口 一群车子 = 一群汽车;”是可以强制转换成功的，看吧，我们自己声明的同样可以实现目的。
 如果我把以上的代码，把“out”改成“in”呢？ 显然不行，因为声明“in”规定了T不能被返回，编译无法通过的。
然而下面的代码是正确的：

1.     interface 接口<in T>
2.     {
3.         void 方法(T t);
4.     }
5.     class 类<T> : 接口<T>
6.     {
7.         public void 方法(T t)
8.         {
9.            
10.         }
11.     }

复制代码

声明“in”不允许被返回，但是可以进行更改。
接着看：

1.         static void Main(string[] args)
2.         {
3.             接口<车子> 一群车子 = new 类<车子>();
4.             接口<汽车> 一群汽车 = 一群车子;
5.         }

复制代码

啊，这怎么也可以啊，“车子”是父类，“汽车”是子类，汽车转换为车子正常，车子转换为汽车，这样也行？
其实“车子”也好，“汽车”也好，在这里都只是泛型参数，并不是他们俩之间的转换，这个基础的概念必须明白，别绕进去了。
这就是逆变。因为“接口”声明了“in”关键字，声明为逆变，让参数去接受一个相对更“弱“的类型，其实是让一个参数的类型，更加具体化，更明确化的一个过程。
 
 
　　
 

 

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！