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

Question

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

我想知道：协方差的“类型”是什么，它们如何与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)

使用Action<A>和Action<B>更改上面的A和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）），所以我们回到协方差。

Answer 2

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

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

元组在它们的组件类型中是协变的，即（T1，T2）<（U1，U2）iff T1 <U1和T2 <U2（其中'<'表示is-subtype-of）。

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

可变类型是不变的，即只有当T = U时Mut（T）<Mut（U）。

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

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

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

基本上代表了类型

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

其中f，g和x分别对应于元组的第一，第二和第三分量。

从上述规则可以得出，C（T，U，V）<C（T'，U'，V'）iff T <T'且U'<U且V = V'。 这意味着泛型类型C在T中是协变的，在U中是逆变的，在V中是不变的。

另一个例子：

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

是

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

这里，D（T）<D（T'）仅在T <T'和T'<T时。一般情况下，只有在T = T'的情况下，所以D实际上在T中是不变的。

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

interface E<T> { Int f(Int) }

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

Answer 3

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