C#逆变和协变的理解-----为什么逆变可以把Object类型的类型参数转换成String类型的类型参数

根据可变性的规则，只有接口和委托可以标记可变性。且只有类型参数为引用类型时才可以利用可变性。

不变性：泛型类型的参数不能改变，这表示一个创建一个MyInterface<String>类型的对象时，赋值给它的只能是MyInterface<String>类型

namespace ContravariantAndCovariant
{
    public interface MyInterface<T>//没有指定任何可变性，说明这个接口的类型参数是不变的
    {
        void Show(T t);
    }

    public class ShowObject : MyInterface<Object>
    {
        public void Show(object t)
        {
            Console.WriteLine(t.ToString());
        }
    }

    public class ShowString : MyInterface<String>
    {
        public void Show(string t)
        {
            Console.WriteLine(t);
        }
    }

    public class ShowInt : MyInterface<Int32>
    {
        public void Show(int t)
        {
            Console.WriteLine(t.ToString());
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            //正确
            MyInterface<String> str_invariant = new ShowString();//只能赋值MyInterface<String>类型
            //错误
            MyInterface<String> str_contravariant = new ShowObject();//当赋值其它类型的时候，编译器会报错
            //CS0266    无法将类型“ContravariantAndCovariant.ShowObject”隐式转换为“ContravariantAndCovariant.MyInterface<string>”。存在一个显式转换(是否缺少强制转换?)    

        }
    }

}

逆变性：泛型的类型参数可以从一个类变成它的派生类，比如：可以把MyInterface<object>转换成MyInterface<string>。逆变用in表示，因为它出现在输入的位置（方法的参数），in 就是进去的意思。

namespace ContravariantAndCovariant
{
    public interface MyInterface<in T>//用in关键字指定T的逆变性
    {
        void Show(T t);//T是参数类型
    }

    public class ShowObject : MyInterface<Object>
    {
        public void Show(object t)
        {
            Console.WriteLine(t.ToString());
        }
    }

    public class ShowString : MyInterface<String>
    {
        public void Show(string t)
        {
            Console.WriteLine(t);
        }
    }

    public class ShowInt : MyInterface<Int32>
    {
        public void Show(int t)
        {
            Console.WriteLine(t.ToString());
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            MyInterface<object> obj = null;
            MyInterface<string> str = obj;//可以把MyInterface<object>类型转换为MyInterface<string>类型
        }
    }

}

协变性：泛型的类型参数可以从一个类变成它的基类，比如：可以把MyInterface<string>转换成MyInterface<object>。逆变用out表示，因为它出现在输出的位置（方法返回值），out 就是出的意思。

namespace ContravariantAndCovariant
{
    public interface MyInterface<out T>//用out关键字指定T的协变性
    {
        T Show(); //T是返回类型
    }

    public class ShowObject : MyInterface<Object>
    {
        public object Show()
        {
            return null;
        }
    }

    public class ShowString : MyInterface<String>
    {
        public string Show()
        {
            return null;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            //错误
            //MyInterface<object> obj = null;
            //MyInterface<string> str = obj;//不能把MyInterface<object>类型转换为MyInterface<string>类型

            //正确
            MyInterface<string> str = null;
            MyInterface<object> obj = str;//可以把MyInterface<string>类型转换成MyInterface<Object>类型
        }
    }
}

CLR是要保证类型的转换是安全的，协变性还好理解，子类是可以转换成父类的，因为子类对象中包括父类对象的所有成员。这个转换是安全的。

但是逆变的话，父类转换成子类是不安全的，当不能里氏转换的时候，父类对象中并没有子类的所有成员。

其实这么看的话是有一个误区，就是关于引用和对象。当逆变的时候，比如上面逆变的代码中:

MyInterface<object> obj = null;

MyInterface<string> str = obj;

str.Show("123")

str是MyInterface<string>类型的变量，但是它引用的对象是MyInterface<Object>类型的，所以当我们调用Show()方法的时候，其实是obj.Show();

obj的参数是object类型的，我们传入的是一个string类型，string---->object的转换是安全的。所以逆变是安全的！

同理的话，协变：

MyInterface<string> str = null;

Myinterface<object> obj = str;

 object  result = obj.show();

可以看到obj是MyInterface<object>类型的变量，但是它引用的对象是MyInterface<string>类型，所以当我们调用Show()方法的时候，其实是str.Show(),

它返回的是string类型，但是obj.Show()返回的是一个object类型，所以我们用一个object类型的变量result去接收返回值，最终变成 string ----->object类型的转换，所以协变是安全的。