C#中的协变与逆变小结

下面是“C#中的协变与逆变小结”的完整攻略：

什么是协变和逆变

协变和逆变是C#中的两个概念，它们都涉及到了类型转换。简单来说：

• 协变：表示在类型转换过程中，类型参数可以“向上转”，也就是说如果T1是T2的子类型，那么Func<T1>可以转换为Func<T2>。
• 逆变：表示在类型转换过程中，类型参数可以“向下转”，也就是说如果T1是T2的子类型，那么Action<T2>可以转换为Action<T1>。

协变和逆变的应用场景

协变和逆变主要用于泛型接口和委托的定义。在实际应用中，它们可以帮助我们写出更灵活的代码。

协变的应用场景

协变主要应用于泛型接口的定义。例如，我们可以定义一个实现了IEnumerable接口的类型，这个类型表示可以按顺序访问一个T类型的集合，并且不支持修改集合：

public interface IEnumerable<out T>
{
    IEnumerator<T> GetEnumerator();
}

我们可以看到，IEnumerable接口中的类型参数T被用out关键字修饰，表示这个类型是协变的。这个接口定义了一个GetEnumerator()方法，用于返回一个IEnumerator迭代器。

由于IEnumerable接口是协变的，所以我们可以用一个IEnumerable类型的变量来存储一个IEnumerable类型的对象。例如：

IEnumerable<Dog> dogs = new List<Dog>();
IEnumerable<Animal> animals = dogs;

这样做是安全的，因为Animal是Dog的基类，List可以被看作是List的一种形式。

逆变的应用场景

逆变主要应用于委托的定义。我们可以为一个参数列表包含了一个委托类型，并定义它的参数类型为逆变。例如：

public delegate void Comparison<in T>(T x, T y);

这里的in关键字表示参数类型是逆变的。此处定义的委托表示比较两个T类型的对象。

由于Comparison委托是逆变的，我们可以将一个Comparison<Animal>类型的变量赋值给一个Comparison<Dog>类型的变量：

Comparison<Animal> animalSort = (a, b) => a.Name.CompareTo(b.Name);
Comparison<Dog> dogSort = animalSort;

这样做是安全的，因为比较Animal对象的lambda表达式同样可以用于比较Dog对象，所以将一个Comparison类型的变量赋值给一个Comparison类型的变量是没有问题的。

两条示例

下面是两个协变和逆变的示例：

示例1：IEnumerable接口的协变

using System;
using System.Collections.Generic;

class Animal
{
    public string Name { get; set; }
    public Animal(string name) => Name = name;
}

class Dog : Animal
{
    public Dog(string name) : base(name) { }
}

class Program
{
    static void Main()
    {
        IEnumerable<Dog> dogs = new List<Dog> { new Dog("Tom"), new Dog("Jerry") };
        IEnumerable<Animal> animals = dogs;

        foreach (Animal animal in animals)
        {
            Console.WriteLine(animal.Name);
        }
    }
}

上面的代码中，我们定义了Animal和Dog两个类，其中Dog是Animal的子类。我们还定义了一个泛型列表，用于存储Dog对象。

接下来，我们将这个Dog列表赋值给一个Animal接口类型的变量，这是因为IEnumerable接口是协变的，我们可以将一个IEnumerable类型的对象赋值给一个IEnumerable类型的变量。

最后，我们使用foreach循环遍历这个Animal列表，输出每个Animal对象的Name属性。

示例2：Comparison委托的逆变

using System;
using System.Collections.Generic;

class Animal
{
    public string Name { get; set; }
    public Animal(string name) => Name = name;
}

class Dog : Animal
{
    public Dog(string name) : base(name) { }
}

class Program
{
    static void Main()
    {
        List<Dog> dogs = new List<Dog> { new Dog("Tom"), new Dog("Jerry") };
        Comparison<Animal> animalSort = (a, b) => a.Name.CompareTo(b.Name);
        Comparison<Dog> dogSort = animalSort;

        dogs.Sort(dogSort);

        foreach (Dog dog in dogs)
        {
            Console.WriteLine(dog.Name);
        }
    }
}

上面的代码中，我们定义了Animal和Dog两个类，并且定义了一个Comparison委托。其中，Animal是Dog的子类，我们将Comparison委托的参数类型定义为了逆变的。

在Main函数中，我们使用List类型的变量存储Dog对象，并定义了一个比较Animal的lambda表达式。接着，我们将这个lambda表达式赋给一个Comparison类型的变量，这是因为Comparison委托是逆变的。最后，我们使用dogSort这个比较器对Dog列表进行排序，并输出排序后的结果。

注意，由于我们将一个比较Animal对象的lambda表达式赋给了一个比较Dog对象的变量，所以这个比较器对Dog对象的比较也是正确的。