class Animal { }
  class Cat : Animal { }

1  Animal animal1 = new Cat();
2  List<Animal> animals = new List<Cat>();

IEnumerable<Animal> list2 = new List<Cat>();

#region 自定义协变
        public interface ICustomerListOut<out T>
        {
            T Get();//T只能作为返回值，不能作为参数
        }
        public class CustomerListOut<T> : ICustomerListOut<T>
        {
            public T Get()
            {
                return default(T);
            }
        }
#endregion

   // 使用自定义协变
   ICustomerListOut<Animal> customerList1 = new CustomerListOut<Animal>();
   ICustomerListOut<Animal> customerList2 = new CustomerListOut<Cat>();
   //理解成后面实例的实际类型(Cat)必须是左边(Animal)内部扩展的（即继承了左边的类型或接口）(out)

#region 自定义逆变
        //在泛型接口的T前面有一个In关键字修饰，而且T只能方法参数，不能作为返回值类型，这就是逆变
        public interface ICustomerListIn<in T>
        {
            void Show(T t);//T只能作为参数，不能作为返回值
        }
        public class CustomerListIn<T> : ICustomerListIn<T>
        {
            public void Show(T t)
            {
                
            }
        }
#endregion

 // 使用自定义逆变
ICustomerListIn<Cat> customerListCat1 = new CustomerListIn<Cat>();
ICustomerListIn<Cat> customerListCat2 = new CustomerListIn<Animal>();
//理解成后面实例的实际类型(Animal)必须在左边(Cat)内部已经继承或者实现了的(in)

public Action<Animal> an;
public Action<Cat> cat;

 public void ceshi1(Animal an) { }
 public void ceshi2(Cat an) { }