c# 抗變 協變

一.定義
在說定義之前，先看一個簡單的例子：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片

public class Sharp  
{  
}  

public class Rectange : Sharp  
{  
}  

上面定義了兩個簡單的類，一個是圖形類，一個是矩形類；它們之間有簡單的繼承關係。接下來是常見的一種正確寫法：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片
Sharp sharp = new Rectange();
就是說“子類引用可以直接轉化成父類引用”，或者說Rectange類和Sharp類之間存在一種安全的隱式轉換。

注意：
root = new Child();
基類的對象當然不能訪問派生類的成員了，雖然實際上是個child對象，但其類型是parent，向上轉換後，已經屏蔽了對派生類成員的訪問

root這個對象，會忽略child類的其他派生方法，只有重寫方法受到影響。

那問題就來了，既然Rectange類和Sharp類之間存在一種安全的隱式轉換，那數組Rectange[]和Sharp[]之間是否也存在這種安全的隱式轉換呢？
這就牽扯到了將原本類型上存在的類型轉換映射到他們的數組類型上的能力，這種能力就稱爲“可變性（Variance）”。在.NET中，唯一允許可變性的類型轉換就是由繼承關係帶來的“子類引用->父類引用”轉換。也就是上面例子所滿足的寫法。
然後看下面這種寫法：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片

Sharp[] sharps=new Rectange[3];  

編譯通過，這說明Rectange[]和Sharp[]之間存在安全的隱式轉換。
像這種與原始類型轉換方向相同的可變性就稱作協變（covariant）

接下來試試這樣寫：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片

Rectange[] rectanges = new Sharp[3];  

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

當然可變性遠遠不只是針對映射到數組的能力，也有映射其它集合的能力如List.
到這裏，很多人就會問了，說了這麼多，那到底這個協變或者抗變有什麼實際利用價值呢？
其價值就在於，在.net 4.0之前可以這麼寫：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片

Sharp sharp = new Rectange();  

但是卻不能這麼寫：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片

IEnumerable<Sharp> sharps = new List<Rectange>();  

4.0之後，可以允許按上面的寫法了，因爲泛型接口IEnumerable被聲明成如下：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片

public interface IEnumerable<out T> : IEnumerable  

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

二.泛型接口中的協變和抗變
接下來定義一個泛型接口：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片

public interface ICovariant<T>  
{  
}  

並且讓上面的兩個類各自繼承一下該接口：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片

public class Sharp : ICovariant<Sharp>  
{  
}  

public class Rectange : Sharp,ICovariant<Rectange>  
{  
}  

編寫測試代碼：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片

static void Main(string[] args)  
{  
    ICovariant<Sharp> isharp = new Sharp();  
    ICovariant<Rectange> irect = new Rectange();  

    isharp = irect;  
}  

編譯並不能通過，原因是無法將ICovariant隱式轉化爲ICovariant！
再將接口修改爲：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片

public interface ICovariant<out T>  
{  
}  

編譯順利通過。這裏我爲泛型接口的類型參數增加了一個修飾符out，它表示這個泛型接口支持對類型T的協變。
即：如果一個泛型接口IFoo，IFoo可以轉換爲IFoo的話，我們稱這個過程爲協變，而且說“這個泛型接口支持對T的協變”。

那我如果反過來呢，考慮如下代碼：

[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片 
static void Main(string[] args)  
{  
    ICovariant<Sharp> isharp = new Sharp();  
    ICovariant<Rectange> irect = new Rectange();  

    irect = isharp;  
   // isharp =irect;  
}  

發現編譯又不通過了， 原因是無法將 ICovariant 隱式轉化爲 ICovariant ！
將接口修改爲：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片

public interface ICovariant<in T>  
{  
}  

編譯順利通過。這裏我將泛型接口的類型參數T修飾符修改成in，它表示這個泛型接口支持對類型參數T的抗變。
即：如果一個泛型接口IFoo，IFoo可以轉換爲IFoo的話，我們稱這個過程爲抗變（contravariant），而且說“這個泛型接口支持對T的抗變”！

泛型接口並不單單隻有一個參數，所以我們不能簡單地說一個接口支持協變還是抗變，只能說一個接口對某個具體的類型參數支持協變或抗變，如ICovariant

public interface ICovariant<out T>  
{  
    T Method1();  
    void Method2(T param);  
}  

發現無論用out還是in修飾T參數，根本編譯不通過。
原因是，我把僅有的一個類型參數T既用作函數的返回值類型，又用作函數的參數類型。
所以：
1）當我用out修飾時，即允許接口對類型參數T協變，也就是滿足從ICovariant到ICovariant轉換，Method1返回值Rectange到Sharp轉換沒有任何問題：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片

ICovariant<Sharp> isharp = new Sharp();  
ICovariant<Rectange> irect = new Rectange();  

isharp = irect;  
Sharp sharp = isharp.Method1();  

但是對於把T作爲參數類型的方法Method2(Rectange)會去替換Method2(Sharp)：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片

ICovariant<Sharp> isharp = new Sharp();  
ICovariant<Rectange> irect = new Rectange();  

isharp = irect;  
isharp.Method2(new Sharp());  

即如果執行最後一行代碼，會發現參數中，Sharp類型並不能安全轉化成Rectange類型，因爲Method2(Sharp)實際上已經被替換成

Method2(Rectange)  ！

2)同樣，當我用in修飾時， 即允許接口對類型參數T抗變，也就是滿足從ICovariant到ICovariant轉換：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片

ICovariant<Sharp> isharp = new Sharp();  
ICovariant<Rectange> irect = new Rectange();  

//isharp = irect;  
irect = isharp;  
irect.Method2(new Rectange());  
Method2(Sharp)會去替換Method2(Rectange)，所以上面的最後一句代碼無論以Rectange類型還是Sharp類型爲參數都沒有任何問題；
但是Method1返回的將是Sharp類型：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片 
ICovariant<Sharp> isharp = new Sharp();  
ICovariant<Rectange> irect = new Rectange();  

//isharp = irect;  
irect = isharp;  
Rectange rect = irect.Method1();  

執行最後一句代碼，同樣將會是不安全的！

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

所以，需要將上面的接口拆成兩個接口即可：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片

public interface ICovariant<out T>  
{  
    T Method1();  

}  

public interface IContravariant<in T>  
{  
    void Method2(T param);  
}  

.net中很多接口都僅將參數用於函數返回類型或函數參數類型，如：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片
public interface IComparable
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片

public interface IEnumerable<out T> : IEnumerable  

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

接下來將接口代碼改成：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片

public interface ICovariant<out T>  
{  
    T Method1();  
    void Method3(IContravariant<T> param);  
}  

public interface IContravariant<in T>  
{  
    void Method2(T param);  
}  

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

既然方法類型參數協變和抗變有上面的互換影響。那麼方法的返回值類型會不會有同樣的問題呢？
將接口修改爲:
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片

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參數也可以用於方法的返回值類型，只要藉助一個可以抗變的類型作爲橋樑即可。

三.泛型委託中的協變和抗變
泛型委託的協變抗變，與泛型接口協變抗變類似。繼續延用Sharp，Rectange類作爲示例：
新建一個簡單的泛型接口：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片

public delegate void MyDelegate1<T>();  
測試代碼：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片 
MyDelegate1<Sharp> sharp1 = new MyDelegate1<Sharp>(MethodForParent1);  
MyDelegate1<Rectange> rect1 = new MyDelegate1<Rectange>(MethodForChild1);  
sharp1 = rect1;  
其中兩個方法爲：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片 
public static void MethodForParent1()   
{  
    Console.WriteLine("Test1");  
}  
public static void MethodForChild1()  
{  
    Console.WriteLine("Test2");  
}  

編譯並不能通過，因爲無法將MyDelegate1隱式轉化爲MyDelegate1，接下來我將接口修改爲支持對類型參數T協變，即加out修飾符：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片
public delegate void MyDelegate1();
編譯順利用過。
同樣，如果反過來，對類型參數T進行抗變：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片

MyDelegate1<Sharp> sharp1 = new MyDelegate1<Sharp>(MethodForParent1);  
MyDelegate1<Rectange> rect1 = new MyDelegate1<Rectange>(MethodForChild1);  
//sharp1 = rect1;  
rect1 = sharp1;  

只需將修飾符改爲in即可：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片

public delegate void MyDelegate1<in T>();  

考慮第二個委託：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片 
public delegate T MyDelegate2<out T>();  
測試代碼：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片 
MyDelegate2<Sharp> sharp2 = new MyDelegate2<Sharp>(MethodForParent2);  
MyDelegate2<Rectange> rect2 = new MyDelegate2<Rectange>(MethodForChild2);  
sharp2 = rect2;  
其中兩個方法爲：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片 
public static Sharp MethodForParent2()  
{  
    return new Sharp();  
}  
public static Rectange MethodForChild2()  
{  
    return new Rectange();  
}  

該委託對類型參數T進行協變沒有任何問題，編譯通過；如果我要對T進行抗變呢？是否只要將修飾符改成in就OK了？
測試如下：

[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片 
public delegate T MyDelegate2<in T>();  
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片 
MyDelegate2<Sharp> sharp2 = new MyDelegate2<Sharp>(MethodForParent2);  
MyDelegate2<Rectange> rect2 = new MyDelegate2<Rectange>(MethodForChild2);  
//sharp2 = rect2;  
rect2 = sharp2;  

錯誤如下：
變體無效: 類型參數“T”必須爲對於“MyDelegate2.Invoke()”有效的 協變式。“T”爲 逆變。
意思就是：這裏的類型參數T已經被聲明成抗變，如果上面的最後一句有效，那麼以後rect2()執行結果返回的將是一個Sharp類型的實例，
如果再出現這種代碼：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片
Rectange rectange = rect2();
那麼這將是一個從Sharp類到Rectange類的不安全的類型轉換！所以如果類型參數T抗變，並且要用於方法返回類型，那麼方法的返回類型也必須支持抗變。即上面所說的方法返回類型協變-抗變一致原則。
那麼如何對上面的返回類型進行抗變呢？很簡單，只要藉助一個支持抗變的泛型委託作爲方法返回類型即可：

[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片 
public delegate Contra<T> MyDelegate2<in T>();  
public delegate void Contra<in T>();  
具體的方法也需要對應着修改一下：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片 
public static Contra<Sharp> MethodForParent3()  
{  
    return new Contra<Sharp>(MethodForParent1);  
}  
public static Contra<Rectange> MethodForChild3()  
{  
    return new Contra<Rectange>(MethodForChild1);  
}  
測試代碼：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片 
MyDelegate2<Sharp> sharp2 = new MyDelegate2<Sharp>(MethodForParent3);  
MyDelegate2<Rectange> rect2 = new MyDelegate2<Rectange>(MethodForChild3);  
rect2 = sharp2;  
編譯通過。

接下來考慮第三個委託：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片
public delegate T MyDelegate3(T param);
首先，對類型參數T進行協變：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片

public delegate T MyDelegate3<out T>(T param);  
對應的方法及測試代碼：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片 
public static Sharp MethodForParent4(Sharp param)  
{  
    return new Sharp();  
}  
public static Rectange MethodForChild4(Rectange param)  
{  
    return new Rectange();  
}  
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片 
MyDelegate3<Sharp> sharp3 = new MyDelegate3<Sharp>(MethodForParent4);  
MyDelegate3<Rectange> rect3 = new MyDelegate3<Rectange>(MethodForChild4);  
sharp3 = rect3;  

和泛型接口類似，這裏的委託類型參數T被同時用作方法返回類型和方法參數類型，不管修飾符改成in或out,編譯都無法通過。所以如果用out修飾T，那麼方法參數param的參數類型T就需藉助一樣東西來轉換一下：一個對類型參數T能抗變的泛型委託。
即：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片
public delegate T MyDelegate3(Contra param);
兩個方法也需對應着修改：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片

public static Sharp MethodForParent4(Contra<Sharp> param)  
{  
    return new Sharp();  
}  
public static Rectange MethodForChild4(Contra<Rectange> param)  
{  
    return new Rectange();  
}  

這就是上面所說的方法參數的協變-抗變互換原則
同理，如果對該委託類型參數T進行抗變，那麼根據方法返回類型協變-抗變一致原則，方法返回參數也是要藉助一個對類型參數能抗變的泛型委託：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片
public delegate Contra MyDelegate3(T param);
兩個方法也需對應着修改爲：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片

public static Contra<Sharp> MethodForParent4(Sharp param)  
{  
    return new Contra<Sharp>(MethodForParent1);  
}  
public static Contra<Rectange> MethodForChild4(Rectange param)  
{  
    return new Contra<Rectange>(MethodForChild1);  
}  

推廣到一般的泛型委託：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片

public delegate T1 MyDelegate4<T1,T2,T3>(T2 param1,T3 param2);  
可能三個參數T1，T2，T3會有各自的抗變和協變，如：
[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片 
public delegate T1 MyDelegate4<out T1,in T2,in T3>(T2 param1,T3 param2);  

這是一種最理想的情況，T1支持協變，用於方法返回值；T2，T3支持抗變，用於方法參數。
但是如果變成：

[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片 
public delegate T1 MyDelegate4<in T1,out T2,in T3>(T2 param1,T3 param2);  

那麼對應的T1，T2類型參數就會出問題，原因上面都已經分析過了。於是就需要修改T1對應的方法返回類型，T2對應的方法參數類型，如何修改？只要根據上面提到的：
1）方法返回類型的協變-抗變一致原則；
2）方法參數類型的協變-抗變互換原則！

對應本篇的例子，就可以修改成：

[csharp] view plaincopy在CODE上查看代碼片派生到我的代碼片 
public delegate Contra<T1> MyDelegate4<in T1, out T2, in T3>(Contra<T2> param1, T3 param2);  

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