CSharpThinking协变和逆变（一）

实践是检验真理的捷径。

　　本章主要是理解C#中的协变和逆变的关系，对今后理解泛型会有很大帮助。

1.协变与逆变的概念及代码说明。

 C#1：数组是强类型，强类型不允许内部数据不能相互转换。C#2中引入了对协变与逆变的限制，而C#4中又适当放宽了政策，不过这一切对数组没有任何影响，不过可以用一系列的接口和集合代替数组。

            Stephen[] MySelf = new Stephen[1];
            MySelf[0] = new Stephen() { Name = "name1", Name2 = "name2" };
            StephenBase[] MyBase = MySelf; // 协变
            Stephen[] OtherMe = (Stephen[])MyBase; // 逆变

...

        public class StephenBase
        {
            public StephenBase() { }
            public string Name { get; set; }
        }

        public class Stephen : StephenBase
        {
            public Stephen()
            {

            }

            public string Name2 { get; set; }
        }

委托的协变和逆变

逆变：其中void KeyPressEventHandler(object sender, KeyPressEventArgs e) 继承自 void EventHandler（object sender, EventArgs e)

void LogPlainEvent(object sender ,EventArgs e)
{
     Console.WriteLine("An event occurred!");
}

Button btn = new Button();
btn.Click += LogPlainEvent; // 委托逆变
btn.KeyPress += LogPlainEvent; // 委托逆变

协变：

           delegate Stream StreamFactory();

            StreamFactory sf = GenerateMeoryStream; // 委托协变
            using (Stream s = sf())
            {
                int data;
                while ((data = s.ReadByte()) != -1)
                {
                    Console.WriteLine(data);
                }
            } 

        static MemoryStream GenerateMeoryStream()
        {
            byte[] buffer = new byte[16];
            for (int i = 0; i < buffer.Length; i++)
            {
                buffer[i] = (byte)i;
            }
            return new MemoryStream(buffer);
        }

注：协变和逆变是指从基类转换成子类或从子类转换到基类。

2.协变与逆变转换时，本质上没有改变对象，只是编译器如何看待这些值

            Stephen[] MySelf = new Stephen[1];
            MySelf[0] = new Stephen() { Name = "name1", Name2 = "name2" }; 
            StephenBase[] MyBase = MySelf; // 协变
            Stephen[] OtherMe = (Stephen[])MyBase; // 逆变

            Console.WriteLine("ChildName: " + OtherMe[0].Name2);
            Console.ReadLine();

 接口继承也会在二次复原转换后依然保留原始信息。

        public static void InterfaceTest()
        {
            HelloStephen stephen = new HelloStephen()
            {
                Email = @"Balabala@happy.com",
                Oicq = @"10001",
                IsAlive = true
            };

            IHelloStephen istephen = (IHelloStephen)stephen;
            HelloStephen targetStephen = HelloStephen.FindStephen(istephen);

            Console.WriteLine("Is Stephen alive ?");
            Console.WriteLine(targetStephen.IsAlive);
            Console.WriteLine("Contact Me ? To : " + targetStephen.Email + " Or QQ : " + targetStephen.Oicq);
        }

    /// <summary>
    /// Descrption:
    /// IStephen Interface
    /// </summary>
    public interface IHelloStephen
    {
        string Email { get; set; }
        string Oicq { get; set; }
        bool IsAlive { get; set; }
    }

    public class HelloStephen : IHelloStephen
    {
        #region IHelloStephen
        string _Email;
        string _Oicq;
        bool _isAlive;

        public bool IsAlive
        {
            get { return _isAlive; }
            set { _isAlive = value; }
        }
        public string Email
        {
            get { return _Email; }
            set { _Email = value; }
        }
        public string Oicq
        {
            get { return _Oicq; }
            set { _Oicq = value; }
        }
        #endregion

        #region HelloStephen
        public string MyCNBlogs { get; set; }
        #endregion

        #region Method
        public static HelloStephen FindStephen(IHelloStephen stephen)
        {
            return (HelloStephen)stephen ?? new HelloStephen() { IsAlive = false };
        }
        #endregion
    }

  

3.方法组转换。

　　C#1中如果要创建一个委托实例，就必须同时指定委托类型和要采取的操作；C#2提供从方法组（一个方法名，表达式）到一个兼容类型的隐式转换。

// C#1
Thread t = new Thread(new ThreadStart(MyMethod));

// C#2
Thread t = new Thread(MyMethod);

4.C#1与C#2中委托协变逆变的不同之处。

 　　存在不兼容的风险：

EventHandler general = new EventHandler(Event);
KeyPressEventHandler key = new KeyPressEventHandler (general); // C#1报错，而C#2不报错。

C#1要求两个委托的类型签名必须匹配。

 本文多数实例均引自《C# in Depth Second Edition》