C# 中的协方差有哪些类型?(或者，协方差:通过示例)

本文关键字：方差 或者 类型 | 更新日期: 2023-09-27 18:19:15

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

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

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

我希望有函数式编程的人也能插话！

C# 中的协方差有哪些类型?(或者，协方差:通过示例)

这是我能想到的：

更新

在阅读了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((，所以我们回到协方差。

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

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

元组在其两种分量类型中都是协变的，即 (T1， T2( <(U1， U2( iff T1 函数在结果上是协变的，在

它们的参数上是逆变的，即 (T1 -> T2( <(U1 -> U2( iff U1 <U2。>

可变类型是不变的，即 Mut(T(

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

现在，像你从主流语言中知道的对象或接口类型可以解释为一种花哨的元组形式，其中包含其方法作为函数等。例如，接口

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 分别对应于元组的第 1、2 和 3 分量。

根据上述规则，C(T， U， V( <C(T'，>

再比如：

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

是

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

在这里，D(T( <D(T'(>

还有第四种情况，有时称为"双方差"，这意味着同时存在协变和逆变。例如

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

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

Java对

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

相关文章：