逆变与协变详解

逆变（contravariant）与协变（covariant）是C#4新增的概念，许多书籍和博客都有讲解，我觉得都没有把它们讲清楚，搞明白了它们，可以更准确地去定义泛型委托和接口，这里我尝试画图详细解析逆变与协变。

变的概念

我们都知道.Net里或者说在OO的世界里，可以安全地把子类的引用赋给父类引用，例如：


1

2

3

//父类 = 子类

string str = "string";

object obj = str;//变了

而C#里又有泛型的概念，泛型是对类型系统的进一步抽象，比上面简单的类型高级，把上面的变化体现在泛型的参数上就是我们所说的逆变与协变的概念。通过在泛型参数上使用in或out关键字，可以得到逆变或协变的能力。下面是一些对比的例子：

协变（Foo<父类> = Foo<子类> ）：


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

//泛型委托：

public delegate T MyFuncA<T>();//不支持逆变与协变

public delegate T MyFuncB<out T>();//支持协变

MyFuncA<object> funcAObject = null;

MyFuncA<string> funcAString = null;

MyFuncB<object> funcBObject = null;

MyFuncB<string> funcBString = null;

MyFuncB<int> funcBInt = null;

funcAObject = funcAString;//编译失败，MyFuncA不支持逆变与协变

funcBObject = funcBString;//变了，协变

funcBObject = funcBInt;//编译失败，值类型不参与协变或逆变

//泛型接口

public interface IFlyA<T> { }//不支持逆变与协变

public interface IFlyB<out T> { }//支持协变

IFlyA<object> flyAObject = null;

IFlyA<string> flyAString = null;

IFlyB<object> flyBObject = null;

IFlyB<string> flyBString = null;

IFlyB<int> flyBInt = null;

flyAObject = flyAString;//编译失败，IFlyA不支持逆变与协变

flyBObject = flyBString;//变了，协变

flyBObject = flyBInt;//编译失败，值类型不参与协变或逆变

//数组：

string[] strings = new string[] { "string" };

object[] objects = strings;

逆变（Foo<子类> = Foo<父类>）


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

public delegate void MyActionA<T>(T param);//不支持逆变与协变

public delegate void MyActionB<in T>(T param);//支持逆变

public interface IPlayA<T> { }//不支持逆变与协变

public interface IPlayB<in T> { }//支持逆变

MyActionA<object> actionAObject = null;

MyActionA<string> actionAString = null;

MyActionB<object> actionBObject = null;

MyActionB<string> actionBString = null;

actionAString = actionAObject;//MyActionA不支持逆变与协变,编译失败

actionBString = actionBObject;//变了，逆变

IPlayA<object> playAObject = null;

IPlayA<string> playAString = null;

IPlayB<object> playBObject = null;

IPlayB<string> playBString = null;

playAString = playAObject;//IPlayA不支持逆变与协变,编译失败

playBString = playBObject;//变了，逆变

来到这里我们看到有的能变，有的不能变，要知道以下几点：

  • 以前的泛型系统（或者说没有in/out关键字时），是不能“变”的，无论是“逆”还是“顺（协）”。
  • 当前仅支持接口和委托的逆变与协变 ，不支持类和方法。但数组也有协变性。
  • 值类型不参与逆变与协变。

那么in/out是什么意思呢？为什么加了它们就有了“变”的能力，是不是我们定义泛型委托或者接口都应该添加它们呢？

原来，在泛型参数上添加了in关键字作为泛型修饰符的话，那么那个泛型参数就只能用作方法的输入参数，或者只写属性的参数，不能作为方法返回值等，总之就是只能是“入”，不能出。out关键字反之。

当尝试编译下面这个把in泛型参数用作方法返回值的泛型接口时：


1

2

3

4

public interface IPlayB<in T>

{

    T Test();

}

出现了如下编译错误：

错误    1    方差无效: 类型参数“T”必须为“CovarianceAndContravariance.IPlayB<T>.Test()”上有效的 协变式。“T”为 逆变。

到这里，我们大致知道了逆变与协变的相关概念，那么为什么把泛型参数限制为in或者out就可以“变”呢？下面尝试画图解释原理。

协变不是理所当然的，逆变也没有“逆”

我们先来看看不支持逆变与协变的泛型，把子类赋给父类，再执行父类方法的具体流程，对于这样一个简单的例子的Test方法：


1

2

3

4

5

6

7

8

9

10

public interface Base<T>

{

    T Test(T param);

}

public class Sub<T> : Base<T>

{

    public T Test(T param) { return default(T); }

}

Base<string> b = new Sub<string>();

b.Test("");

它实际的流程是这样的：

即调用父类的方法，其实实际是调用子类的方法。可以看到，这个方法能够安全的调用，需要两个条件：1.变式（父）的方法参数能安全转为原式（子）的 参数；2.原式（子）的返回值能安全的转为变式的返回值。不幸的是参数的流向跟返回值的流向是相反的，所以对于既是in，又是out的泛型参数来说，肯定 是行不通的，其中一个方向必然不能安全转换的。例如，对上面的例子，我们尝试“变”：


1

2

3

4

Base<object> BaseObject = null;

Base<string> BaseString = null;

BaseObject = BaseString;//编译失败

BaseObject.Test("");

这里的“实际流程”如下，可以看到，参数那里是object是不能安全转换为string，所以编译失败：

看到这里如果都明白的话，我们不难得到逆变与协变的”实际流程图”（记住，它们是有in/out限制的）:

可以看到，从”实际流程图”来看，逆变根本没有“逆”，都离不开只能安全地把子类的引用赋给父类引用这个根本。

来到这里应该基本理解逆变与协变了，不过装配脑袋的这篇文章有个更高级的问题，原文也有解答，这里我用上面画图的方式去理解它。

图解逆变与协变的相互作用

问题的提出，你知道那个正确吗？


1

2

3

4

5

6

7

8

9

10

11

public interface IBar<in T> { }

//应该是in

public interface IFoo<in T>

{

    void Test(IBar<T> bar);

}

//还是out

public interface IFoo<out T>

{

    void Test(IBar<T> bar);

}

答案是，如果是in的话，会编译失败，out才正确（当然不要泛型修饰符也能通过编译，但IFoo就没有协变能力了）。这里的意思就是说，一个有协 变（逆变）能力的泛型（IBar），作为另一个泛型（IFoo）的参数时，影响到了它（IFoo）的泛型的定义。乍一看以为是in的其中一个陷阱是T是在 Test方法的参数里的，所以以为是in。但这里Test的参数根本不是T，而是IBar<T>。

我们画个图来理解它。既然out可以通过，那么它的“协变流程图”应该如下：

图跟前面那些大致一样，但理解它要跟问题相反（上面问题是先定义好IBar，再去定义IFoo）。1.我们定义好一个有协变能力的IFoo,这是前 提。2.可以推出，上面的流程是成立的。3.这个流程重点是参数流向，要使整个流程成立，就必须使IBar<string> = IBar<object>成立，这不就是逆变吗？整个结论就是，有协变能力的IFoo要求它的泛型参数（IBar）有逆变能力。其实根据上面的箭头也可以理解，因为原式和变式的变向跟参数的变向是相反的，导致了它们要有相反的能力，这就是装配脑袋文章说的：方法参数的协变-反变互换原则。根据这个原理，也很容易得出，如果Test方法的返回值是IBar<T>，而不是参数，那么就要求IBar<T>要有协变能力，因为返回值的箭头与原式和变式的变向的箭头是同向的。

The End！

转自：http://www.cnblogs.com/lemontea/archive/2013/02/17/2915065.html

时间： 2024-08-26 06:29:06

逆变与协变详解的相关文章

Scala 深入浅出实战经典 第81讲：Scala中List的构造是的类型约束逆变、协变、下界详解

王家林亲授<DT大数据梦工厂>大数据实战视频 Scala 深入浅出实战经典(1-97讲)完整视频.PPT.代码下载:百度云盘:http://pan.baidu.com/s/1c0noOt6 腾讯微云:http://url.cn/TnGbdC 360云盘:http://yunpan.cn/cQ4c2UALDjSKy 访问密码 45e2土豆:http://www.tudou.com/programs/view/ceac2IoB-ik/优酷:http://v.youku.com/v_show/id_

Scala中List的构造是的类型约束逆变、协变、下界详解

学习了Scala中List的构造是的类型约束逆变.协变.下界详解,列表中用::加入父类的对象,列表会协变为父类,例子如下: Def :: [B>:A](x:B):List(B)= New scala:collection.imutable.::(x,this) 王家林亲授<DT大数据梦工厂>大数据实战视频“Scala深入浅出实战经典”视频.音频和PPT下载!第81讲:Scala中List的构造是的类型约束逆变.协变.下界详解腾讯微云:http://url.cn/UNeLA2百度云盘:ht

C# 逆变与协变

原文:C# 逆变与协变 该文章中使用了较多的 委托delegate和Lambda表达式,如果你并不熟悉这些,请查看我的文章<委托与匿名委托>.<匿名委托与Lambda表达式>以便帮你建立完整的知识体系. 在C#从诞生到发展壮大的过程中,新知识点不断引入.逆变与协变并不是C#独创的,属于后续引入.在Java中同样存在逆变与协变,后续我还会写一篇Java逆变协变的文章,有兴趣的朋友可以关注一下. 逆变与协变,听起来很抽象.高深,其实很简单.看下面的代码: class Person {

Java 逆变与协变

最近一直忙于学习模电.数电,搞得头晕脑胀,难得今天晚上挤出一些时间来分析一下Java中的逆变.协变.Java早于C#引入逆变.协变,两者在与C#稍有不同,Java中的逆变.协变引入早于C#,故在形式没有C#直观(Google推出的基于jvm的Kotlin语音,则完全走向了C#的路线).Java中逆变.协变,在泛型集合使用中更多些.更直观(像C#中的用法在Java中较少出现,但并非不可). 正常泛型集合的使用 示例代码如下: public static void main(String[] arg

泛型之逆变和协变总结

泛型之逆变和协变总结 c# 泛型 逆变 协变 变的概念 协变(Foo<父类> = Foo<子类> ) 逆变(Foo<子类> = Foo<父类>) 逆变与协变的相互作用 变的概念 //父类 = 子类 string str = "string";  object obj = str;//变了  协变(Foo<父类> = Foo<子类> ) //泛型委托: public delegate T MyFuncA<T&g

Java中的逆变与协变（转）

看下面一段代码 Number num = new Integer(1); ArrayList<Number> list = new ArrayList<Integer>(); //type mismatch List<? extends Number> list = new ArrayList<Number>(); list.add(new Integer(1)); //error list.add(new Float(1.2f)); //error 有人会

Java中的逆变与协变

看下面一段代码 Number num = new Integer(1); ArrayList<Number> list = new ArrayList<Integer>(); //type mismatch List<? extends Number> list = new ArrayList<Number>(); list.add(new Integer(1)); //error list.add(new Float(1.2f)); //error 有人会

OOP中的逆变和协变

逆变和协变在存在于强类型语言中,尽管非常少提及,可是里面蕴含了面向对象的世界观.感谢和我一起讨论这个问题的人. 这里用了C#.Scala的语法作为演示样例,事实上逆变和协变的概念跟语言本身关系不大,事实也是如此. 一.定义 逆变的參数能够由指定的类型的子类型取代,协变的參数能够由指定类型的父类型取代. Scala中的逆变声明:Function[-A,+B] ;当中泛型-A为逆变类型.在实例化时,能够使用A类型或者A类的子类型. 二.协变与逆变的用途不同 1.语义 Scala中,函数的原型之中的一

c#的逆变和协变

1.逆变和协变只能用于接口和委托,协变和逆变要声明 in 和out,不声明则不支持逆变和协变 2.List<T>不支持逆变和协变 3.逆变和协变要类型安全,接口的方法 返回类型和参数 要和实现的方法的返回类型和参数相互转换 协变和逆变 IDAL<Animal> dal=new DAL<Dog>(); dal.add(T); //报错,T类型是Animal ,添加的是Animal及其子类,但是add方法的实际引用是add(T1) //T1是Dog类型的, 那么 T(Ani