11

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

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

例如，一种类型是返回类型 covariance，Java 支持，但 C# 不支持。

我希望有函数式编程能力的人也能加入进来！

4

3 回答 3

10

这是我能想到的：

更新

在阅读了 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根据定义， an 是“只读的” - 您不能向其中添加元素。将其与可以修改
的定义进行对比，例如使用：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);

输出证明这是有效的：

训练猫无视你……完成！

为了理解这一点，有必要开个玩笑。

有一天，一位语言学教授正在给他的班级讲课。
“在英语中，”他说，“双重否定形成肯定。
但是，”他指出，“没有一种语言可以使双重肯定形成否定。”

房间后面传来一个声音：“对，对。”

这和协方差有什么关系？！

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

AnAction<T>是逆变的，即它“翻转”了类型的关系：

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

用and改变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>

- 根据定义，这意味着 Trainer 是协变的。

简而言之，应用Action 两次我们得到了逆变换，即类型之间的关系被翻转了两次（参见 (4) ），所以我们回到协方差。

于 2013-06-21T09:22:56.240 回答
3

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

  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) 如果 U1 < T1 和 T2 < U2。

可变类型是不变的，即 Mut(T) < Mut(U) 仅当 T = 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') 当且仅当 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

还有第四种情况，有时称为“二元”，即同时具有协变和逆变。例如，

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

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

于 2013-06-21T13:07:07.153 回答
1

Java 使用泛型类型的使用地点变化的概念：在每个使用地点指定所需的变化。这就是为什么Java程序员需要熟悉所谓的PECS规则。是的，它很笨拙，并且已经受到了很多批评。

于 2013-06-21T09:28:38.763 回答