解读经典《C#高级编程》最全泛型协变逆变解读 页127-131.章4

本文目录

前言

本篇继续讲解泛型。上一篇讲解了泛型类的定义细节。本篇继续讲解泛型接口。

泛型接口

使用泛型可定义接口,即在接口中定义的方法可以带泛型参数。然后由继承接口的类实现泛型方法。用法和继承泛型类基本没有区别。

不变、协变和逆变

在.Net4.0之前,泛型接口是不变的。.Net4.0通过协变和逆变为泛型接口和泛型委托增加了重要的扩展。

注:本书总体非常好,但在协变和逆变方面,我认为是有缺陷的。我一直偏好通过读书籍来了解技术,而不是逛论坛,但协变和逆变的问题我研究了本书多次,都没搞懂而放弃了,反正平时不需要理解这个也能编程,问题不大。但今天要做课程输出了,就必须得搞懂了。
然后我就结合网络上的文章来帮助理解,发现本书的命名和微软官方的命名的不同。本书中叫“协变”和“抗变”,而微软官方叫协变和逆变。在我最终理解清楚了这两个概念后,我认为“抗变”的命名是不合理的。所以我还是采用了微软官方的说法。而可能正是因为“抗变”的概念误导而导致逻辑分析时一直理不顺。后面我也会稍加分析为什么抗变的命名不合理。

要理解协变和逆变,并不容易。我网上搜索了不少文章。包括我前几次研究没透彻的那几次,也没少在网上找文章,但我认为都有这样或者那样的问题没讲清楚。所以,我本篇文章讲协变和逆变,也不一定能让大家都理解。但我尽量针对我理解过程中的困难,和网上的文章不足,重新构思整个理解思路,尽量把来龙去脉都交代到位。

注:泛型委托有同样的课题,原理相同,这里不表,后面委托章节会再提及

首先,协变和逆变,对应的是“不变”的概念。什么是不变:

string val1 = \"abc\";                            //声明类型 = 实例化类型,是所谓不变
List<string> list1 = new List<string>();        //声明泛型类型 = 实例化泛型类型,是所谓不变

其次,协变和逆变是个通用概念,不只是泛型接口或者泛型委托的专有概念:

object user = new User();                       //实例化类型是声明类型的子类,是所谓协变
IEnumerable<object> list2 = new List<string>(); //实例化泛型类型是声明泛型类型的子类,是所谓协变(这同时也是泛型接口)

上面举了协变的例子,逆变先不举例,这个比较逆天,要先有铺垫知识后面才能继续讲。
在这个例子里,我们可以对协变的概念用土话再描述下,所谓协变,是“符合对象继承规则,符合编译器验证规则,在类型间能够顺畅的转变,即所谓协变”。而逆变呢,并不是“不能够顺畅的转变”(那就是“抗变”了),我认为是不对的。逆变我认为应该理解为:“反向的变,逆向的变”

第三,关注类型转换的矛盾。回到泛型接口,泛型接口实现的内部代码和外部代码间的类型转换点在哪里?当然是在泛型接口的方法上,这是泛型接口的“界面”。而方法中定义的返回值和实际返回值可能是继承关系,定义的传入参数和实际传入参数也可能是继承关系。而这将导致问题,从而最终需要通过给T增加关键字in或者out,来限制方法参数和返回值的行为。因此,我们下面需要仔细分析泛型接口的方法的传入参数和返回值。

第四,在讲协变和逆变前,先举个“不变”的泛型例子作为基础。这个例子中,T既作为方法参数,又作为方法返回值。

/// <summary>
/// 同时有输入T和输出T的泛型
/// </summary>
/// <typeparam name=\"T\"></typeparam>
public interface IBase<T>
{
    T Test(T param);        //T既作为传入参数,又作为传出的返回值
}
public class Sub<T> : IBase<T>
{
    public T Test(T param) { return default(T); }
}

/// <summary>
/// 泛型的\"不变\"测试
/// </summary>
public static class Gen
{
    public static void Test()
    {
        IBase<string> b = new Sub<string>();    //声明泛型类型 = 实例化泛型类型: 即所谓“不变”
        var result = b.Test(\"\");

        Console.ReadKey();
    }
}

如果,在使用过程中,泛型类型是“不变”的,那么就没有协变和逆变的问题。但我们也需要探究这段代码执行的原理,为理解协变和逆变打下基础。下面这个图是我在网上一片文章上找的,描述的就是执行b.Test(\"\")时的执行流程,务必读懂:

执行过程:

  1. 执行IBase<string>.Test(\"\"),泛型类型是string
  2. 因为创建的实例是Sub<string>,所以调用的是Sub<string>.Test(\"\")
  3. 执行结果返回类型是string
  4. 结果再转化为IBase<string>.Test(\"\")的返回值,也是string

因为实例化的泛型类型是不变的(参数和返回值都是string),所以执行过程中没有发生泛型类型的类型转换,所以执行成功。

第五,协变需求的产生,以及问题的出现。如果是按上面的方式,在泛型接口中就无法体现继承关系的优势。因为只能用确定类作为泛型类型,不能同时使用基类和派生类。那么我们尝试在以上案例的基础上尝试一下使用基类和派生类。
上述代码修改点:将声明的string泛型类型改为object泛型类型,其他不变。

我们发现编译出错了。为什么会这样呢?我们再分析一下执行过程。

执行过程:

  1. 执行IBase<object>.Test(\"\"),泛型类型是object
  2. 因为创建的实例是Sub<string>,所以调用的是Sub<string>.Test(\"\")。但这里出问题了。因为这需要将参数类型object转换为子类string,这做不到隐式转换,因为string是object的派生类。
  3. 编译失败

从上面例子我们可以发现,双向类型转化不再可行。那么只能单向的类型转换。这就是关键字in和out的由来。
如果要实现泛型接口的协变,必须对泛型接口的使用进行限制,那就是out关键字。使用out关键字,来表示T只能用于输出(作为返回值)。同理,对于逆变,就是使用关键字in,来表示T只能用于传入参数。

第六,道理搞明白了,我们再画一下协变和逆变的执行流程图

再贴两个协变和逆变的demo,
协变:

public interface IBase1<out T>
{
    /// <summary>
    /// 使用out修饰T,表明T只能用于方法的返回值(即输出)
    /// </summary>
    /// <returns></returns>
    T Test();
}
public class Sub1<T> : IBase1<T>
{
    public T Test() { return default(T); }
}

/// <summary>
/// 协变测试
/// </summary>
public static class Covariance
{
    public static void Test()
    {
        IBase1<object> a = new Sub1<string>();      //声明泛型父类,实例化泛型子类,在协变时(使用out关键字)可以成立
        var result = a.Test();

        Console.ReadKey();
    }
}

逆变:

public interface IBase2<in T>
{
    /// <summary>
    /// 用in修饰T,表明T只能作为方法的输入参数
    /// </summary>
    /// <param name=\"param\"></param>
    void Test(T param);
}
public class Sub2<T> : IBase2<T>
{
    public void Test(T param) { Console.WriteLine(\"T默认值:\" + default(T)); }
}

/// <summary>
/// 逆变测试
/// </summary>
public static class Contravariant
{
    public static void Test()
    {
        IBase2<string> a = new Sub2<object>();      //声明泛型子类,实例化泛型父类,在逆变时(使用out关键字)可以成立
        a.Test(\"\");

        Console.ReadKey();
    }
}

第七、最后我们来想想为什么逆变叫“逆变”,而且不应该是“抗变”?
我们看这个逆变的执行代码:

IBase2<string> a = new Sub2<object>();      //声明泛型子类,实例化泛型父类,在逆变时(使用out关键字)可以成立

定义为子类,却声明为父类,这是不是很逆天?这不符合我们通常的思路。我想这应该就是叫“逆变”原因。逆变不应该是抗变,它没有抗拒类型转变,而是成功执行了类型转变。只不过,它的赋值语句看起来,怎么类型定义和类型初始化是反过来的?因而得名吧。

第八、协变,逆变就在身边
虽然以前没搞懂协变和逆变的概念,然而程序照写,似乎也没什么妨碍。这应该就是在实际应用中,还没碰到非常复杂的应用场景,所以对这个没感觉。实际上泛型接口,泛型委托的协变逆变就在身边。比如:

public delegate void Action<in T1, in T2>(T1 arg1, T2 arg2)    //协变
public delegate TResult Func<in T, out TResult>(T arg)          //协变,逆变
public interface IEnumerable<out T> : IEnumerable               //协变

我们平时感觉不到我们在应用协变逆变,主要还是因为我们只讲in,out理解为方法输入参数、方法返回值。泛型类型在99%场景下都是“不变”的(如输入string,输出string),所以对此没有感知。

最后,我文中有些重要图片来自这篇文章,我觉得讲解的也非常好,给了我很大帮助。大家可以看看,某些方面讲解的更细:
逆变与协变详解

下一篇,我们开始讲泛型结构。

觉得文章有意义的话,请动动手指,分享给朋友一起来共同学习进步。

欢迎关注本人如下公众号 “产品技术知与行” ,打造全面的结构化知识库,包括原创文章、免费课程(C#,Java,Js)、技术专题、视野知识、源码下载等内容。


扫描二维码关注

回到目录,再看看相关文章

人已赞赏
站长资讯

关于重罚“上市公司造假”“割韭菜”议案被采纳

2020-11-9 3:44:16

站长资讯

java List/ArrayList 解惑

2020-11-9 3:44:18

0 条回复 A文章作者 M管理员
    暂无讨论,说说你的看法吧
个人中心
购物车
优惠劵
今日签到
有新私信 私信列表
搜索