協變和抗變

一.定義

在說定義之前，先看一個簡單的例子：

    public class Sharp
    {
    }

    public class Rectange : Sharp
    {
    }

上面定義了兩個簡單的類，一個是圖形類，一個是矩形類；它們之間有簡單的繼承關係。接下來是常見的一種正確寫法：

Sharp sharp = new Rectange();

就是說“子類引用可以直接轉化成父類引用”，或者說Rectange類和Sharp類之間存在一種安全的隱式轉換。 那問題就來了，既然Rectange類和Sharp類之間存在一種安全的隱式轉換，那陣列Rectange[]和Sharp[]之間是否也存在這種安全的隱式轉換呢？

這就牽扯到了將原本型別上存在的型別轉換對映到他們的陣列型別上的能力，這種能力就稱為“可變性（Variance）”。在.NET中，唯一允許可變性的型別轉換就是由繼承關係帶來的“子類引用->父類引用”轉換。也就是上面例子所滿足的寫法。
然後看下面這種寫法：

Sharp[] sharps=new Rectange[3];

編譯通過，這說明Rectange[]和Sharp[]之間存在安全的隱式轉換。 像這種與原始型別轉換方向相同的可變性就稱作協變（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;
        }

編譯並不能通過，原因是無法將ICovariant<Rectange>隱式轉化為ICovariant<Sharp>！ 再將介面修改為：

    public interface ICovariant<out T>
    {
    }

編譯順利通過。這裡我為泛型介面的型別引數增加了一個修飾符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>
    {
    }

編譯順利通過。這裡我將泛型介面的型別引數T修飾符修改成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);
    }

發現無論用out還是in修飾T引數，根本編譯不通過。 原因是，我把僅有的一個型別引數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());

即如果執行最後一行程式碼，會發現引數中，Sharp型別並不能安全轉化成Rectange型別，因為Method2(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();

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

綜上：在沒有額外機制的限制下，介面進行協變或抗變都是型別不安全的。.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<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");
        }

編譯並不能通過，因為無法將MyDelegate1<Rectange>隱式轉化為MyDelegate1<Sharp>，接下來我將介面修改為支援對型別引數T協變，即加out修飾符：

        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;

只需將修飾符改為in即可：

        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();
        }

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

        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();

那麼這將是一個從Sharp類到Rectange類的不安全的型別轉換！所以如果型別引數T抗變，並且要用於方法返回型別，那麼方法的返回型別也必須支援抗變。即上面所說的方法返回型別協變-抗變一致原則。 那麼如何對上面的返回型別進行抗變呢？很簡單，只要藉助一個支援抗變的泛型委託作為方法返回型別即可：

        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);

首先，對型別引數T進行協變：

        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;

和泛型介面類似，這裡的委託型別引數T被同時用作方法返回型別和方法引數型別，不管修飾符改成in或out,編譯都無法通過。所以如果用out修飾T，那麼方法引數param的引數型別T就需藉助一樣東西來轉換一下：一個對型別引數T能抗變的泛型委託。
即：

        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);

可能三個引數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);

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