深刻理解 C# 协变和逆变

msdn 解释以下： 

“协变”是指可以使用与原始指定的派生类型相比，派生程度更大的类型。 

“逆变”则是指可以使用派生程度更小的类型。 

解释的很正确，大体就是这样，不过不够直白。 

直白的理解： 

“协变”->”和谐的变”->”很天然的变化”->string->object :协变。 

“逆变”->”逆常的变”->”不正常的变化”->object->string 逆变。 

上面是我的对协变和逆变的理解，比起记住那些派生，类型，原始指定,更大，更小之类的词语，我的认为要容易点。 

下面是一则笑话： 

一个星期的每一天应该这样念:

星期一 = 忙day； 
星期二 = 求死day； 
星期三 = 未死day； 
星期四 = 受死day； 
星期五 = 福来day； 
星期六 = 洒脱day； 
星期天 = 伤day

 

为了演示协变和逆变，以及之间的区别，请建立控制台程序CAStudy，手动添加两个类： 

 

  

由于是演示，因此都是个空类，

  

只是有一点记住Dog 继承自Animal,

  

因此Dog变成Animal 就是和谐的变化(协变),而若是Animal 变成Dog就是不正常的变化(逆变)

  

在Main函数中输入：

 

 

  

由于Dog继承自Animal，因此Animal aAnimal = aDog; aDog 会隐式的转变为Animal.

  

可是List<Dog> 不继承List<Animal> 因此出现下面的提示：

  

 

  

若是想要转换的话，应该使用下面的代码：

  

List<Animal> lstAnimal2 = lstDogs.Select(d => (Animal)d).ToList();

  

能够看到一个lstDogs 变成lstAnimal 是多么复杂的操做了。

  

正因如此，因此微软新增了两个关键字：Out,In,下面是他们的msdn解释：

 

 

 

 

协变的英文是：“covariant”，逆变的英文是：“Contravariant”

  

为何Microsoft选择的是”Out” 和”In” 做为特性而不是它们呢？

  

我我的的理解：

  

由于协变和逆变的英文太复杂了，并无体现协变和逆变的不一样，可是out 和 in 却很直白。

  

out: 输出(做为结果),in:输入(做为参数)

  

因此若是有一个泛型参数标记为out,则表明它是用来输出的，只能做为结果返回，而若是有一个泛型参数标记为in,则表明它是用来输入的，也就是它只能做为参数。

  

目前out 和in 关键字只能在接口和委托中使用，微软使用out 和 in 标记的接口和委托大体以下：

 

 

先看下第一个IEnumerable<T>

 

 和刚开始说的同样，T 用out 标记，因此T表明了输出，也就是只能做为结果返回。

 

public static void Main()

 

{

    Dog aDog = new Dog(); 

    Animal aAnimal = aDog; 

    List<Dog> lstDogs = new List<Dog>();

    //List<Animal> lstAnimal = lstDogs;

    List<Animal> lstAnimal2 = lstDogs.Select(d => (Animal)d).ToList();

    IEnumerable<Dog> someDogs = new List<Dog>();

    IEnumerable<Animal> someAnimals = someDogs;

}

 

由于T只能作结果返回，因此T不会被修改，编译器就能够推断下面的语句强制转换合法，因此

IEnumerable<Animal> someAnimals = someDogs; 

能够经过编译器的检查，反编译代码以下： 

 

虽然经过了C#编译器的检查，可是il 并不知道协变和逆变，仍是得乖乖的强制转换。 

在这里我看到了这句话：

IEnumerable<Animal> enumerable2 = (IEnumerable<Animal>) enumerable1;

那么是否是能够List<Animal> lstAnimal3 = (List<Animal>)lstDogs; 呢？ 

想要回答这个问题须要在回头看看Clr via C# 关于泛型和接口的章节了，我就不解释了， 

答案是不能够。 

上面演示的是协变，接下来要演示下逆变。 

为了演示逆变，那么就要找个in标记的接口或者委托了，最简单的就是： 

   

在Main函数中添加： 

Action<Animal> actionAnimal = new Action<Animal>(a => {/*让动物叫*/ });

Action<Dog> actionDog = actionAnimal;

actionDog(aDog);

很明显actionAnimal 是让动物叫，由于Dog是Animal，那么既然Animal 都能叫，Dog确定也能叫。 

In 关键字：逆变，表明输入，表明着只能被使用，不能做为返回值，因此C#编译器能够根据in关键字推断这个泛型类型只能被使用，因此Action<Dog> actionDog = actionAnimal;能够经过编译器的检查。 

再次演示Out关键字：

添加两个类：

public interface IMyList<out T>

{

    T GetElement();

}

 

public class MyList<T> : IMyList<T>

{

    public T GetElement()

    {

        return default(T);

    }

} 

由于out 关键字，因此下面的代码能够经过编译

IMyList<Dog> myDogs = new MyList<Dog>();

IMyList<Animal> myAnimals = myDogs;

 

将上面的两个类修改成：

public interface IMyList<out T>

{

    T GetElement();

    void ChangeT(T t);

}

 

public class MyList<T> : IMyList<T>

{

    public T GetElement()

    {

        return default(T);

    }

 

    public void ChangeT(T t)

    {

        //Change T

    }

}

 

编译：

 

由于T被out修饰，因此T只能做为参数。

 

一样修改两个类以下：

public interface IMyList<in T>

{

    T GetElement();

    void ChangeT(T t);

}

 

public class MyList<T> : IMyList<T>

{

    public T GetElement()

    {

        return default(T);

    }

 

    public void ChangeT(T t)

    {

        //Change T

    }

}

 

这一次使用in关键字。

编译：

 

由于用in关键字标记，因此T只能被使用，不能做为返回值。

 

最后修改代码为：

public interface IMyList<in T>

{

    void ChangeT(T t);

}

 

public class MyList<T> : IMyList<T>

{

    public void ChangeT(T t)

    {

        //Change T

    }

}

 

编译成功，由于in表明了逆变，因此

IMyList<Animal> myAnimals = new MyList<Animal>();

IMyList<Dog> myDogs = myAnimals;

 

能够编译成功！。