.net学习笔记之协变和抗变(原创)

对于协变和抗变的这两个词的定义，是初次接触；然而实际应用应该是从用c#语言编写代码开始的。

这两个词的理解过程非常绕，查看很多资料，再加上敲代码调试之后才逐渐有点理解它们的含义。

所谓的协变，可以理解成：父类 -> 子类。父类的对象用子类替换，也可以理解成子类当父类用。

所谓的抗变，可以理解成：子类 -> 父类。子类的对象用父类替换，也可以理解成父类当子类用。抗变也常常翻译为逆变。

在c#的语言中，很多地方的调用已经隐藏了协变和抗变的使用。函数的返回类型默认是抗变的。例如，函数Func的返回类型为string，我们可以将返回的值赋给object对象。

private void button2_Click(object sender, EventArgs e)
{
    //注意这里：Func的返回类型为string, obj的类型为object, string类型继承自object
    object obj = Func();
}

string Func()
{
    return "这里有协变的应用";
}

函数的参数类型则默认是协变的。例如，函数Act的输入参数为object类型，实际操作中我们可以将string类型的对象传给函数。

private void button2_Click(object sender, EventArgs e)
{
    string str = "这是一个string类型的实例, 函数Act的参数为object, 这里有抗变的应用";
    Act(str);
}

void Act(object obj)
{
    return ;
}

再看下面的代码，两者一起应用。

private void button2_Click(object sender, EventArgs e)
{
    string str = "这是一个string类型的实例";
    object obj = null;
    obj = Both(str);
}

string Both(object obj)
{
    return "协变和抗变两者都有";
}

是不是觉得非常熟悉，常常用到？所以本篇开头我说可能从开始用C#编写代码的时候就开始接触了。

• 接下来说说我对《c#高级编程》中的泛型接口的协变和抗变的理解。

上面提到了，c#的语法中已经定义了一些协变和抗变的应用。在泛型接口的定义中，如果泛型类型T用out关键词标注，这个泛型接口就是协变的。而且在接口的代码里面，T只能用作返回类型，不能用作参数类型。

如果泛型类型T用in关键词标注的话，这个接口就是抗变的。在接口的代码里面，T只能用作函数的参数类型，而不能用作返回类型。

留文备用。如果理解有误，请在下面勘正。

补充一篇转载：

转载自：http://www.cnblogs.com/tenghoo/archive/2012/12/04/interface_covariant_contravariant.html

 

1、什么是协变、逆变？

假设：TSub是TParent的子类。
协变：如果一个泛型接口IFoo<T>，IFoo<TSub>可以转换为IFoo<TParent>的话，我们称这个过程为协变，IFoo支持对参数T的协变。
逆变：如果一个泛型接口IFoo<T>，IFoo<TParent>可以转换为IFoo<TSub>的话，我们称这个过程为逆变，IFoo支持对参数T的逆变。

2、为什么要有协变、逆变?

通常只有具备继承关系的对象才可以发生隐式类型转换，如Base b=new sub()。
协变和逆变可以使得更多的类型之间能够实现隐式类型转换、类型安全性有了保障。

3、为什么泛型接口要引入协变、逆变？

基于以上原因的同时、许多接口仅仅将类型参数用于参数或返回值。所以支持协变和逆变后泛型的使用上有了更大的灵活性

4、为什么支持协变的参数只能用于方法的返回值？支持逆变的参数只能用于方法参数？

“TParent不能安全转换成TSub”，是这两个问题的共同原因。
我们定义一个接口IFoo。
 

    interface IFoo<T>
    {
        void Method1(T param);
        T Method2();
    }

我们看一下协变的过程：IFoo<TSub>转换成IFoo<TParent>。

Method1：将TSub替换成TParent，Method1显然存在 TParent到TSub的转换。

Method2：返回值类型从TSub换成了TParent，是类型安全的。

所以支持协变的参数只能用在方法的返回值中。

再看一下逆变的过程：IFoo<TParent>转换成IFoo<TSub>。

Method1：将TParent替换成TSub，Method1存在 TSub到TParent的转换，是类型安全的。

Method2：返回值类型从TParent换成了TSub，是不安全的。

所以支持逆变的参数只能用在方法的参数中。

5、泛型接口支持协变、逆变和不支持协变、逆变的对比？

这其实是对3个问题的补充。

定义一个接口IFoo，既不支持协变，也不支持逆变。

    interface IFoo<T>
    {
        void Method1(T param);
        T Method2();
    }

实现接口IFoo

    public class FooClass<T> : IFoo<T>
    {
        public void Method1(T param)
        {
            Console.WriteLine(default(T));
        }
        public T Method2()
        {
            return default(T);
        }
    }

定义一个接口IBar支持对参数T的协变

    interface IBar<out T>
    {
        T Method();
    }

实现接口IBar

    public class BarClass<T> : IBar<T>
    {
        public T Method()
        {
            return default(T);
        }
    }

 定义一个接口IBaz支持对参数T的逆变

    interface IBaz<in T>
    {
        void Method(T param);
    }

实现接口IBaz

    public class BazClass<T> : IBaz<T>
    {
        public void Method(T param)
        {
            Console.WriteLine(param.ToString());
        }
    }

定义两个有继承关系的类型，IParent和SubClass。

    interface IParent
    {
        void DoSomething();
    }
    public class SubClass : IParent
    {
        public void DoSomething()
        {
            Console.WriteLine("SubMethod");
        }
    }

按照协变的逻辑，分别来使用IFoo和IBar。

            //IFoo 不支持对参数T的协变
            IFoo<SubClass> foo_sub = new FooClass<SubClass>();
            IFoo<IParent> foo_parent = foo_sub;//编译错误

            //IBar 支持对参数T的协变
            IBar<SubClass> bar_sub = new BarClass<SubClass>();
            IBar<IParent> bar_parent = bar_sub;

foo_parent = foo_sub 会提示编译时错误“无法将类型“IFoo<SubClass>”隐式转换为“IFoo<IParent>”。存在一个显式转换(是否缺少强制转换?)”

按照逆变的逻辑，分别来使用IFoo和IBaz。

            //IFoo 对参数T逆变不相容
            IFoo<IParent> foo_parent = null;
            IFoo<SubClass> foo_sub = foo_parent;//编译错误

            //IBaz 对参数T逆变相容
            IBaz<IParent> baz_parent = null;
            IBaz<SubClass> baz_sub = baz_parent;

 foo_sub = foo_parent 会提示编译时错误“无法将类型“IFoo<IParent>”隐式转换为“IFoo<ISub>”。存在一个显式转换(是否缺少强制转换?)”

6、.NET4.0对IEnumerable接口的修改？

2.0中的定义：

    public interface IEnumerable<T> : IEnumerable
    {
        IEnumerator<T> GetEnumerator();
    }

4.0中的定义：

    public interface IEnumerable<out T> : IEnumerable
    {
        IEnumerator<T> GetEnumerator();
    }

可以看到4.0中增加了对协变的支持。

可以在两个版本试下， 下面的语句在2.0下会报错。

    List<SubClass> subarr = new List<SubClass>();
    IEnumerable<IParent> parentarr = subarr;