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

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

 1             Stephen[] MySelf = new Stephen[1];
 2             MySelf[0] = new Stephen() { Name = "name1", Name2 = "name2" };
 3             StephenBase[] MyBase = MySelf; // 协变
 4             Stephen[] OtherMe = (Stephen[])MyBase; // 逆变
 5 
 6 ...
 7 
 8         public class StephenBase
 9         {
10             public StephenBase() { }
11             public string Name { get; set; }
12         }
13 
14         public class Stephen : StephenBase
15         {
16             public Stephen()
17             {
18 
19             }
20 
21             public string Name2 { get; set; }
22         }

委托的协变和逆变

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

1 void LogPlainEvent(object sender ,EventArgs e)
2 {
3      Console.WriteLine("An event occurred!");
4 }
5 
6 Button btn = new Button();
7 btn.Click += LogPlainEvent; // 委托逆变
8 btn.KeyPress += LogPlainEvent; // 委托逆变

协变：

 1            delegate Stream StreamFactory();
 2 
 3             StreamFactory sf = GenerateMeoryStream; // 委托协变
 4             using (Stream s = sf())
 5             {
 6                 int data;
 7                 while ((data = s.ReadByte()) != -1)
 8                 {
 9                     Console.WriteLine(data);
10                 }
11             } 
12 
13         static MemoryStream GenerateMeoryStream()
14         {
15             byte[] buffer = new byte[16];
16             for (int i = 0; i < buffer.Length; i++)
17             {
18                 buffer[i] = (byte)i;
19             }
20             return new MemoryStream(buffer);
21         }

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

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

1             Stephen[] MySelf = new Stephen[1];
2             MySelf[0] = new Stephen() { Name = "name1", Name2 = "name2" }; 
3             StephenBase[] MyBase = MySelf; // 协变
4             Stephen[] OtherMe = (Stephen[])MyBase; // 逆变
5 
6             Console.WriteLine("ChildName: " + OtherMe[0].Name2);
7             Console.ReadLine();

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

 1         public static void InterfaceTest()
 2         {
 3             HelloStephen stephen = new HelloStephen()
 4             {
 5                 Email = @"Balabala@happy.com",
 6                 Oicq = @"10001",
 7                 IsAlive = true
 8             };
 9 
10             IHelloStephen istephen = (IHelloStephen)stephen;
11             HelloStephen targetStephen = HelloStephen.FindStephen(istephen);
12 
13             Console.WriteLine("Is Stephen alive ?");
14             Console.WriteLine(targetStephen.IsAlive);
15             Console.WriteLine("Contact Me ? To : " + targetStephen.Email + " Or QQ : " + targetStephen.Oicq);
16         }

 1     /// <summary>
 2     /// Descrption:
 3     /// IStephen Interface
 4     /// </summary>
 5     public interface IHelloStephen
 6     {
 7         string Email { get; set; }
 8         string Oicq { get; set; }
 9         bool IsAlive { get; set; }
10     }
11 
12     public class HelloStephen : IHelloStephen
13     {
14         #region IHelloStephen
15         string _Email;
16         string _Oicq;
17         bool _isAlive;
18 
19         public bool IsAlive
20         {
21             get { return _isAlive; }
22             set { _isAlive = value; }
23         }
24         public string Email
25         {
26             get { return _Email; }
27             set { _Email = value; }
28         }
29         public string Oicq
30         {
31             get { return _Oicq; }
32             set { _Oicq = value; }
33         }
34         #endregion
35 
36         #region HelloStephen
37         public string MyCNBlogs { get; set; }
38         #endregion
39 
40         #region Method
41         public static HelloStephen FindStephen(IHelloStephen stephen)
42         {
43             return (HelloStephen)stephen ?? new HelloStephen() { IsAlive = false };
44         }
45         #endregion
46     }

3.方法组转换。

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

1 // C#1
2 Thread t = new Thread(new ThreadStart(MyMethod));
3 
4 // C#2
5 Thread t = new Thread(MyMethod);

View Code

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

　　存在不兼容的风险：

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

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

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