C#中的协变、逆变

一、概述

1、在 C# 中，协变和逆变能够实现数组类型、委托类型和泛型类型参数的隐式引用转换。

2、按字面，可以这样理解：协变，感觉协和地隐式引用转换；逆变，逆反直觉地隐式引用转换。

二、泛型中的协变和逆变

1、定义

（1）协变，使你能够使用比原始指定的类型派生程度更大的类型。你可以将 IEnumerable<Derived> 的实例分配给 IEnumerable<Base> 类型的变量。

（2）逆变，使你能够使用比原始指定的类型更泛型的类型（派生程度更小的类型）。你可以将 Action<Base> 的实例分配给 Action<Derived> 类型的变量。

（3）不变性，表示只能使用最初指定的类型。固定泛型类型参数既不是协变，也不是逆变。你无法将 List<Base> 的实例分配给 List<Derived> 类型的变量，反之亦然。

2、具有协变类型参数的泛型接口

（1）关键字 out

（2）在接口方法中，只能作为方法的返回类型

public interface IEnumerator<out T> : IEnumerator, IDisposable
{
    T Current { get; }
}

3、具有逆变类型参数的泛型接口

（1）关键字 in

（2）在接口方法中，只能作为方法的参数类型

public interface IComparer<in T>
{
    int Compare(T? x, T? y);
}

4、代码示例

（1）协变

internal partial class Program
{
    private static void ToTest5()
    {
        ITest1<string> implementStr = new ImplementStr();
        object result1 = implementStr.Foo();
        Console.WriteLine(result1);

        ITest1<object> implementObj = implementStr;
        object result2 = implementObj.Foo();
        Console.WriteLine(result2);
    }
}

public interface ITest1<out T>
{
    T Foo();
}

public partial class ImplementStr : ITest1<string>
{
    public string Foo()
    {
        return " foo";
    }
}

public partial class ImplementObj : ITest1<object>
{
    public object Foo()
    {
        return 1;
    }
}

View Code

运行结果：

（2）逆变

internal partial class Program
{
    private static void ToTest6()
    {
        ITest2<object> implementObj = new ImplementObj();
        implementObj.Bar("bar1");

        ITest2<string> implementStr = implementObj;
        implementStr.Bar("bar2");
    }
}

public interface ITest2<in T>
{
    void Bar(T parameter);
}

public partial class ImplementStr : ITest2<string>
{
    public void Bar(string parameter)
    {
        Console.WriteLine($" string parameter：{parameter}");
    }
}

public partial class ImplementObj : ITest2<object>
{
    public void Bar(object parameter)
    {
        Console.WriteLine($" object parameter：{parameter}");
    }
}