协变和逆变，这两个词的翻译实在很难表达出他们的真实含义。其实他们是继承和多态的衍生物，而且在.Net 1.0 和2.0中都提供了某种程度的支持，只是在.Net 4.0中支持的更加完善了。
简单说来，协变和逆变就是希望支持更多情况的隐式类型转换,使得我们的编程更加方便，而通常来说只有具备继承关系的两个对象才可以发生隐式类型转换，如Base b=new Derived(). 协变和逆变则使得更多的类型之间可以发生隐式类型转换，如通过协变以下代码可以正常工作：
Func<Derived> dFunc=GetDFunc(); Func<Base> bFunc = dFunc; IEnumerable<Derived> dEnum=GetDEnum(); IEnumerable<Base> bEnum = dEnum;
那么我们为什么需要这种功能呢？让我们从一个多态的例子开始：
abstract class Animal { internal abstract void Eat(); } abstract class Mammal : Animal { } class Tiger : Mammal { internal override void Eat() { Console.WriteLine("Tiger eat"); } }
class Program { static void Main(string[] args) { Tiger tiger = new Tiger(); FeedAnimal(tiger); } static void FeedAnimal(Animal animal) { animal.Eat(); } }
虽然FeedAnimal方法接受的参数类型为Animal ,但是当我们传入一个Tiger 的实例，方法能够编译通过，并得到正确的执行。这是一个典型的多态运用。之所以能够这么做是因为Tiger 继承于Animal ，在FeedAnimal方法中对Animal对象的各种操作，Tiger 对象同样支持，而不会发生调用了animal的某个方法A，而tiger中不存在A方法的情况。 那么如果我们把这一原则推而广之，就出现了协变这一概念。
static void FeedAnimal(Func<Animal> animalCreator) { var animal=animalCreator(); animal.Eat(); } static Tiger CreateTiger() { return new Tiger(); }
现在我们让FeedAnimal方法接受一个能够返回Animla的delegate，而同时又创建了一个能够返回Tiger的方法。按照之前的推理，FeedAnimal方法无非就是对delegate中返回的Animal对象进行各种操作，那么如果给它一个返回Tiger对象的delegate，也应该能够正常的工作。所以下面这段代码是可以在.NET 2.0中工作的。
class Program { static void Main(string[] args) { FeedAnimal(CreateTiger); } }
这就是所谓的协变，我们希望两个对象之间，除了继承关系外也能做隐式类型的转换，因为我们认为这种转换是合理的，是类型安全的。
大家可能很奇怪，如果.Net 2.0就已经支持了以上的代码，那么4.0又搞了些什么？
先来看看下面的代码:
class Program { static void Main(string[] args) { Tiger tiger = new Tiger(); FeedAnimal(tiger); } static void FeedAnimal(Animal animal) { Console.WriteLine("Feed Animal");
}
static void FeedAnimal(Mammal mammal)
{
Console.WriteLine("Feed Mamal");
} }
以上这段代码的输出结果是 Feed Mammal，当碰到两个匹配的重载方法时，.Net编译器选择了形参类型在继承树上更接近自己的方法。可是如果我们把Animal改成Func<Animal> 以下代码就编译出错了，编辑器不知道选择哪个方法作为匹配。
class Program { static void Main(string[] args) { FeedAnimal(CreateTiger); }
static Tiger CreateTiger() { return new Tiger(); }
static void FeedAnimal(Func<Animal> animalCreator) { var animal=animalCreator(); animal.Eat(); } static void FeedAnimal(Func<Mammal> animalCreator) { var animal = animalCreator(); animal.Eat(); }
究其根本，在C# 2.0中你无法实现以下delegate间的隐式类型转换
Func<Tiger> tFunc = CreateTiger; Func<Animal> aFunc = tFunc;
而C# 4.0, 使得上述代码能够成功运行，之前的两个方法他也能够做出正确的选择。这是通过out关键字实现的。 注意Func<TResult> 这个delegate在C# 2.0和4.0中的定义是不同的：
//C# 2.0 public delegate TResult Func<TResult>(); //C# 4.0 public delegate TResult Func<out TResult>();
out关键字表示该类型用于返回值，而返回值可以发生协变，因为一个方法如果能够接受一个返回Animal的delegate，那么他必然也可以接受一个返回Tiger的delegate，因为他对animla的操作同样可以作用于tiger上。
既然delegate能够支持协变，那么interface也应该给予支持，因为它无非就是多个delegate罢了。
以下代码在C# 2.0中式不能通过编译的, 这样看来interface还不如delegate支持的好。
static void Main(string[] args) { List<Tiger> tigers = new List<Tiger>(); FeedAnimals(tigers); } static void FeedAnimals(IEnumerable<Animal> animals) { foreach (var animal in animals) animal.Eat(); }
下面的代码也就更加不行了：
List<Tiger> tigers = new List<Tiger>();
IEnumerable<Animal> animlas = tigers;
到了C# 4.0中，由于out关键字的缘故，以上两段代码都能正常工作了。而IEnumerable<T>的定义也被改为
public interface IEnumerable<out T> : IEnumerable { IEnumerator<T> GetEnumerator(); }
之前举得例子都是描述协变的，其实逆变无非就是扩大了输入参数的类型转换的可能，不过方向是反的。
static void FeedAnimal(Animal animal) { animal.Eat(); } static void Execute(Action<Mammal> tAct) { tAct(new Tiger()); }
在Execute方法中， 我们接受一个类型为Action<Mammal> 的delegate，我们在使用这个delegate时，可以传入各种类型的Mammal，比如Tiger， Lion。如果我们传入的delegate能够作用于Animal对象，那么他自然可以作用于Tiger， Lion。 所以我们可以传入一个输入类型更抽象的delegate。因此，在逆变的支持下我们可以写出以下代码。
static void Main(string[] args) { Action<Animal> aAct = FeedAnimal; Action<Mammal> mAct = aAct; Execute(aAct); }
参考资料：