网站首页 > 基础教程 正文
C#4.0 协变 和 抗变（逆变）
关于协变和逆变要从面向对象继承说起。继承关系是指子类和父类之间的关系；子类从父类继承所以子类的实例也就是父类的实例。比如说Animal是父类，Dog是从Animal继承的子类；如果一个对象的类型是Dog，那么他必然是Animal。协变逆变正是利用继承关系 对不同参数类型或返回值类型 的委托或者泛型接口之间做转变。
如果一个方法要接受Dog参数，那么另一个接受Animal参数的方法肯定也可以接受这个方法的参数，这是Animal向Dog方向的转变是逆变。如果一个方法要求的返回值是Animal，那么返回Dog的方法肯定是可以满足其返回值要求的，这是Dog向Animal方向的转变是协变。
由子类向父类方向转变是协变 协变用于返回值类型用out关键字由父类向子类方向转变是逆变 逆变用于方法的参数类型用in关键字
一、定义
一个可变性和子类到父类转换的方向一样，就称作协变；而如果和子类到父类的转换方向相反，就叫抗变！
那到底这个协变或者抗变有什么实际利用价值呢？其价值就在于，在.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> // Covariant 协变的并且让上面的两个类各自继承一下该接口：
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);四、C#中的范型接口与泛型委托
interface IEnumerable<out T> : IEnumerable
{
IEnumerator<T> GetEnumerator();
}
public interface IEnumerator<out T> : IEnumerator, IDisposable
{
T Current
{
get;
}
}
public interface IQueryable<out T> : IEnumerable<T>, IEnumerable, IQueryable
{
}
public interface IQueryable : IEnumerable
{
//
// Properties
//
Type ElementType
{
get;
}
Expression Expression
{
get;
}
IQueryProvider Provider
{
get;
}
}
public interface IGrouping<out TKey, out TElement> : IEnumerable<TElement>, IEnumerable
{
TKey Key
{
get;
}
}
public interface IComparer<in T>
{
int Compare(T x, T y);
}
public interface IEqualityComparer<in T>
{
bool Equals(T x, T y);
int GetHashCode(T obj);
}
public interface IComparable<in T>
{
int CompareTo(T other);
}C#中的范型委托
public delegate void Action<in T>(T obj);
public delegate TResult Func<in T, out TResult>(T arg);
public delegate bool Predicate<in T>(T obj);
public delegate int Comparison<in T>(T x, T y);
public delegate TOutput Converter<in TInput, out TOutput>(TInput input);- 上一篇： 学习笔记之C#基础——字符与字符串
- 下一篇： 非常实用!8个Word图片处理技巧
猜你喜欢
- 2024-12-02 C++中的struct完全可以被class替代，为什么不删去它呢?
- 2024-12-02 C#笔记~泛型
- 2024-12-02 C# 中 IsNullOrEmpty 和 IsNullOrWhiteSpace 你用对了吗?
- 2024-12-02 C#面试宝典 2022年 60个常见的C#面试问题和答案
- 2024-12-02 C#学习随笔—操作BIN文件(读，写，替代)
- 2024-12-02 C# 入门深度学习:万字长文讲解微积分和梯度下降
- 2024-12-02 344.C# 中的正则表达式:字符匹配、字面字符、特殊字符和转义序列
- 2024-12-02 C#通过二进制读写实现文件的伪加密
- 2024-12-02 C#移除字符串中的不可见Unicode字符
- 2024-12-02 使用 C# 解析月份简写的时间日期格式
- 最近发表
- 标签列表
-
- gitpush (61)
- pythonif (68)
- location.href (57)
- tail-f (57)
- pythonifelse (59)
- deletesql (62)
- c++模板 (62)
- css3动画 (57)
- c#event (59)
- linuxgzip (68)
- 字符串连接 (73)
- nginx配置文件详解 (61)
- html标签 (69)
- c++初始化列表 (64)
- exec命令 (59)
- canvasfilltext (58)
- mysqlinnodbmyisam区别 (63)
- arraylistadd (66)
- node教程 (59)
- console.table (62)
- c++time_t (58)
- phpcookie (58)
- mysqldatesub函数 (63)
- window10java环境变量设置 (66)
- c++虚函数和纯虚函数的区别 (66)