逆变与协变详解

梦里梦外; 2021-06-26 16:06 505阅读 0赞

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

## 变的概念 ##

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

//父类 = 子类
    string str = "string";
    object obj = str;//变了

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

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

//泛型委托：
    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<父类>`） ##

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`泛型参数用作方法返回值的泛型接口时：

public interface IPlayB<in T>
    { 
        T Test();
    }

出现了如下编译错误：

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

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

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

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

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("");

它实际的流程是这样的：  
![image][]

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

Base<object> BaseObject = null;
    Base<string> BaseString = null;
    BaseObject = BaseString;//编译失败
    BaseObject.Test("");

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

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

![image][image 2]

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

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

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

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

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可以通过，那么它的“协变流程图”应该如下：

![image][image 3]

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

The End！

[image]: /images/20210626/e7a2ac23784247cc9cd0baf6d2337aac.png
[image 1]: /images/20210626/c90106221fcc48f69d519e15fd8ac742.png
[image 2]: /images/20210626/bff492a8bdb6423fa971df97c54385ed.png
[Link 1]: http://www.cnblogs.com/Ninputer/archive/2008/11/22/generic_covariant.html
[image 3]: /images/20210626/bb2ae5d6b62e44bcb767268f4d34ee54.png