C#逆变与协变详解

该文章中使用了较多的 委托delegate和lambda表达式，如果你并不熟悉这些，请查看我的文章《》、《匿名委托与lambda表达式》以便帮你建立完整的知识体系。

在c#从诞生到发展壮大的过程中，新知识点不断引入。逆变与协变并不是c#独创的，属于后续引入。在java中同样存在逆变与协变，后续我还会写一篇java逆变协变的文章，有兴趣的朋友可以关注一下。

逆变与协变，听起来很抽象、高深，其实很简单。看下面的代码：

class person
 {

 }
 class student : person
 {

 }
 class teacher: person
 {

 }
 
 class program
 {
  static void main(string[] args)
  {
   list<person> plist = new list<person>();
   plist = new list<student>();
   plist = new list<teacher>();
}
}

在上面的代码中，plist = new list<student>()、plist = new list<teacher>()两句产生编译错误。虽然person是student/teacher的父类，但list<person>类型却不是list<student/teacher>类型的父类，所以上面的赋值语句报类型转换失败错误。

如上这样的赋值操作，在c# 4.0之前是不允许的，至于为什么不允许，类型安全是首要因素。看下面的示例代码：

list<person> plist = new list<student>();
plist.add(new person());
plist.add(new student());
plist.add(new teacher());

如下示例，假设 list<person> plist = new list<student>() 允许赋值，那plist虽然类型为list<person>集合，但实际指向确是list<student>集合。plist.add(new person())，添加操作实际调用的是list<student>.add()。person类型无法安全转换为student，所以这样的集合定义没有意义，所以上面的假设不成立。

但情况在c# 4.0之后发生了变化，并不是"不可能发生的事情发生了"，而是应用的灵活性做出了新的调整。同样的在c# 4.0中上面的程序仍是不被允许的，但却出现了例外。从c# 4.0开始，在泛型委托、泛型接口中，允许特殊情况的发生（实质上并未发生特殊变化，后面说明）。如下示例：

delegate void work<t>(t item);

class person
{
  public string name { get; set; }
}
class student : person
{
  public string like { get; set; }
}
class teacher : person
{
  public string teach { get; set; }
}

class program
{
  static void main(string[] args)
  {
   work<person> worker = (p) => { console.writeline(p.name); }; ;
   work<student> student_worker = (s) => { console.writeline(s.like); };
   student_worker = worker; //此处编译错误
  }
}

根据前面的理论支持，student_worker = worker;的错误很容易理解。但此处我们程序的目的是让 woker  充当 work<student> 的功能，以后调用 student_worker(s)实际调用的是woker(s)。为了满足我们的需求，需要程序做2方面的处理：

1、因在调用student_worker(s)时，实质执行的是woker(s)，所以需要s变量的类型能成功转换为woker需要的参数类型。

2、需要告诉编译器，此处允许将 work<person> 类型的对象赋值给 work<student>类型的变量。

条件1在调用时student_worker()，时编译器会提示要求参数必须是student类型对象，该对象可成功转换为person类型对象。

条件2则需要对woke委托定义进行调整，调整如下：

delegate void workin<in t>(t item);

委托名字改为workin是为却别修改前后的委托，关键之处为<in t>。通过增加 in 关键字，标注该泛型委托的类型参数t，仅作为委托方法的参数来使用。此时上面的程序便可成功编译并执行。

delegate void workin<in t>(t item);
class program
 {
  static void main(string[] args)
  {
   workin<person> woker = (p) => { console.writeline(p.name); };
   workin<student> student_worker = woker;
   student_worker(new student() { name="tom", like="c#" });

  }
 }

对于要求类型参数为子类型，允许赋值类型参数为父类型值的这种情况，称为逆变。逆变在c#中需要用 in 标注泛型的类型参数。逆变虽叫逆变，但只是形式上看似父类对象赋值给子类变量，实质上是方法调用时参数的类型转换。student s = new person()，这是不可能的，这不是逆变是错误。

上面的代码如你能转换为下面的形式，那你就可以忘却逆变，本质比现象更重要????：

delegate void workin<in t>(t item);
 class program
 {
  static void main(string[] args)
  {
   workin<person> woker = (p) => { console.writeline(p.name); };
   workin<student> student_worker = (s)=> { woker(s); };
   student_worker(new student() { name="tom", like="c#" });
  }
 }

协变

 现在修改我们的程序需求，要求work委托执行后返回一个person对象，如下：

 delegate t work<t>(); 
 class program
 {
  static void main(string[] args)
  {
   work<person> worker = () => { return new person(); };
   work<student> student_worker = () => { return new student(); };

   worker = student_worker;
  }
 }

同上 worker = student_worker 无法通过编译，此时我们的目的为：用 work<student>  student_woker 的功能替代 work<person> 的功能，因为 student_woker 执行后返回一个student对象，这完全符合 work<person> 的要求。

如果要实现上面的目的，程序同样需做2方面的处理：

1、因在调用 worker()时，实质执行的是 student_worker()，所以需要 student_worker() 执行结果能功转换为woker 执行后返回的类型。

2、需要告诉编译器，此处允许将 work<student>类型的对象赋值给 work<person> 类型的变量。

此时条件1，上述代码已经满足，对于条件2，需要泛型委托work做如下调整：

delegate t workout<out t>();
委托名字改为workout也为却别修改前后的委托，关键之处为<out t>。通过增加 out 关键字，标注该泛型委托的类型参数t，仅作为委托方法的返回值类型来使用。此时上面的程序便可成功编译并执行。

delegate t workout<out t>();
class program
 {
  static void main(string[] args)
  {
   workout<person> worker = () => { return new person(); };
   workout<student> student_worker = () => { return new student(); };

   worker = student_worker;
   person p = worker();
  }
 }

对于要求泛型类型参数为父类型，允许赋值类型参数为子类型值的这种情况，称为协变。协变在c#中需要用 out 标注泛型的类型参数。

注意：逆变、协变类型说明的区别。根据引出的定义逆变的形式只可能发生在泛型上（泛型接口、泛型委托），而协变的代码形式就比较多，但并不一定是协变。所以在协变中用红色注明，必须是关于泛型参数的情况才是协变。下面这类情况不属于协变（至少我不认为它们是协变）：

person p = new student();

上面的示例代码如你能转换为下面的形式，那你也可以忘却协变????：

delegate t workout<out t>();
class program
 {
  static void main(string[] args)
  {
   
   workout<student> student_worker = () => { return new student(); };
   workout<person> worker = () => { return student_worker (); };
   person p = worker();
  }
 }

通过上面的内容可以发现，逆变、协变其实是方法参数、返回值类型的转换与对委托方法的包装而已。抓住其核心，再看各种形式的代码就简单了。

在c# 4.0 中 你可以查看 action，func的定义，以便更深入理解逆变、协变。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。