Delegate（委托）中的Covariance（协变）和Contravariance（逆变）

在Delegate当中，Variance（变异）是比较简单的理念，但不能深入理解的话，还是感觉比较疑惑的。

Covariance（协变）

• Return types are compatible
• A delegate variable can be used with a method that retures a type that is derived from the delegate's returned type

协变是用在方法返回值上的技术。

一个委托变量可以被赋值于一个方法，即使这个方法的返回值是继承于委托所定义时的返回值。

代码示例：

public class Person { }
 
public class Employee : Person { }
 
class Program
{
    static void Main(string[] args)
    {
        Func<Person> personMaker;
        personMaker = MakePerson;
        personMaker = MakeEmployee;
 
        Func<Employee> employeeMaker;
        //employeeMaker = MakePerson(); //这个是不能通过编译的
        //employeeMaker = MakePerson2(); //这个是不能通过编译的
        employeeMaker = MakeEmployee;
    }
 
    private static Person MakePerson() { return new Person(); }
 
    private static Person MakePerson2() { return new Employee(); }
 
    private static Employee MakeEmployee() { return new Employee(); }
}

在以上示例中，

• Func<Person>很显然可以被赋值于一个返回Person的方法。但如果一个方法返回Employee呢？因为Employee是继承自Person，Employee就是一个Person，所以即使是返回Employee的方法也是可以赋给Func<Person>的。这里就是Covariance所支持的理念。
• Func<Employee>很显然可以被赋值于一个返回Employee的方法。但如果一个方法返回Person呢？因为Person不是Employee，即使Person实际上指的是Employee，这样的赋值也是不能通过编译的。

Covariance相对于Contravariance还是好理解一些。

Contravariance（逆变）

• Parameter types are compatible
• A delegate variable can be used with a method that takes parameters that are ancestors of the delegate's parameter types

逆变是用在方法参数上的技术。

一个委托变量可以被赋值于一个方法，即使这个方法的参数是委托所定义时的参数的父类。

代码示例：

public class Person { }
 
public class Employee : Person { }
 
class Program
{
    static void Main(string[] args)
    {
        Action<Person> personProcessor;
        personProcessor = ProcessPerson;
        //personProcessor = ProcessEmployee; //这个是不能通过编译的
        personProcessor(new Person());
        personProcessor(new Employee());
 
        Action<Employee> employeeProcessor;
        employeeProcessor = ProcessPerson;
        employeeProcessor = ProcessEmployee;
        //employeeProcessor(new Person()); //这个是不能通过编译的
        employeeProcessor(new Employee());
    }
 
    private static void ProcessPerson(Person person) { }
 
    private static void ProcessEmployee(Employee employee) { }
}

在以上示例中，

• Action<Person>在最终调用的时候必须是Person或它的子类。因为Employee也是Person，所以personProcessor可以传入Person或者Employee。
• Action<Employee>在最终调用的时候必须是Employee或它的子类。传入Person的时候，那就不能通过编译。即使Person实际上代表的是Employee，也不能通过编译。
• 为什么方法ProcessEmployee不能赋于personProcessor？理由很简单：ProcessEmployee处理的是Employee，但personProcessor只能处理Person。把一个Person传给ProcessEmployee，这是不行的。
• 为什么ProcessPerson能赋值给employeeProcessor？因为ProcessPerson是处理Person的，但Employee也是Person，所以从概念上讲，但我们把ProcessPerson赋给employeeProcessor的时候，也就是准备处理Person，当employeeProcessor最终调用的时候传入的是Employee，所以应该完全可以。这里就是Contravariance所实现的理念。
• 简言之，Action<Person>最终是处理Person的，ProcessPerson可以处理Person，但ProcessEmployee不可以处理Person。Action<Employee>最终是处理Employee的，ProcessPerson和ProcessEmployee是可以处理Employee的。

Contravariance相对于Covariance稍微难理解一些。

但我相信经过以上的实例和讲解，大家应该能深刻地理解了委托中的协变和逆变！