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的定义,以便更深入理解逆变、协变。

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

(0)

相关推荐

  • C#4.0新特性之协变与逆变实例分析

    本文实例讲述了C#4.0新特性的协变与逆变,有助于大家进一步掌握C#4.0程序设计.具体分析如下: 一.C#3.0以前的协变与逆变 如果你是第一次听说这个两个词,别担心,他们其实很常见.C#4.0中的协变与逆变(Covariance and contravariance)有了进一步的完善,主要是两种运行时的(隐式)泛型类型参数转换.简单来讲,所谓协变(Covariance)是指把类型从"小"升到"大",比如从子类升级到父类:逆变则是指从"大"变到

  • c#协变和逆变实例分析

    本文实例讲述了c#协变和逆变的原理及应用.分享给大家供大家参考.具体如下: 由子类向父类方向转变是协变,用out关键字标识,由父类向子类方向转变是逆变,用in关键字 协变和逆变的应用   一. 数组的协变 复制代码 代码如下: Animal[] animalArray = new Dog[]{}; 说明:声明的数组数据类型是Animal,而实际上赋值时给的是Dog数组:每一个Dog对象都可以安全的转变为Animal.Dog向Animal方法转变是沿着继承链向上转变的所以是协变   二. 委托中的

  • C#逆变与协变详解

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

  • C/C++ 双链表之逆序的实例详解

    C/C++ 双链表之逆序的实例详解 一.结点结构 双向链表的数据结构定义如下: typedef struct node { ElemType data; struct node *prior struct node *next; }list; 其中,ElemType可以是任意数据类型如int.float或者char等,在算法中,规定其默认为int类型. 二.带头结点 本文描述的是双向链表逆序,链表逆序需要维护3个指针,分别指向前一个节点.当前节点和下一个节点,具体代码如下: list *reve

  • YGC前后新生代是否变大分析详解

    问题描述 我们都知道gc是为了释放内存,但是你是否碰到过ygc前后新生代反增不减的情况呢?gc日志效果类似下面的: 2016-05-18T15:06:13.011+0800: [GC [ParNew (promotion failed): 636088K->690555K(707840K), 0.2958900 secs][CMS: 1019739K->1019733K(1310720K), 2.6208600 secs] 1655820K->1655820K(2018560K), [C

  • 浅谈Java中的桥接方法与泛型的逆变和协变

    目录 1. 泛型的协变 1.1 泛型协变的使用 1.2 泛型协变存在的问题 1.2.1 Java当中桥接方法的来由 1.2.2 为什么泛型协变时,不允许添加元素呢 1.2.3 从Java字节码的角度去看桥接方法 2. 泛型逆变 2.1 泛型逆变的使用 2.2 泛型逆变会有什么问题 3.协变与逆变-PECS原则 泛型的协变和逆变是什么?对应于Java当中,协变对应的就是<? extends XXX>,而逆变对应的就是<? super XXX>. 1. 泛型的协变 1.1 泛型协变的使

  • C语言递归实现字符串逆序的方式详解

    C语言实现字符串逆序,具体内容如下所示: 一.迭代的方式实现 贴上代码:迭代的方式实现 '//字符串逆序:不可用字符串操作函数' #include <stdio.h> void swap(char* ch1, char* ch2) '//交换两个字符串' { char tmp = *ch1; *ch1 = *ch2; *ch2 = tmp; } int my_strlen(char* str) '//实现计算字符串字节数' { int count = 0; while (*str != '\0

  • 详析C#的协变和逆变

    目录 为啥C#需要协变和逆变? 协变(Covariance) 逆变(Contravariance) 前言: 在引用类型系统时,协变.逆变和不变性具有如下定义. 这些示例假定一个名为 Base 的基类和一个名为 Derived的派生类. Covariance 使你能够使用比原始指定的类型派生程度更大的类型. 你可以将 IEnumerable 的实例分配给 IEnumerable 类型的变量. Contravariance 使你能够使用比原始指定的类型更泛型(派生程度更小)的类型. 你可以将 Act

  • C#泛型详解

    这篇文章主要讲解C#中的泛型,泛型在C#中有很重要的地位,尤其是在搭建项目框架的时候. 一.什么是泛型 泛型是C#2.0推出的新语法,不是语法糖,而是2.0由框架升级提供的功能. 我们在编程程序时,经常会遇到功能非常相似的模块,只是它们处理的数据不一样.但我们没有办法,只能分别写多个方法来处理不同的数据类型.这个时候,那么问题来了,有没有一种办法,用同一个方法来处理传入不同种类型参数的办法呢?泛型的出现就是专门来解决这个问题的. 二.为什么使用泛型 先来看下面一个例子: using System

  • C#泛型的使用及示例详解

    目录 一.什么是泛型 二.为什么使用泛型 三.泛型类型参数 四.泛型类 五.泛型约束 六.泛型的协变和逆变 七.泛型缓存 这篇文章主要讲解C#中的泛型,泛型在C#中有很重要的地位,尤其是在搭建项目框架的时候. 一.什么是泛型 泛型是C#2.0推出的新语法,不是语法糖,而是2.0由框架升级提供的功能. 我们在编程程序时,经常会遇到功能非常相似的模块,只是它们处理的数据不一样.但我们没有办法,只能分别写多个方法来处理不同的数据类型.这个时候,那么问题来了,有没有一种办法,用同一个方法来处理传入不同种

  • php反序列化之字符串逃逸详解

    目录 php反序列化–字符串逃逸 过滤后字符串变多 字符串变多原理详解 过滤后字符串变少 总结 php反序列化–字符串逃逸 PHP反序列化的字符串逃逸,一共分有两种情况,情况一:过滤后字符串变多,情况二:过滤后字符变少(本篇文章默认已有反序列化相关知识基础) 过滤后字符串变多 以ctfshow-web262为例讲解: error_reporting(0); class message{ public $from; public $msg; public $to; public $token='u

  • 详解c# 协变和逆变

    基本概念 协变:能够使用比原始指定的派生类型的派生程度更大(更具体)的类型.例如 IFoo<父类> = IFoo<子类> 逆变:能够使用比原始指定的派生类型的派生程度更新(更抽象)的类型.例如 IBar<子类> = IBar<父类> 关键字out和in 协变和逆变在泛型参数中的表现方式,out关键字表示协变,in关键字表示逆变.二者只能在泛型接口或者委托中使用. 理解协变和逆变 看完上面的定义是不是一脸懵逼~~~.看不懂就对了,且定义语句的歧义性很大.让我们

随机推荐