协变与逆变是.Net4.0新加入的概念，我看了很多博客文章，可能是我悟性比较差，感觉没有完全讲明白，自己研究了一天终于搞懂了，特此记录一下。
一、简单理解协变和逆变
//协变：子类对象（引用）赋值给父类变量（引用） object obj = null; string str = ""; obj = str; //逆变：父类对象（引用）赋值给子类变量（引用） object obj = null; string str = ""; str = obj; /* str = obj;这段代码大家会发现是错误的，这个赋值是基本操作都是错误的， 那又如何实现逆变这种逆反的赋值操作呢？实际上逆变根本不是逆向将父类 赋给子类的，我慢慢解释... */
二、真正的协变和逆变
概念：
1、以前的泛型系统（或者说没有in/out关键字时），是不能“变”的，无论是“逆”还是“顺（协）”。
2、当前仅支持接口和委托的逆变与协变 ，不支持类和方法。但数组也有协变性。
3、值类型不参与逆变与协变。
协变：Foo<ParentClass> = Foo<ChildClass>
public class TestOut<T> where T : new() { /* * 关键字out因为协变的类型T只能作为输出参数使用，而不能作为输入参数 */ //*****[协变]泛型委托Demo***** //1、创建泛型委托 public delegate T MyFunA<T>(); //默认不支持协变与逆变 public delegate T MyFunB<out T>(); //设置支持协变 //public delegate void MyFunC<out T>(T param);//错误，协变类型只能“出”不能“入” //2、创建委托变量 public MyFunA<object> FunAObject = null; public MyFunA<string> FunAString = null; public MyFunB<object> FunBObject = null; public MyFunB<string> FunBString = null; public MyFunB<int> FunBInt = null; //3、验证结果 public void TestFun() { //FunAObject = FunAString;//错误，不可用协变 FunBObject = FunBString;//正确，可用协变可以完成子类string到父类object的转换 //FunBObject = FunBInt; //错误，值类型不参与协变 } //*****[协变]泛型接口Demo***** //1、创建泛型接口 public interface IMyInterfaceA<T> { } //默认不支持协变与逆变 public interface IMyInterfaceB<out T> { } //设置支持协变 //public interface IMyInterfaceC<out T> //{ // void Test(T param);//错误，协变只能“出”不能“入” //} //2、创建接口变量 public IMyInterfaceA<object> interAObject = null; public IMyInterfaceA<string> interAString = null; public IMyInterfaceB<object> interBObject = null; public IMyInterfaceB<string> interBString = null; public IMyInterfaceB<int> interBInt = null; //3、验证结果 public void TestInterface() { //interAObject = interAString; //错误，不可用协变 interBObject = interBString; //正确，可用协变可以完成子类string到父类object的转换 //interBObject = interBInt; //错误，值类型不参与协变 } }
逆变：Foo<ChildClass> = Foo<ParentClass>
public class TestIn<T> where T : new() { /* * 关键字in因为逆变的类型只能作为输入参数，而不能作为输出参数 */ //*****[逆变]泛型委托***** //1、创建泛型委托 public delegate void MyActionA<T>(T param); //默认不支持协变与逆变 public delegate void MyActionB<in T>(T param); //设置支持逆变 //public delegate T MyActionC<in T>();//错误，逆变只能“入”不能“出” //2、创建委托变量 public MyActionA<object> ActionAObject = null; public MyActionA<string> ActionAString = null; public MyActionB<object> ActionBObject = null; public MyActionB<string> ActionBString = null; public MyActionB<int> ActionBInt = null; //3、验证结果 public void TestAction() { //ActionAString = ActionAObject; //错误，不可用逆变 ActionBString = ActionBObject; //正确，可用逆变可以完成从父类object到子类string的转换 //ActionBInt = ActionBObject; //错误，值类型不参与逆变 } //*****[逆变]泛型接口***** //1、创建泛型接口 public interface IMyInterfaceA<T> { } //默认不支持协变与逆变 public interface IMyInterfaceB<in T> { } //设置支持逆变 //public interface IMyInterfaceC<in T> //{ // T Test();//错误，逆变只能“入”不能“出” //} //2、创建接口变量 public IMyInterfaceA<object> interAObject = null; public IMyInterfaceA<string> interAString = null; public IMyInterfaceB<object> interBObject = null; public IMyInterfaceB<string> interBString = null; public IMyInterfaceB<int> interBInt = null; //3、验证结果 public void TestInterface() { //interAString = interAObject; //错误，不可用逆变 interBString = interBObject; //正确，可用你变可以完成从父类object到子类string的转换 //interBInt = interBObject; //错误，值类型不参与逆变 } }
三、解析协变与逆变（协变是顺序的，逆变并不是逆反的）
这里就是我看别人的博客没有看懂的地方，研究时从这里卡住了半天，想通后发现豁然开朗，现在分享出来
先创建一个协变接口，一个逆变接口
//*****协变接口***** public interface ITestA<out T> { T Test(); } public class TestA<T> : ITestA<T> { public T Test() { //do something... return default(T); } } //*****逆变接口***** public interface ITestB<in T> { void Test(T p); } public class TestB<T> : ITestB<T> { public void Test(T p) { //do something... } }
协变解析：
internal class Program { private static void Main(string[] args) { //写法一 ITestA<object> testA = new TestA<string>(); object obj = testA.Test(); //写法二 ITestA<object> testA1 = null; ITestA<string> testA2 = null; testA1 = testA2; obj = testA1.Test(); /* 执行步骤如下： //先调用父类函数 public object ITestA<object>.Test() { //发现父类函数为接口，函数体由子类实现，所以... //再调用子类函数 public string ITestA<string>.Test() { //do something... } //父类函数调用子类函数，子类函数向外return返回值，由string类型传至object类型 } */ //协变“可出不可入”因为由子类函数向父类函数返回值，子类类型小，父类类型大，所以可以进行安全转换 } }
别的博客中看到以上解释，没看明白，后来才懂，他的意思是：协变时是子类向父类返回值，值类型是由子到父，可以安全转换！
[原式就是主观应该调用的方式，我想调用子类的这个函数]
[变式就是实际运行时调用的方式，先调用父类函数再由父类函数调用子类函数]
//ITest1<object> = ITest1<string> //原式（子类）：string ITest1<string>.Test() // ↓ //变式（父类）：object ITest1<object>.Test()
逆变解析：
internal class Program { private static void Main(string[] args) { //写法一 ITestB<string> testB = new TestB<object>(); testB.Test(""); //写法二 ITestB<string> testB1 = null; ITestB<object> testB2 = null; testB1 = testB2; testB1.Test(""); /* 执行步骤如下： //先调用父类函数 public void ITestB<string>.Test(string param) { //发现父类函数为接口，函数体由子类实现，所以... //再调用子类函数 public void ITestB<object>.Test(object param) { //do something... } //父类函数调用子类函数，并向子类函数传递参数由string类型传至object类型 } */ //逆变“可入不可出”因为由父类函数向子类函数传递参数，父类类型小，子类类型大，所以可以进行安全转换 } }
别的博客中看到以上解释，没看明白，后来才懂，他的意思是：逆变时是父类向子类传参数值，值类型是由子到父，可以安全转换！
[原式就是主观应该调用的方式，我想调用子类的这个函数]
[变式就是实际运行时调用的方式，先调用父类函数再由父类函数调用子类函数]
//ITest2<string> = ITest2<object> //原式（子类）：void ITest2<object>.Test(object param) // ↑ //变式（父类）：void ITest2<string>.Test(string param)
调用执行步骤：
ITestA<object> testA = new TestA<string>();
object obj = testA.Test();
ITestB<string> testB = new TestB<object>();
testB.Test("");
父类变量（引用）调用方法，实际上执行步骤如下：
1、调用父类自己的方法
2、被告知方法体由子类实现
3、父类去调用子类方法
4、【逆变】发现子类方法有参，于是父类传递自己的参数（类型string）到子类（类型object），可以安全转换
5、子类执行方法体功能
6、【协变】将执行的返回值返回给父类
7、【协变】父类接收子类方法返回值，返回值类型为子类的
8、【协变】继续向上返回，发现返回值类型不一样（类型string），所以转为父类方法的类型返回（类型object），可以安全转换
所以这就是为什么【协变只能返回值】，而【逆变只能传递值】，实际协变逆变并没有父类型转子类型的过程，都是使用的子类型转父类型的安全转换
应用场景：微软提倡只要是泛型的接口或者委托都希望使用协变逆变，RedSharper也会有相应的提示，这样做也可以增加【函数传入参数值】、【函数返回值】的扩展性，何乐而不为呢~