你了解C#的协变和逆变吗

• 从C# 4.0开始，泛型接口和泛型委托都支持协变和逆变，由于历史原因，数组也支持协变。
• 里氏替换原则：任何基类可以出现的地方，子类一定可以出现。

协变（out）

• 协变：即自然的变化，遵循里氏替换原则，表现在代码上则是任何基类都可以被其子类赋值，如Animal = Dog、Animal = Cat
• 使用out关键字声明（注意和方法中修饰参数的out含义不同）
• 被标记的参数类型只能作为方法的返回值（包括只读属性）
• 在没有协变时：

  abstract class Animal {}
  class Dog : Animal {}
  class Cat : Animal {}
  
  interface IPoppable<T>
  {
      T Pop();
  }
  class MyStack<T> : IPoppable<T>
  {
      private int _pos;
      private readonly T[] _data = new T[100];
  
      public void Push(T obj) => _data[_pos++] = obj;
      public T Pop() => _data[--_pos];
  }
  

  以下代码是无法通过编译的

  var dogs = new MyStack<Dog>();
  IPoppable<Animal> animals1 = dogs; // 此处会发生编译错误
  Stack<Animal> animals2 = dogs; // 此处会发生编译错误
  

  此时，我们如果需要为动物园饲养员新增一个输入参数为Stack<Animal>饲喂的方法，一个比较好的方法是新增一个约束泛型方法：

  class Zookeeper
  {
      public static void Feed<T>(IPoppable<T> animals) where T : Animal {}
  }
  // 或者
  class Zookeeper
  {
      public static void Feed<T>(Stack<T> animals) where T : Animal {}
  }
  
  // Main
  Zookeeper.Feed(dogs);
  

• 现在，C#增加了协变
  
  使IPoppable<T>接口支持协变

  // 仅仅增加了一个 out 声明
  interface IPoppable<out T>
  {
      T Pop();
  }
  

  简化Feed方法

  class Zookeeper
  {
      public static void Feed(IPoppable<Animal> animals) {}
  }
  
  // Main
  Zookeeper.Feed(dogs);
  

  协变的天然特性——仅可作为方法返回值，接口（或委托）外部无法进行元素添加，确保了泛型类型安全性，所以不用担心Dog的集合中出现Cat

• 常用的支持协变的接口和委托有：
  • IEnumerable
  • IEnumerator
  • IQueryable
  • IGrouping<out TKey, out TElement>
  • Func等共17个
  • Converter<in TInput, out TOutput>

  IEnumerable<Dog> dogs = Enumerable.Empty<Dog>();
  IEnumerable<Animal> animals = dogs;
  
  var dogList = new List<Dog>();
  IEnumerable<Animal> animals = dogList;
  

• 另外，由于历史原因，数组也支持协变，例如

  var dogs = new Dog[10];
  Animal[] animals = dogs;
  

  但是无法保证类型安全性，以下代码可正常进行编译，但是运行时会报错

  animals[0] = new Cat(); // 运行时会报错
  

逆变(in)

• 逆变：即协变的逆向变化，实质上还是遵循里氏替换的原则，将子类赋值到基类上
• 使用in关键字声明
• 被标记的参数类型只能作为方法输入参数（包括只写属性）
• 例如：

  abstract class Animal {}
  class Dog : Animal {}
  class Cat : Animal {}
  
  interface IPushable<in T>
  {
      void Push(T obj);
  }
  class MyStack<T> : IPushable<T>
  {
      private int _pos;
      private readonly T[] _data = new T[100];
  
      public void Push(T obj) => _data[_pos++] = obj;
      public T Pop() => _data[--_pos];
  }
  
  // Main
  var animals = new MyStack<Animal>();
  animals.Push(new Cat());
  IPushable<Dog> dogs = animals;
  dogs.Push(new Dog());
  

  逆变的天然特性——仅可作为方法输入参数，接口（或委托）无法进行元素获取，即只能将子类赋值到父类上，进而保证了类型安全性。

• 另外，常用支持逆变的接口和委托有：
  • IComparer
  • IComparable
  • IEqualityComparer
  • Action等共16个
  • Predicate
  • Comparison
  • Converter<in TInput, out TOutput>

Action<Animal> animalAction = new Action<Animal>(a => { });
Action<Dog> DogAction = animalAction;