轉自：

協變和抗變

一.定義

在說定義之前，先看一個簡單的例子：
? ? public class Shape
? ? {
? ? }
?
? ? public class Rectange : Shape
? ? {
? ? }
上面定義了兩個簡單的類，一個是圖形類，一個是矩形類；它們之間有簡單的繼承關系。接下來是常見的一種正確寫法：
Shape shape= new Rectange();
就是說“子類引用可以直接轉化成父類引用”，或者說Rectange類和Shape類之間存在一種安全的隱式轉換。
那問題就來了，既然Rectange類和Shape類之間存在一種安全的隱式轉換，那數組Rectange[]和Shape[]之間是否也存在這種安全的隱式轉換呢？
這就牽扯到了將原本類型上存在的類型轉換映射到他們的數組類型上的能力，這種能力就稱為“可變性（Variance）”。在.NET中，唯一允許可變性的類型轉換就是由繼承關系帶來的“子類引用->父類引用”轉換。也就是上面例子所滿足的寫法。
然后看下面這種寫法：
Shape[] shapes=new Rectange[3];
編譯通過，這說明Rectange[]和Shape[]之間存在安全的隱式轉換。
像這種與原始類型轉換方向相同的可變性就稱作協變（covariant）

接下來試試這樣寫：
Rectange[] rectanges = new Shape[3];
發現編譯不通過，即數組所對應的單一元素的父類引用不可以安全的轉化為子類引用。數組也就自然不能依賴這種可變性，達到協變的目的。
所以與協變中子類引用轉化為父類引用相反，將父類引用轉化為子類引用的就稱之為抗變。
即：一個可變性和子類到父類轉換的方向一樣，就稱作協變；而如果和子類到父類的轉換方向相反，就叫抗變！
?

當然可變性遠遠不只是針對映射到數組的能力，也有映射其它集合的能力如List<T>.
到這里，很多人就會問了，說了這么多，那到底這個協變或者抗變有什么實際利用價值呢？
其價值就在于，在.net 4.0之前可以這么寫：
????????????Shape shape?= new Rectange();
但是卻不能這么寫：
????????????IEnumerable<Shape> shapes = new List<Rectange>();
4.0之后，可以允許按上面的寫法了，因為泛型接口IEnumerable<T>被聲明成如下：
public interface IEnumerable<out T> : IEnumerable

上面提到了，數組不支持抗變。在.Net 4.0之后，支持協變和抗變的有兩種類型：泛型接口和泛型委托。

?
二.泛型接口中的協變和抗變

接下來定義一個泛型接口：
public interface ICovariant<T>
{
}
并且讓上面的兩個類各自繼承一下該接口：
????public class Shape : ICovariant<Shape>
????{
????}
?
????public class Rectange : Shape,ICovariant<Rectange>
????{
????}
編寫測試代碼：
????????static void Main(string[] args)
????????{
????????????ICovariant<Shape> ishape = new Shape();
????????????ICovariant<Rectange> irect = new Rectange();
?
????????????ishape = irect;
????????}
編譯并不能通過，原因是無法將ICovariant<Rectange>隱式轉化為ICovariant<Shape>！
再將接口修改為：
????public interface ICovariant<out T>
????{
????}
編譯順利通過。這里我為泛型接口的類型參數增加了一個修飾符out，它表示這個泛型接口支持對類型T的協變。
即：如果一個泛型接口IFoo<T>，IFoo<TSub>可以轉換為IFoo<TParent>的話，我們稱這個過程為協變，而且說“這個泛型接口支持對T的協變”。

那我如果反過來呢，考慮如下代碼：
????????static void Main(string[] args)
????????{
????????????ICovariant<Shape> ishape = new Shape();
????????????ICovariant<Rectange> irect = new Rectange();
?
????????????irect = ishape;
???????????// ishape =irect;
????????}
發現編譯又不通過了， 原因是無法將 ICovariant<Shape> 隱式轉化為 ICovariant<Rectange> ！
將接口修改為：
????public interface ICovariant<in T>
????{
????}
編譯順利通過。這里我將泛型接口的類型參數T修飾符修改成in，它表示這個泛型接口支持對類型參數T的抗變。
即：如果一個泛型接口IFoo<T>，IFoo<TParent>可以轉換為IFoo<TSub>的話，我們稱這個過程為抗變（contravariant），而且說“這個泛型接口支持對T的抗變”！

泛型接口并不單單只有一個參數，所以我們不能簡單地說一個接口支持協變還是抗變，只能說一個接口對某個具體的類型參數支持協變或抗變，如ICovariant<out T1,in T2>說明該接口對類型參數T1支持協變，對T2支持抗變。
舉個例子就是：ICovariant<Rectange,Shape>能夠轉化成ICovariant<Shape,Rectange>，這里既有協變也有抗變。

以上都是接口并沒有屬性或方法的情形，接下來給接口添加一些方法：
????//這時候，無論如何修飾T，都不能編譯通過
????public interface ICovariant<out T>
????{
????????T Method1();
????????void Method2(T param);
????}
發現無論用out還是in修飾T參數，根本編譯不通過。
原因是，我把僅有的一個類型參數T既用作函數的返回值類型，又用作函數的參數類型。
所以：
1）當我用out修飾時，即允許接口對類型參數T協變，也就是滿足從ICovariant<Rectange>到ICovariant<Shape>轉換，Method1返回值Rectange到Shape轉換沒有任何問題：
????????????ICovariant<Shape> ishape = new Shape();
????????????ICovariant<Rectange> irect = new Rectange();
?
????????????ishape = irect;
????????????Shape shape = ishape.Method1();
但是對于把T作為參數類型的方法Method2(Rectange)會去替換Method2(Shape)：
????????????ICovariant<Shape> ishape = new Shape();
????????????ICovariant<Rectange> irect = new Rectange();
?
????????????ishape = irect;
????????????ishape.Method2(new Shape());
即如果執行最后一行代碼，會發現參數中，Shape類型并不能安全轉化成Rectange類型，因為Method2(Shape)實際上已經被替換成
Method2(Rectange) ！

2)同樣，當我用in修飾時， 即允許接口對類型參數T抗變，也就是滿足從ICovariant<Shape>到ICovariant<Rectange>轉換：
?????????????ICovariant<Shape> ishape = new Shape();
????????????ICovariant<Rectange> irect = new Rectange();
?
????????????//ishape = irect;
????????????irect = ishape;
????????????irect.Method2(new Rectange());
Method2(Shape)會去替換Method2(Rectange)，所以上面的最后一句代碼無論以Rectange類型還是Shape類型為參數都沒有任何問題；
但是Method1返回的將是Shape類型：
?????????????ICovariant<Shape> ishape = new Shape();
????????????ICovariant<Rectange> irect = new Rectange();
?
????????????//ishape = irect;
????????????irect = ishape;
????????????Rectange rect = irect.Method1();
執行最后一句代碼，同樣將會是不安全的！

綜上：在沒有額外機制的限制下，接口進行協變或抗變都是類型不安全的。.NET 4.0有了改進，它允許在類型參數的聲明時增加一個額外的描述，以確定這個類型參數的使用范圍，這個額外的描述即in,out修飾符，它們倆的用法如下：
如果一個類型參數僅僅能用于函數的返回值，那么這個類型參數就對協變相容，用out修飾。而相反，一個類型參數如果僅能用于方法參數，那么這個類型參數就對抗變相容，用in修飾。

所以，需要將上面的接口拆成兩個接口即可：
????public interface ICovariant<out T>
????{
????????T Method1();
?
????}
?
????public interface IContravariant<in T>
????{
????????void Method2(T param);
????}

.net中很多接口都僅將參數用于函數返回類型或函數參數類型，如：
public interface IComparable<in T>
public interface IEnumerable<out T> : IEnumerable

幾個重要的注意點：

1.僅有泛型接口和泛型委托支持對類型參數的可變性，泛型類或泛型方法是不支持的。
2.值類型不參與協變或抗變，IFoo<int>永遠無法協變成IFoo<object>，不管有無聲明out。因為.NET泛型，每個值類型會生成專屬的封閉構造類型，與引用類型版本不兼容。
3.聲明屬性時要注意，可讀寫的屬性會將類型同時用于參數和返回值。因此只有只讀屬性才允許使用out類型參數，只寫屬性能夠使用in參數。

接下來將接口代碼改成：
????public interface ICovariant<out T>
????{
????????T Method1();
????????void Method3(IContravariant<T> param);
????}
?
????public interface IContravariant<in T>
????{
????????void Method2(T param);
????}
同樣是可以編譯通過的.
我們需要費一些周折來理解這個問題。現在我們考慮ICovariant<Rectange>，它應該能夠協變成ICovariant<Shape>，因為Rectange是Shape的子類。因此Method3(Rectange)也就協變成了Method3(Shape)。當我們調用這個協變,Method3(Shape)必須能夠安全變成Method3(Rectange)才能滿足原函數的需要(具體原因上面已經示例過了）。這里對Method3的參數類型要求是Shape能夠抗變成Rectange！也就是說，如果一個接口需要對類型參數T協變，那么這個接口所有方法的參數類型必須支持對類型參數T的抗變（如果T有作為某些方法的參數類型）。
同理我們也可以看出，如果接口要支持對T抗變，那么接口中方法的參數類型都必須支持對T協變才行。這就是方法參數的協變-抗變互換原則。所以，我們并不能簡單地說out參數只能用于方法返回類型參數，它確實只能直接用于聲明返回值類型，但是只要一個支持抗變的類型協助，out類型參數就也可以用于參數類型！（即上面的例子），換句話說，in除了直接聲明方法參數類型支持抗變之外，也僅能借助支持協變的類型才能用于方法參數，僅支持對T抗變的類型作為方法參數類型也是不允許的。

既然方法類型參數協變和抗變有上面的互換影響。那么方法的返回值類型會不會有同樣的問題呢？
將接口修改為:
????public interface IContravariant<in T>
????{
?
????}
????public interface ICovariant<out T>
????{
?
????}
?
????public interface ITest<out T1, in T2>
????{
????????ICovariant<T1> test1();
????????IContravariant<T2> test2();
????}

我們看到和剛剛正好相反，如果一個接口需要對類型參數T進行協變或抗變，那么這個接口所有方法的返回值類型必須支持對T同樣方向的協變或抗變（如果有某些方法的返回值是T類型）。這就是方法返回值的協變-抗變一致原則。也就是說，即使in參數也可以用于方法的返回值類型，只要借助一個可以抗變的類型作為橋梁即可。

三.泛型委托中的協變和抗變

泛型委托的協變抗變，與泛型接口協變抗變類似。繼續延用Shape，Rectange類作為示例：
新建一個簡單的泛型接口：
????????public delegate void MyDelegate1<T>();
測試代碼：
????????????MyDelegate1<Shape> shape1 = new MyDelegate1<Shape>(MethodForParent1);
????????????MyDelegate1<Rectange> rect1 = new MyDelegate1<Rectange>(MethodForChild1);
????????????shape1 = rect1;
其中兩個方法為：
????????public static void MethodForParent1()?
????????{
????????????Console.WriteLine("Test1");
????????}
????????public static void MethodForChild1()
????????{
????????????Console.WriteLine("Test2");
????????}
編譯并不能通過，因為無法將MyDelegate1<Rectange>隱式轉化為MyDelegate1<Shape>，接下來我將接口修改為支持對類型參數T協變，即加out修飾符：
????????public delegate void MyDelegate1<out T>();
編譯順利用過。
同樣，如果反過來，對類型參數T進行抗變：
????????????MyDelegate1<Shape> shape1 = new MyDelegate1<Shape>(MethodForParent1);
????????????MyDelegate1<Rectange> rect1 = new MyDelegate1<Rectange>(MethodForChild1);
????????????//shape1 = rect1;
????????????rect1 = shape1;
只需將修飾符改為in即可：
????????public delegate void MyDelegate1<in T>();

考慮第二個委托：
????????public delegate T MyDelegate2<out T>();
測試代碼：
????????????MyDelegate2<Shape> shape2 = new MyDelegate2<Shape>(MethodForParent2);
????????????MyDelegate2<Rectange> rect2 = new MyDelegate2<Rectange>(MethodForChild2);
????????????shape2 = rect2;
其中兩個方法為：
????????public static Shape MethodForParent2()
????????{
????????????return new Shape();
????????}
????????public static Rectange MethodForChild2()
????????{
????????????return new Rectange();
????????}
該委托對類型參數T進行協變沒有任何問題，編譯通過；如果我要對T進行抗變呢？是否只要將修飾符改成in就OK了？
測試如下：
????????public delegate T MyDelegate2<in T>();
????????????MyDelegate2<Shape> shape2 = new MyDelegate2<Shape>(MethodForParent2);
????????????MyDelegate2<Rectange> rect2 = new MyDelegate2<Rectange>(MethodForChild2);
????????????//shape2 = rect2;
????????????rect2 = shape2;
錯誤如下：
變體無效: 類型參數“T”必須為對于“MyDelegate2<T>.Invoke()”有效的 協變式。“T”為 逆變。
意思就是：這里的類型參數T已經被聲明成抗變，如果上面的最后一句有效，那么以后rect2()執行結果返回的將是一個Shape類型的實例，
如果再出現這種代碼：
????????????Rectange rectange = rect2();
那么這將是一個從Shape類到Rectange類的不安全的類型轉換！所以如果類型參數T抗變，并且要用于方法返回類型，那么方法的返回類型也必須支持抗變。即上面所說的方法返回類型協變-抗變一致原則。
那么如何對上面的返回類型進行抗變呢？很簡單，只要借助一個支持抗變的泛型委托作為方法返回類型即可：
????????public delegate Contra<T> MyDelegate2<in T>();
????????public delegate void Contra<in T>();
具體的方法也需要對應著修改一下：
????????public static Contra<Shape> MethodForParent3()
????????{
????????????return new Contra<Shape>(MethodForParent1);
????????}
????????public static Contra<Rectange> MethodForChild3()
????????{
????????????return new Contra<Rectange>(MethodForChild1);
????????}
測試代碼：
????????????MyDelegate2<Shape> shape2 = new MyDelegate2<Shape>(MethodForParent3);
????????????MyDelegate2<Rectange> rect2 = new MyDelegate2<Rectange>(MethodForChild3);
????????????rect2 = shape2;
編譯通過。

接下來考慮第三個委托：
????????public delegate T MyDelegate3<T>(T param);
首先，對類型參數T進行協變：
????????public delegate T MyDelegate3<out T>(T param);
對應的方法及測試代碼：
????????public static Shape MethodForParent4(Shape param)
????????{
????????????return new Shape();
????????}
????????public static Rectange MethodForChild4(Rectange param)
????????{
????????????return new Rectange();
????????}
????????????MyDelegate3<Shape> shape3 = new MyDelegate3<Shape>(MethodForParent4);
????????????MyDelegate3<Rectange> rect3 = new MyDelegate3<Rectange>(MethodForChild4);
????????????shape3 = rect3;
和泛型接口類似，這里的委托類型參數T被同時用作方法返回類型和方法參數類型，不管修飾符改成in或out,編譯都無法通過。所以如果用out修飾T，那么方法參數param的參數類型T就需借助一樣東西來轉換一下：一個對類型參數T能抗變的泛型委托。
即：
????????public delegate T MyDelegate3<out T>(Contra<T> param);
兩個方法也需對應著修改：
????????public static Shape MethodForParent4(Contra<Shape> param)
????????{
????????????return new Shape();
????????}
????????public static Rectange MethodForChild4(Contra<Rectange> param)
????????{
????????????return new Rectange();
????????}
這就是上面所說的方法參數的協變-抗變互換原則
同理，如果對該委托類型參數T進行抗變，那么根據方法返回類型協變-抗變一致原則，方法返回參數也是要借助一個對類型參數能抗變的泛型委托：
????????public delegate Contra<T> MyDelegate3<in T>(T param);
兩個方法也需對應著修改為：
????????public static Contra<Shape> MethodForParent4(Shape param)
????????{
????????????return new Contra<Shape>(MethodForParent1);
????????}
????????public static Contra<Rectange> MethodForChild4(Rectange param)
????????{
????????????return new Contra<Rectange>(MethodForChild1);
????????}
推廣到一般的泛型委托：
????????public delegate T1 MyDelegate4<T1,T2,T3>(T2 param1,T3 param2);
可能三個參數T1，T2，T3會有各自的抗變和協變，如：
????????public delegate T1 MyDelegate4<out T1,in T2,in T3>(T2 param1,T3 param2);
這是一種最理想的情況，T1支持協變，用于方法返回值；T2，T3支持抗變，用于方法參數。
但是如果變成：
????????public delegate T1 MyDelegate4<in T1,out T2,in T3>(T2 param1,T3 param2);
那么對應的T1，T2類型參數就會出問題，原因上面都已經分析過了。于是就需要修改T1對應的方法返回類型，T2對應的方法參數類型，如何修改？只要根據上面提到的：
1）方法返回類型的協變-抗變一致原則；
2）方法參數類型的協變-抗變互換原則！

對應本篇的例子，就可以修改成：
????????public delegate Contra<T1> MyDelegate4<in T1, out T2, in T3>(Contra<T2> param1, T3 param2);

以上，協變和抗變記錄到此。

總結

以上是生活随笔為你收集整理的【转】c# 协变与抗变的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。