C#中的协方差有哪些？(或者,协方差:例如)

Question

协方差(大致)是在使用它们的复杂类型中镜像 "简单"类型的继承的能力.
例如,我们总是可以将一个实例Cat视为一个实例Animal.如果ComplexType是协变ComplexType<Cat>的ComplexType<Animal>,则可以将A 视为a .

我想知道:协方差的"类型"是什么,它们与C#有什么关系(它们是否受支持？)
代码示例会有所帮助.

例如,一种类型是返回类型协方差,由Java支持,但不支持C#.

我希望有功能编程印章的人也可以加入!

Answer 1

这是我能想到的:

更新

在阅读了Eric Lippert提出的建设性意见和大量文章之后,我改进了答案:

• 更新了数组协方差的破坏性
• 添加了"纯"代理方差
• 从BCL添加了更多示例
• 添加了指向深入解释概念的文章的链接.
• 添加了关于高阶函数参数协方差的全新部分.

返回类型协方差:

可用Java(> = 5)^[1]和C++ ^[2],C#不支持(Eric Lippert解释了为什么不能以及你可以做些什么):

class B {
    B Clone();
}

class D: B {
    D Clone();
}

接口协方差^[3] - 在C#中受支持

BCL将通用IEnumerable接口定义为协变:

IEnumerable<out T> {...}

因此以下示例有效:

class Animal {}
class Cat : Animal {}

IEnumerable<Cat> cats = ...
IEnumerable<Animal> animals = cats;

请注意,IEnumerable根据定义,"只读" - 您无法向其添加元素.
对比其定义IList<T>可以修改,例如使用.Add():

public interface IEnumerable<out T> : ...  //covariant - notice the 'out' keyword
public interface IList<T> : ...            //invariant

通过方法组委派协方差^[4] - 在C#中支持

class Animal {}
class Cat : Animal {}

class Prog {
    public delegate Animal AnimalHandler();

    public static Animal GetAnimal(){...}
    public static Cat GetCat(){...}

    AnimalHandler animalHandler = GetAnimal;
    AnimalHandler catHandler = GetCat;        //covariance

}

"纯粹的"代表协方差^{[5 - pre-variance-release article]} - 在C#中得到支持

不带参数并返回内容的委托的BCL定义是协变的:

public delegate TResult Func<out TResult>()

这允许以下内容:

Func<Cat> getCat = () => new Cat();
Func<Animal> getAnimal = getCat; 

数组协方差 - 在C#中以破碎的方式支持^{[6] [7]}

string[] strArray = new[] {"aa", "bb"};

object[] objArray = strArray;    //covariance: so far, so good
//objArray really is an "alias" for strArray (or a pointer, if you wish)


//i can haz cat?
object cat == new Cat();         //a real cat would object to being... objectified.

//now assign it
objArray[1] = cat                //crash, boom, bang
                                 //throws ArrayTypeMismatchException

最后 - 令人惊讶且有点令人费解的
代表参数协方差(是的,那是协方差) - 用于高阶函数.^[8]

带有一个参数并且不返回任何内容的委托的BCL定义是逆变的:

public delegate void Action<in T>(T obj)

忍受我.让我们定义一个马戏团的动物训练师 - 他可以被告知如何训练动物(通过给他一个Action与该动物一起工作的动物).

delegate void Trainer<out T>(Action<T> trainingAction);

我们有培训师的定义,让我们找一个培训师并让他去工作.

Trainer<Cat> catTrainer = (catAction) => catAction(new Cat());

Trainer<Animal> animalTrainer = catTrainer;  
// covariant: Animal > Cat => Trainer<Animal> > Trainer<Cat> 

//define a default training method
Action<Animal> trainAnimal = (animal) => 
   { 
   Console.WriteLine("Training " + animal.GetType().Name + " to ignore you... done!"); 
   };

//work it!
animalTrainer(trainAnimal);

输出证明这有效:

训练猫忽略你......完成!

为了理解这一点,一个笑话是有序的.

有一天,一位语言学教授正在为他的班级讲课.
"在英语中,"他说,"双重否定形成了积极的一面.
然而,"他指出,"没有任何一种双重正面形成负面的语言."

房间后面传来一个声音:"是的,没错."

什么是得到了与协方差办？

让我尝试一下背面的演示.

一个Action<T>是逆变的,即它"翻转"类型的关系:

A < B => Action<A> > Action<B> (1)

更改A和B上面Action<A>和Action<B>并获得:

Action<A> < Action<B> => Action<Action<A>> > Action<Action<B>>  

or (flip both relationships)

Action<A> > Action<B> => Action<Action<A>> < Action<Action<B>> (2)     

将(1)和(2)放在一起,我们有:

,-------------(1)--------------.
 A < B => Action<A> > Action<B> => Action<Action<A>> < Action<Action<B>> (4)
         `-------------------------------(2)----------------------------'

但我们的Trainer<T>代表实际上是Action<Action<T>>:

Trainer<T> == Action<Action<T>> (3)

所以我们可以将(4)重写为:

A < B => ... => Trainer<A> < Trainer<B> 

- 根据定义,这意味着培训师是协变的.

简而言之,应用Action 两次我们得到反对方差,即类型之间的关系被翻转两次(见(4)),所以我们回到协方差.