这是我能想到的：
更新
在阅读了 Eric Lippert 指出（和撰写）的建设性 cmets 和大量文章后，我改进了答案：
- 更新了数组协方差的破坏性
- 添加了“纯”委托差异
- 从 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();
}
接口协方差[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
最后 - 令人惊讶且有点令人费解的
委托参数协方差（是的，这就是 co-方差） - 用于高阶函数。[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)
将上面的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）），所以我们'回到协方差。