协变性(大致)是在使用“简单”类型的复杂类型中镜像继承的能力。
例如。我们总是可以处理 Cat
的实例作为 Animal
的实例. ComplexType<Cat>
可能被视为 ComplexType<Animal>
,如果 ComplexType 是协变的。
我想知道:协方差的“类型”是什么,它们与 C# 有什么关系(是否支持它们?)
代码示例会有所帮助。
例如,一种类型是返回类型协方差,Java 支持,但 C# 不支持。
我希望有函数式编程能力的人也能插话!
最佳答案
这是我能想到的:
更新
在阅读了 Eric Lippert 提出(和撰写)的建设性评论和大量文章后,我改进了答案:
- 更新了数组协方差的破损性
- 添加了“纯”委托(delegate)方差
- 添加了更多来自 BCL 的示例
- 添加了指向深入解释概念的文章的链接。
- 添加了关于高阶函数参数协方差的全新部分。
返回类型协方差:
可用于 Java (>= 5) [1]
和 C++ [2]
,在 C# 中不受支持(Eric Lippert 解释 why not 和 what you can do about it ):
class B {
B Clone();
}
class D: B {
D Clone();
}
接口(interface)协方差 [3]
- C# 支持
BCL 定义了通用的 IEnumerable
接口(interface)是协变的:
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
通过方法组委托(delegate)协变 [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
}
“纯”委托(delegate)协方差 [5 - pre-variance-release article]
- C# 支持
委托(delegate)的 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
最后 - 令人惊讶且有点令人费解的事情
委托(delegate)参数协方差(是的,这就是co-方差)- 用于高阶函数。 [8]
采用一个参数且不返回任何内容的委托(delegate)的 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);
输出证明这是可行的:
Training Cat to ignore you... done!
为了理解这一点,开个玩笑吧。
A linguistics professor was lecturing to his class one day.
"In English," he said, "a double negative forms a positive.
However," he pointed out, "there is no language wherein a double positive can form a negative."A voice from the back of the room piped up, "Yeah, right."
与协方差有什么关系?!
让我尝试一个餐巾纸背面的演示。
安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>
delegate 实际上是一个 Action<Action<T>>
:
Trainer<T> == Action<Action<T>> (3)
所以我们可以将 (4) 重写为:
A < B => ... => Trainer<A> < Trainer<B>
- 根据定义,这意味着 Trainer 是协变的。
简而言之,申请 Action
两次我们得到了反反方差,即类型之间的关系翻转了两次(见 (4)),所以我们回到了协方差。
关于c# - C# 中的协变有哪些类型? (或者,协方差 : by example),我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/17231577/