C#:協變和抗變
阿新 • • 發佈:2019-02-04
協變和抗變
一.定義
在說定義之前,先看一個簡單的例子: public class Sharp
{
}
public class Rectange : Sharp
{
}
上面定義了兩個簡單的類,一個是圖形類,一個是矩形類;它們之間有簡單的繼承關係。接下來是常見的一種正確寫法:
Sharp sharp = new Rectange();
就是說“子類引用可以直接轉化成父類引用”,或者說Rectange類和Sharp類之間存在一種安全的隱式轉換。
那問題就來了,既然Rectange類和Sharp類之間存在一種安全的隱式轉換,那陣列Rectange[]和Sharp[]之間是否也存在這種安全的隱式轉換呢?然後看下面這種寫法:
Sharp[] sharps=new Rectange[3];
編譯通過,這說明Rectange[]和Sharp[]之間存在安全的隱式轉換。
像這種與原始型別轉換方向相同的可變性就稱作協變(covariant)
接下來試試這樣寫:
Rectange[] rectanges = new Sharp[3];
發現編譯不通過,即陣列所對應的單一元素的父類引用不可以安全的轉化為子類引用。陣列也就自然不能依賴這種可變性,達到協變的目的。 Sharp sharp = new Rectange();
但是卻不能這麼寫:
4.0之後,可以允許按上面的寫法了,因為泛型介面IEnumerable<T>被宣告成如下:IEnumerable<Sharp> sharps = new List<Rectange>();
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);
以上,協變和抗變記錄到此。