協變和抗變
一.定義
在說定義之前，先看一個簡單的例子：
public class Sharp
{
}
public class Rectange : Sharp
{
}Sharp sharp = new Rectange();那問題就來了，既然Rectange類和Sharp類之間存在一種安全的隱式轉換，那數組Rectange[]和Sharp[]之間是否也存在這種安全的隱式轉換呢？
這就牽扯到了將原本類型上存在的類型轉換映射到他們的數組類型上的能力，這種能力就稱爲“可變性（Variance）”。在.NET中，唯一允許可變性的類型轉換就是由繼承關係帶來的“子類引用->父類引用”轉換。也就是上面例子所滿足的寫法。
然後看下面這種寫法：
Sharp[] sharps=new Rectange[3];像這種與原始類型轉換方向相同的可變性就稱作協變（covariant）
接下來試試這樣寫：
Rectange[] rectanges = new Sharp[3];發現編譯不通過，即數組所對應的單一元素的父類引用不可以安全的轉化爲子類引用。數組也就自然不能依賴這種可變性，達到協變的目的。
所以與協變中子類引用轉化爲父類引用相反，將父類引用轉化爲子類引用的就稱之爲抗變。
即：一個可變性和子類到父類轉換的方向一樣，就稱作協變；而如果和子類到父類的轉換方向相反，就叫抗變！
當然可變性遠遠不只是針對映射到數組的能力，也有映射其它集合的能力如List<T>.
到這裏，很多人就會問了，說了這麼多，那到底這個協變或者抗變有什麼實際利用價值呢？
其價值就在於，在.net
4.0之前可以這麼寫：
Sharp sharp = new Rectange();但是卻不能這麼寫：
IEnumerable<Sharp> sharps = new List<Rectange>();4.0之後，可以允許按上面的寫法了，因爲泛型接口IEnumerable<T>被聲明成如下：
public interface IEnumerable<out T> : IEnumerable
上面提到了，數組不支持抗變。在.Net
4.0之後，支持協變和抗變的有兩種類型：泛型接口和泛型委託。
二.泛型接口中的協變和抗變
接下來定義一個泛型接口：
public interface ICovariant<T>
{
}
public class Sharp : ICovariant<Sharp>
{
}
public class Rectange : Sharp,ICovariant<Rectange>
{
} static void Main(string[] args)
{
ICovariant<Sharp> isharp = new Sharp();
ICovariant<Rectange> irect = new Rectange();
isharp = irect;
}再將接口修改爲：
public interface ICovariant<out T>
{
}即：如果一個泛型接口IFoo<T>，IFoo<TSub>可以轉換爲IFoo<TParent>的話，我們稱這個過程爲協變，而且說“這個泛型接口支持對T的協變”。
那我如果反過來呢，考慮如下代碼：
那我如果反過來呢，考慮如下代碼：
static void Main(string[] args)
{
ICovariant<Sharp> isharp = new Sharp();
ICovariant<Rectange> irect = new Rectange();
irect = isharp;
// isharp =irect;
}原因是無法將
ICovariant<Sharp>
隱式轉化爲
ICovariant<Rectange>
！將接口修改爲：
public interface ICovariant<in T>
{
}即：如果一個泛型接口IFoo<T>，IFoo<TParent>可以轉換爲IFoo<TSub>的話，我們稱這個過程爲抗變（contravariant），而且說“這個泛型接口支持對T的抗變”！
泛型接口並不單單隻有一個參數，所以我們不能簡單地說一個接口支持協變還是抗變，只能說一個接口對某個具體的類型參數支持協變或抗變，如ICovariant<out T1,in T2>說明該接口對類型參數T1支持協變，對T2支持抗變。
舉個例子就是：ICovariant<Rectange,Sharp>能夠轉化成ICovariant<Sharp,Rectange>，這裏既有協變也有抗變。
以上都是接口並沒有屬性或方法的情形，接下來給接口添加一些方法：
//這時候，無論如何修飾T，都不能編譯通過
public interface ICovariant<out T>
{
T Method1();
void Method2(T param);
}原因是，我把僅有的一個類型參數T既用作函數的返回值類型，又用作函數的參數類型。
所以：
1）當我用out修飾時，即允許接口對類型參數T協變，也就是滿足從ICovariant<Rectange>到ICovariant<Sharp>轉換，Method1返回值Rectange到Sharp轉換沒有任何問題：
ICovariant<Sharp> isharp = new Sharp();
ICovariant<Rectange> irect = new Rectange();
isharp = irect;
Sharp sharp = isharp.Method1();但是對於把T作爲參數類型的方法Method2(Rectange)會去替換Method2(Sharp)：
ICovariant<Sharp> isharp = new Sharp();
ICovariant<Rectange> irect = new Rectange();
isharp = irect;
isharp.Method2(new Sharp());Method2(Rectange)
！
2)同樣，當我用in修飾時，
即允許接口對類型參數T抗變，也就是滿足從ICovariant<Sharp>到ICovariant<Rectange>轉換：
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類型：
ICovariant<Sharp> isharp = new Sharp();
ICovariant<Rectange> irect = new Rectange();
//isharp = irect;
irect = isharp;
Rectange rect = irect.Method1();如果一個類型參數僅僅能用於函數的返回值，那麼這個類型參數就對協變相容，用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參數。
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<Sharp>，因爲Rectange是Sharp的子類。因此Method3(Rectange)也就協變成了Method3(Sharp)。當我們調用這個協變,Method3(Sharp)必須能夠安全變成Method3(Rectange)才能滿足原函數的需要(具體原因上面已經示例過了）。這裏對Method3的參數類型要求是Sharp能夠抗變成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參數也可以用於方法的返回值類型，只要藉助一個可以抗變的類型作爲橋樑即可。
三.泛型委託中的協變和抗變
泛型委託的協變抗變，與泛型接口協變抗變類似。繼續延用Sharp，Rectange類作爲示例：新建一個簡單的泛型接口：
public delegate void MyDelegate1<T>(); MyDelegate1<Sharp> sharp1 = new MyDelegate1<Sharp>(MethodForParent1);
MyDelegate1<Rectange> rect1 = new MyDelegate1<Rectange>(MethodForChild1);
sharp1 = rect1;其中兩個方法爲：
public static void MethodForParent1()
{
Console.WriteLine("Test1");
}
public static void MethodForChild1()
{
Console.WriteLine("Test2");
} public delegate void MyDelegate1<out T>();同樣，如果反過來，對類型參數T進行抗變：
MyDelegate1<Sharp> sharp1 = new MyDelegate1<Sharp>(MethodForParent1);
MyDelegate1<Rectange> rect1 = new MyDelegate1<Rectange>(MethodForChild1);
//sharp1 = rect1;
rect1 = sharp1; public delegate void MyDelegate1<in T>();考慮第二個委託：
public delegate T MyDelegate2<out T>();
MyDelegate2<Sharp> sharp2 = new MyDelegate2<Sharp>(MethodForParent2);
MyDelegate2<Rectange> rect2 = new MyDelegate2<Rectange>(MethodForChild2);
sharp2 = rect2; public static Sharp MethodForParent2()
{
return new Sharp();
}
public static Rectange MethodForChild2()
{
return new Rectange();
}測試如下：
public delegate T MyDelegate2<in T>(); MyDelegate2<Sharp> sharp2 = new MyDelegate2<Sharp>(MethodForParent2);
MyDelegate2<Rectange> rect2 = new MyDelegate2<Rectange>(MethodForChild2);
//sharp2 = rect2;
rect2 = sharp2;變體無效: 類型參數“T”必須爲對於“MyDelegate2<T>.Invoke()”有效的 協變式。“T”爲 逆變。
意思就是：這裏的類型參數T已經被聲明成抗變，如果上面的最後一句有效，那麼以後rect2()執行結果返回的將是一個Sharp類型的實例，
如果再出現這種代碼：
Rectange rectange = rect2();
那麼如何對上面的返回類型進行抗變呢？很簡單，只要藉助一個支持抗變的泛型委託作爲方法返回類型即可：
public delegate Contra<T> MyDelegate2<in T>();
public delegate void Contra<in T>(); public static Contra<Sharp> MethodForParent3()
{
return new Contra<Sharp>(MethodForParent1);
}
public static Contra<Rectange> MethodForChild3()
{
return new Contra<Rectange>(MethodForChild1);
} MyDelegate2<Sharp> sharp2 = new MyDelegate2<Sharp>(MethodForParent3);
MyDelegate2<Rectange> rect2 = new MyDelegate2<Rectange>(MethodForChild3);
rect2 = sharp2;接下來考慮第三個委託：
public delegate T MyDelegate3<T>(T param); public delegate T MyDelegate3<out T>(T param); public static Sharp MethodForParent4(Sharp param)
{
return new Sharp();
}
public static Rectange MethodForChild4(Rectange param)
{
return new Rectange();
} MyDelegate3<Sharp> sharp3 = new MyDelegate3<Sharp>(MethodForParent4);
MyDelegate3<Rectange> rect3 = new MyDelegate3<Rectange>(MethodForChild4);
sharp3 = rect3;即：
public delegate T MyDelegate3<out T>(Contra<T> param); public static Sharp MethodForParent4(Contra<Sharp> param)
{
return new Sharp();
}
public static Rectange MethodForChild4(Contra<Rectange> param)
{
return new Rectange();
}同理，如果對該委託類型參數T進行抗變，那麼根據方法返回類型協變-抗變一致原則，方法返回參數也是要藉助一個對類型參數能抗變的泛型委託：
public delegate Contra<T> MyDelegate3<in T>(T param); public static Contra<Sharp> MethodForParent4(Sharp param)
{
return new Contra<Sharp>(MethodForParent1);
}
public static Contra<Rectange> MethodForChild4(Rectange param)
{
return new Contra<Rectange>(MethodForChild1);
} public delegate T1 MyDelegate4<T1,T2,T3>(T2 param1,T3 param2); public delegate T1 MyDelegate4<out T1,in T2,in T3>(T2 param1,T3 param2);但是如果變成：
public delegate T1 MyDelegate4<in T1,out T2,in T3>(T2 param1,T3 param2);1）方法返回類型的協變-抗變一致原則；
2）方法參數類型的協變-抗變互換原則！
對應本篇的例子，就可以修改成：
public delegate Contra<T1> MyDelegate4<in T1, out T2, in T3>(Contra<T2> param1, T3 param2);以上，協變和抗變記錄到此。
