C#4.0新特性（3）：變性 Variance（逆變與協變）

標籤：

　一句話總結：協變讓一個粗粒度介面（或委託）可以接收一個更加具體的介面（或委託）作為參數（或傳回值）；逆變讓一個介面（或委託）的參數類型（或傳回值）類型更加具體化，也就是參數類型更強，更明確。

　　通常，協變型別參數可用作委託的傳回型別，而逆變型別參數可用作參數類型。對於介面，協變型別參數可用作介面的方法的傳回型別，而逆變型別參數可用作介面的方法的參數類型。

協變

我們先來看下面一個來自MSDN的例子：
01 // 協變

02 IEnumerable<string> strings = new List<string>();

03 IEnumerable<object> objects = strings;

04 //大家看到了麼一個聲明為IEnumerable<string>的介面類型被賦給了一個更低層級的IEnumerable<object>.

05 //對，這就是協變。再來看一個例子：

06 class Base

07 {

08     public static void PrintBases(IEnumerable<Base> bases)

09     {

10         foreach(Base b in bases)

11         {

12             Console.WriteLine(b);

13         }

14  

15     }

16 }

17  

18 class Derived : Base

19 {

20     public static void Main()

21     {

22         List<Derived> dlist = new List<Derived>();

23         Derived.PrintBases(dlist);

24 　　　　 //由於IEnumerable<T>介面是協變的，所以PrintBases(IEnumerable<Base> bases)

25         //可以接收一個更加具體化的IEnumerable<Derived>作為其參數。

26         IEnumerable<Base> bIEnum = dlist;

27     }

28 }
下面給協變下個定義：

　　協變：讓一個帶有協變參數的泛型介面（或委託）可以接收類型更加精細化，具體化的泛型介面（或委託）作為參數，可以看成OO中多態的一個延伸。

逆變

1 // 逆變

2 // Assume that the following method is in the class:

3 // static void SetObject(object o) { }

4 Action<object> actObject = SetObject;

5 Action<string> actString = actObject;

6 //委託actString中以後要使用更加精細化的類型string不能再使用object啦！

7 string strHello(“Hello”);

8 actString(strHello);
大家看到了嗎？一個聲明為Action<object>的類型被賦給了一個Action<string>，大家都知道，Action<T>接收參數，沒有傳回值，所以其中的object和string是其參數，這個過程其實就是參數的約束更加強了，也就是說讓參數類型更加精細化。下面我們來給逆變下個定義：

　　逆變：讓一個帶有協變參數的泛型介面（或委託）可以接收粒度更粗的泛型介面或委託作為參數，這個過程實際上是參數類型更加精細化的過程。

一、兩個概念：強型別與弱類型

為了後面敘述方便，我現在這裡自訂兩個概念：強型別和弱類型。在本篇文章中，強型別和弱類型指的是兩個具有直接或者間接繼承關係的兩個類。如果一個類是另一個類的直接或者間接基類，那麼它為弱類型，直接或者間接子類為強型別。後續的介紹中會用到的兩個類Foo和Bar先定義在這裡。Bar繼承自Foo。Foo是弱類型，而Bar則是強型別。

1 public class Foo    

2  {    

3      //Others Members...    

4  }    

5  public class Bar:Foo    

6  {    

7      //Others Members...    

8  }
有了強型別和弱類型的概念，我們就可以這樣的定義協變和逆變：如果類型TBar是基於強型別Bar的類型（比如型別參數為Bar的泛型型別，或者是參數/傳回值類型為Bar的委託），而類型TFoo是基於弱類型Foo的類型，協變就是將TBar類型的執行個體賦值給TFoo類型的變數，而逆變則是將TFoo類型的執行個體賦值給TBar類型的變數。

二、委託中的協變與逆變的使用

協變和逆變主要體現在兩個地方：介面和委託，先來看看在委託中如何使用協變和逆變。現在我們定義了如下一個表示無參函數的泛型委派Function，型別參數為函數傳回值的類型。泛型參數之前添加了一個out關鍵字表示T是一個協變變體。那麼在使用過程中，基於強型別的委託Fucntion執行個體就可以賦值給基於弱類型的委託Fucntion變數。

01 public delegate T Function<out T>();    

02  class Program    

03  {    

04      static void Main()    

05     {    

06         Function funcBar = new Function(GetInstance);    

07         Function funcFoo = funcBar;   

08         Foo foo = funcFoo();    

09     }   

10      static Bar GetInstance()   

11      {   

12          return new Bar();   

13      }   

14  }
接下來介紹逆變委託的用法。下面定義了一個名稱為Operate的泛型委派，接受一個具有泛型參數類型的參數。在定義泛型參數前添加了in關鍵字，表示T是一個基於逆變的變體。由於使用了逆變，我們就可以將基於弱類型的委託Operate執行個體就可以賦值給基於強型別的委託Operate變數。

01 public delegate void Operate<in T>(T instance);  

02 class Program  

03 {  

04 static void Main()  

05 {  

06     Operate opFoo = new Operate(DoSth);  

07     Operate opBar = opFoo;  

08     opBar(new Bar());  

09 }  

10 static void DoSth(Foo foo)  

11 {  

12     //Others...  

13 }  

14 }
三、介面中的協變與逆變的使用

接下來我們同樣通過一個簡單的例子來說明在介面中如何使用協變和逆變。下面定義了一個繼承自 IEnumerable介面的IGroup集合類型，和上面一樣，泛型參數T之前的out關鍵字表明這是一個協變。既然是協變，我們就可以將一個基於強型別的委託IGroup執行個體就可以賦值給基於弱類型的委託IGroup變數。

01 public interface IGroup<out T> : IEnumerable 

02 { }  

03  

04 public class Group : List, IGroup  

05 { } 

06  

07 public delegate void Operate<in T>(T instance);  

08  

09 class Program  

10 {  

11     static void Main()  

12     {  

13         IGroup groupOfBar = new Group();  

14         IGroup groupOfFoo = groupOfBar;  

15         //Others...  

16     } 

17 }
下面是一個逆變介面的例子。首先定義了一個IPaintable的介面，裡面定義了一個可讀寫的Color屬性，便是實現該介面的類型的對象具有自己的顏色，並可以改變顏色。類型Car實現了該介面。介面IBrush定義了一把刷子，泛型型別需要實現IPaintable介面，in關鍵字表明這是一個逆變。方法Paint用於將指定的對象粉刷成相應的顏色，表示被粉刷的對象的類型為泛型參數類型。Brush實現了該介面。由於IBrush定義成逆變，我們就可以將基於強型別的委託IBrush執行個體就可以賦值給基於弱類型的委託IBrush變數。

public interface IPaintable  
{ 
    Color Color { get; set; }  
} 
public class Car : IPaintable  
{  
    public Color Color { get; set; }  
}  

public interface IBrush<in T> where T : IPaintable  
{  
    void Paint(T objectToPaint, Color color);  
}  
public class Brush : IBrush where T : IPaintable  
{  
    public void Paint(T objectToPaint, Color color)  
    {  
        objectToPaint.Color = color;  
    }  
}  

class Program  
{  
    static void Main()  
    {  
        IBrush brush = new Brush();  
        IBrush carBrush = brush;  
       Car car = new Car();  
       carBrush.Paint(car, Color.Red);  
       Console.WriteLine(car.Color.Name);  
    }  
}四、從Func看協變與逆變的本質

接下來我們來談談協變和逆變的本質區別是什麼。在這裡我們以我們非常熟悉的一個委託Func作為例子，下面給出了該委託的定義。我們可以看到Func定義的兩個泛型參數分別屬於逆變和協變。具體來說輸入參數類型為逆變，傳回值類型為協變。

1 public delegate TResult Func<in T, out TResult>(T arg);
再重申以下這句話“輸入參數類型為逆變，傳回值類型為協變”。然後，你再想想為什麼逆變用in關鍵字，而協變用out關鍵字。這兩個不是偶然，實際上我們可以將協變/逆變與輸出/輸入匹配起來。

我們再從另一個角度來理解協變與逆變。我們知道介面代表一種契約，當一個類型實現一個介面的時候就相當於簽署了這份契約，所以必須是實現介面中所有的成員。實際上類型繼承也屬於一種契約關係，基類定義契約，子類“簽署”該契約。對於類型系統來說，介面實現和類型繼承本質上是一致的。契約是弱類型，簽署這份契約的是強型別。

將契約的觀點應用在委託上面，委託實際上定義了一個方法的簽名（參數列表和傳回值），那麼參數和傳回值的類型就是契約，現在的關鍵是誰去履行這份契約。所有參數是外界傳入的，所以基於參數的契約履行者來源於外部，也就是被賦值變數的類型，所以被賦值變數類型是強型別。而對於代理本身來說，參數是一種輸入，也就是一種採用in關鍵字表示的逆變。

而對於委託的傳回值，這是給外部服務的，是委託自身對外界的一種承諾，所以它自己是契約的履行著，因此它自己應該是強型別。相應地，對於代理本身來說，傳回值是一種輸出，也就是一種採用out關鍵字定義的協變。

也正式因為這個原因，對於一個委託，你不能將參數類型定義成成協變，也不能將傳回型別定義成逆變。下面兩中變體定義方式都是不能通過編譯的。

1 delegate TResult Fucntion<out T, TResult>(T arg);  

2 delegate TResult Fucntionin TResult>(T arg);
說到這裡，我想有人要問一個問題，既然輸入表示逆變，輸出表示協變，委託的輸出參數應該定義成協變了？非也，實際上輸出參數在這裡既輸出輸出，也輸出輸入（畢竟調用的時候需要指定一個對應類型的對象）。也正是為此，輸出參數的類型及不能定義成協變，也不能定義成逆變。所以下面兩種變體的定義也是不能通過編譯的。

1 delegate void Action<in T>(out T arg);  

2 delegate void Action<out T>(out T arg);
五、逆變實現了“演算法”的重用

實際上關係協變和逆變體現出來的編程思想，還有一種我比較推崇的說法，那就是：協變是繼承的體現，而逆變體現的則是多態。實際上這與上面分析的契約關係本質上是一致的。

關於逆變，在這裡請容我再囉嗦一句：逆變背後蘊藏的編程思想體現出了對演算法的重用——我們為基類定義了一套操作，可以自動應用於所有子類的對象。

完整樣本

01 /// <summary>

02 /// 協變和逆變允許數群組類型、委託類型和泛型型別參數進行隱式引用轉換。 協變保留分配相容性，逆變與之相反。

03 /// 協變和逆變只能用於參考型別，不能用於實值型別或void

04 /// </summary>

05 public class CovarianceAndContravariance : IFace

06 {

07     public CovarianceAndContravariance()

08     {

09         ///分配相容性

10         string str = "test";

11         object obj = str;

12  

13         ///數組的協變允許派生程度更大的類型的數組隱式轉換為派生程度更小的類型的數組，但是此操作運行時不是型別安全的操作.

14         object[] array = new String[10];

15         // array[0] = 10;

16  

17         ///方法的協變和逆變

18         Func<object> del = GetString;

19         //Func<string> del00 = GetObject;   //傳回值不能逆變

20         Action<string> del2 = SetObject;

21         //Action<object> del22 = SetString; //參數不能協變

22         Action<object> actObject = SetObject;

23         Action<string> actString = actObject;

24  

25         // 泛型型別參數進行隱式引用轉換

26         IEnumerable<string> strings = new List<string>();

27         IEnumerable<object> objects = strings;

28     }

29  

30     static object GetObject() { return null; }

31     static void SetObject(object obj) { }

32  

33     static string GetString() { return ""; }

34     static void SetString(string str) { }

35  

36     /// <summary>

37     /// 介面不存在協變和逆變

38     /// </summary>

39     /// <param name="obj"></param>

40     /// <returns></returns>

41     public string func(object obj)

42     {

43         return null;

44     }

45     public object func2(string obj)

46     {

47         return null;

48     }

49 }

50 public interface IFace

51 {

52     string func(object obj);

53     object func2(string obj);

54 }
　　一句話總結：協變讓一個粗粒度介面（或委託）可以接收一個更加具體的介面（或委託）作為參數（或傳回值）；逆變讓一個介面（或委託）的參數類型（或傳回值）類型更加具體化，也就是參數類型更強，更明確。

　　通常，協變型別參數可用作委託的傳回型別，而逆變型別參數可用作參數類型。對於介面，協變型別參數可用作介面的方法的傳回型別，而逆變型別參數可用作介面的方法的參數類型。

C#4.0新特性（3）：變性 Variance（逆變與協變）