C# 协变与逆变 有何实用性剖析

【协变】 主要体现在泛型中,更大地兼容返回值的类型

【逆变】继承类的操作类/操作方法参数,可以用基类的操作类/操作方法进行复用，不需要重复定义.

        实际开发中,如果不同控件 响应相同的操作,正常情况下,由于不同的控件事件的委托不同,要写两个操作函数。
        在逆变的情况下, 就可以简化为一个事件参数使用 System.EventArgs类型,也就是基类型。
        现在自动生成的事件函数都是一下格式: DoEvent(object sender, System.EventArgs e)。

【接口中的应用】

     逆变：TypeBookBase类的ShowSort()方法,使用继承于 IComparer<Book>的类PriceComparer来排序,对基类的操作方法或操作类进行复用，避免了多次定义

     协变：BoolUtil类的ShowBook(IEnumerable<Book> books)方法，IEnumerable<Book>参数可以兼容List<Book>以及它的List<TypeBook>

 public class Book
    {       
        public Book(string name, decimal price)
        {
            this.Name=name;
            this.Price=price;
        }
        
        public string Name
        {
            get;
            set;
        }
       
        public decimal Price
        {
            get;
            set;
        }
   

       
    }
    public class TypeBook : Book
    {        
        public int Type
        {
            get;
            set;
        }
        
        public TypeBook(string name, decimal price, int type)
            : base(name, price)
        {
            this.Type=type;
        }


    }

 public class BookBase
    {
        protected List<Book> books = new List<Book>();
      

        public BookBase()
        {
            Book book1 = new Book("同学", 98);
            Book book2 = new Book("月明", 5);
            Book book3 = new Book("编程", 58);
            Book book4 = new Book("大哥", 34);
            Book book5 = new Book("朋友", 40);
            books.Add(book1);
            books.Add(book2);
            books.Add(book3);
            books.Add(book4);
            books.Add(book5);
        }

       

        public void ShowSort()
        {                      
          
            Console.WriteLine("按价格升序排列：");
            books.Sort(new PriceComparer());
            BoolUtil.ShowBook(books);
       
            Console.WriteLine("按价格降序排列：");
            books.Sort(new PriceComparer(false));
            BoolUtil.ShowBook(books);
         
            Console.Read();
        }
    }
  

    public class TypeBookBase
    {
        protected List<TypeBook> books = new List<TypeBook>();
        
        public TypeBookBase()

        {
            TypeBook book1 = new TypeBook("同学", 98,4);
            TypeBook book2 = new TypeBook("月明", 5,1);
            TypeBook book3 = new TypeBook("编程", 58,3);
            TypeBook book4 = new TypeBook("大哥", 34,9);
            TypeBook book5 = new TypeBook("朋友", 40,16);
            books.Add(book1);
            books.Add(book2);
            books.Add(book3);
            books.Add(book4);
            books.Add(book5);
        }

       

        public void ShowSort()
        {
            //PriceComparer 逆变
            Console.WriteLine("按价格升序排列：");
            books.Sort(new PriceComparer());
            BoolUtil.ShowBook(books);
           
            Console.WriteLine("按价格降序排列：");
            books.Sort(new PriceComparer(false));
            BoolUtil.ShowBook(books);

            
            Console.WriteLine("按类型升序排列：");
            books.Sort(new TypeComparer());
            BoolUtil.ShowBook(books);
 
            Console.WriteLine("按类型降序排列：");
            books.Sort(new TypeComparer(false));
            BoolUtil.ShowBook(books);

            Console.Read();
        }
    }


    public class BoolUtil
    {  
        //IEnumerable 协变
        public static void ShowBook(IEnumerable<Book> books)
        {
            Type type=books.GetType().GetGenericArguments().First();
            bool IsTypeBook=type.Equals(typeof(TypeBook));

            Console.WriteLine();
            Console.WriteLine("名称\t\t价格\t"+(IsTypeBook?"类型":""));
            Console.WriteLine("---------------------------------------");

            foreach (var item in books)
            {
                Console.WriteLine(item.Name + "\t\t" + item.Price+"\t"+(IsTypeBook?((TypeBook)item).Type.ToString():""));
            }
            Console.WriteLine("\n");
        }

    }

  public class TypeComparer : IComparer<TypeBook>
    {  
        private bool IsAsc;
        public TypeComparer(bool IsAsc=true)
        {
            this.IsAsc=IsAsc;
        }
        public int Compare(TypeBook x, TypeBook y)
        {
            if (IsAsc)
                return x.Type.CompareTo(y.Type);
            return y.Type.CompareTo(x.Type);
        }
    }     

    public class PriceComparer: IComparer<Book>
    {  
        private bool IsAsc;
        public PriceComparer(bool IsAsc=true)
        {
            this.IsAsc=IsAsc;
        }
        public int Compare(Book x, Book y)
        {
            if (IsAsc)
                return x.Price.CompareTo(y.Price);
            return y.Price.CompareTo(x.Price);
        }
    }

 public     class BookMain
    {
       public  static void DoMain()
        {

            BookBase bs=new BookBase();
         
            bs.ShowSort();

            TypeBookBase tbs=new TypeBookBase();
             
            tbs.ShowSort();

        }
    }

【委托中的应用】

   逆变：DoForInHandler(InHandler action)方法，参数类型是 delegate void InHandler(Dogs dog)，但是当前方法可以接收 void InAction(Mammals m) 方法.

   协变：DoForOutHandler(OutHandler action)方法，参数类型是 delegate Mammals OutHandler()，但是当前方法可以接收 Dogs OutActionDog()方法.

 class Mammals
    {
        public string Name
        {
            get;
            set;
        }
       
    }

    class Dogs : Mammals
    {
        public string Color
        {
            get;
            set;
        }
      
    }
    class Cats : Mammals { }

  class InOutDelegate
    {
        #region 委托 协变
        public delegate Mammals OutHandler();
        public static Mammals OutAction()
        {
            return new Mammals();
        }

        public static Dogs OutActionDog()
        {

            return new Dogs();
        }

        public static void DoForOutHandler(OutHandler action)
        {
            Console.WriteLine(action().ToString());
        }
        #endregion 

        #region 委托 逆变

        public delegate void InHandler(Dogs dog);
        public delegate void InHandlerCat(Cats cat);      
        public static void InAction(Mammals m)
        {
            m.Name="InAction.Name";
        }
        public static void InActionDog(Dogs d)
        {
            d.Name="InAction_Dog.Name";
            d.Color="InAction_Dog.Color";
        }
        public static void DoForInHandler(InHandler action)
        {
            Dogs ds=new Dogs();
            ds.Name="DoForInHandler.Name";
            action(ds);
            Console.WriteLine("Name:"+ds.Name+" Color:"+ds.Color);
        }
        #endregion

        #region In::反例
        public delegate void DoMammals(Mammals mm);
        public static void DoForMammals(DoMammals action)
        {
            Mammals mm=new Mammals();
            mm.Name="DoForMammals.Name";
            action(mm);
            Console.WriteLine("Name:"+mm.Name);

        }
        #endregion

        #region 委托 协变+逆变

        public delegate Mammals InOutHandler(Dogs dog);
        public static Dogs InOutAction(Mammals mm)
        {
            Dogs dd=new Dogs();
            dd.Name=mm.Name;
            dd.Color="InOutAction.Color";
            return dd;
        }
        public static void DoForInOutHandler(InOutHandler action)
        {
            Dogs dg=new Dogs();
            dg.Name="DoForInOutHandler.Name";
            dg.Color="DoForInOutHandler.Color";
            var dd=InOutAction(dg);
            Console.WriteLine("Name:"+dd.Name+" Color:"+dd.Color);
        }
        #endregion 

        



        //实际开发中,如果不同控件 响应相同的操作
        //正常情况下,由于不同的控件事件的委托不同,要写两个操作函数　
        //在逆变的情况下, 就可以简化为一个
        //事件参数使用 System.EventArgs类型,也就是基类型
        //现在自动生成的 事件函数都是一下格式: 
        //DoEvent(object sender, System.EventArgs e)
        public static void Test()
        { 

            //Delegate::Out
            Console.WriteLine("Out:");
            OutHandler out1 = OutAction;           
            OutHandler out2 = OutActionDog;
            DoForOutHandler(OutAction);
            DoForOutHandler(OutActionDog);


            //Delegate::In
            Console.WriteLine();
            Console.WriteLine("In:");
            InHandler in1=InAction;
            Action<Dogs> in11=InAction;
            InHandlerCat in2=InAction;
            Action<Cats> in22=InAction;

            DoForInHandler(InAction);
            DoForInHandler(InActionDog);

            //Deletgate::In 反例
           // DoForMammals(InAction);
           // DoForMammals(InActionDog);


            //Delegate::In+Out
            Console.WriteLine();
            Console.WriteLine("InOut:");    
            DoForInOutHandler(InOutAction); 
        } 

    }