C＃中的协方差有哪些？（或者，协方差：例如）

协方差（大致）是在使用它们的复杂类型中镜像 “简单”类型的inheritance的能力。
例如，我们总是可以将Cat的实例视为Animal一个实例。如果ComplexType是协变的，则ComplexType可以被视为ComplexType 。

我想知道：协方差的“类型”是什么，它们如何与C＃相关（它们是否受支持？）
代码示例会很有帮助。

例如，一种类型是返回类型协方差 ，由Java支持，但不支持C＃。

我希望有function编程印章的人也可以加入！

这是我能想到的：

更新

在阅读了建设性的评论和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 {...}

因此以下示例有效：

 class Animal {} class Cat : Animal {} IEnumerable cats = ... IEnumerable animals = cats;

请注意，根据定义， IEnumerable是“只读” – 您无法向其添加元素。
与IList的定义形成对比，可以使用.Add()进行修改：

 public interface IEnumerable : ... //covariant - notice the 'out' keyword public interface IList : ... //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()

这允许以下内容：

 Func getCat = () => new Cat(); Func 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(T obj)

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

 delegate void Trainer(Action trainingAction);

我们有训练师的定义，让我们找一个培训师并让他去上class。

 Trainer catTrainer = (catAction) => catAction(new Cat()); Trainer animalTrainer = catTrainer; // covariant: Animal > Cat => Trainer > Trainer //define a default training method Action trainAnimal = (animal) => { Console.WriteLine("Training " + animal.GetType().Name + " to ignore you... done!"); }; //work it! animalTrainer(trainAnimal);

输出certificate这有效：

训练猫忽略你……完成！

为了理解这一点，一个笑话是有序的。

有一天，一位语言学教授在课堂上讲课。
“在英语中，”他说，“双重否定形成了积极的一面。
然而，“他指出，”没有一种语言，其中双重积极可以形成负面。“

房间后面的声音传来，“是的，没错。”

与协方差有什么关系？！

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

Action是逆变的，即它“翻转”类型的关系：

 A < B => Action > Action (1)

使用Action和Action更改上面的A和B并获取：

 Action < Action => Action> > Action> or (flip both relationships) Action > Action => Action> < Action> (2)

将（1）和（2）放在一起，我们有：

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

但我们的Trainer委托实际上是一个Action> ：

 Trainer == Action> (3)

所以我们可以将（4）重写为：

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

– 根据定义，这意味着培训师是协变的。

简而言之，应用Action 两次得到反对方差，即类型之间的关系翻转两次（见（4）），所以我们回到协方差。

最好用更通用的结构类型来解释。考虑：

元组类型：（T1，T2），一对类型T1和T2（或更一般地，n元组）;
函数类型：T1 – > T2，参数类型为T1且结果为T2的函数;
可变类型：Mut（T），一个持有T的可变变量。

元组在它们的组件类型中是协变的，即（T1，T2）<（U1，U2）iff T1

函数在它们的结果中是协变的，在它们的参数中是逆变的，即（T1 – > T2）<（U1 - > U2）iff U1

可变类型是不变的，即仅当t = U时Mut（T）

所有这些规则都是最通用的正确子类型规则。

现在，像主流语言中所知的对象或接口类型可以被解释为包含其作为函数的方法的元组的奇特forms。例如，界面

 interface C { T f(U, U) Int g(U) Mut(V) x }

基本上代表了类型

 C(T, U, V) = ((U, U) -> T, U -> Int, Mut(V))

其中f，g和x分别对应于元组的第1，第2和第3个分量。

从上述规则可以得出，C（T，U，V）

另一个例子：

 interface D { Int f(T) T g(Int) }

是

 D(T) = (T -> Int, Int -> T)

这里，D（T）

还有第四种情况，有时称为“双变量”，它同时意味着共变和反变。例如，

 interface E { Int f(Int) }

在T中是双变量的，因为它实际上并未使用。

Java对通用类型使用了使用站点方差的概念：在每个使用站点指定所需的方差。这就是为什么Java程序员必须熟悉所谓的PECS规则的原因。是的，这是笨拙的，已经收到了很多批评。

C＃中的协方差有哪些？ （或者，协方差：例如）

类型参数的数据类型如何在协方差和逆变量中确定？

C＃中的协方差有哪些？（或者，协方差：例如）