C# 逆變與協變

該文章中使用了較多的 委托delegate和Lambda表達式，如果你並不熟悉這些，請查看我的文章《委托與匿名委托》、《匿名委托與Lambda表達式》以便幫你建立完整的知識體系。

在C#從誕生到發展壯大的過程中，新知識點不斷引入。逆變與協變並不是C#獨創的，屬於后續引入。在Java中同樣存在逆變與協變，后續我還會寫一篇Java逆變協變的文章，有興趣的朋友可以關注一下。

逆變與協變，聽起來很抽象、高深，其實很簡單。看下面的代碼：

class Person
    {

    }
    class Student : Person
    {

    }
    class Teacher: Person
    {

    }
    
    class Program
    {
        static void Main(string[] args)
        {
            List<Person> plist = new List<Person>();
            plist = new List<Student>();
            plist = new List<Teacher>();
}
}

在上面的代碼中，plist = new List<Student>()、plist = new List<Teacher>()兩句產生編譯錯誤。雖然Person是Student/Teacher的父類，但List<Person>類型卻不是List<Student/Teacher>類型的父類，所以上面的賦值語句報類型轉換失敗錯誤。

如上這樣的賦值操作，在C# 4.0之前是不允許的，至於為什么不允許，類型安全是首要因素。看下面的示例代碼：

List<Person> plist = new List<Student>();
plist.Add(new Person());
plist.Add(new Student());
plist.Add(new Teacher());

如下示例，假設 List<Person> plist = new List<Student>() 允許賦值，那plist雖然類型為List<Person>集合，但實際指向確是List<Student>集合。plist.Add(new Person())，添加操作實際調用的是List<Student>.Add()。Person類型無法安全轉換為Student，所以這樣的集合定義沒有意義，所以上面的假設不成立。

但情況在C# 4.0之后發生了變化，並不是"不可能發生的事情發生了"，而是應用的靈活性做出了新的調整。同樣的在C# 4.0中上面的程序仍是不被允許的，但卻出現了例外。從C# 4.0開始，在泛型委托、泛型接口中，允許特殊情況的發生（實質上並未發生特殊變化，后面說明）。如下示例：

 

delegate void Work<T>(T item);

class Person
{
        public string Name { get; set; }
}
class Student : Person
{
        public string Like { get; set; }
}
class Teacher : Person
{
        public string Teach { get; set; }
}

class Program
{
        static void Main(string[] args)
        {
            Work<Person> worker = (p) => { Console.WriteLine(p.Name); }; ;
            Work<Student> student_worker = (s) => { Console.WriteLine(s.Like); };
            student_worker = worker; //此處編譯錯誤
        }
}

 

根據前面的理論支持，student_worker = worker;的錯誤很容易理解。但此處我們程序的目的是讓 woker  充當 Work<Student> 的功能，以后調用 student_worker(s)實際調用的是woker(s)。為了滿足我們的需求，需要程序做2方面的處理：

1、因在調用student_worker(s)時，實質執行的是woker(s)，所以需要s變量的類型能成功轉換為woker需要的參數類型。

2、需要告訴編譯器，此處允許將 Work<Person> 類型的對象賦值給 Work<Student>類型的變量。

 

條件1在調用時student_worker()，時編譯器會提示要求參數必須是Student類型對象，該對象可成功轉換為Person類型對象。

條件2則需要對Woke委托定義進行調整，調整如下：

delegate void WorkIn<in T>(T item);

委托名字改為WorkIn是為卻別修改前后的委托，關鍵之處為<in T>。通過增加 in 關鍵字，標注該泛型委托的類型參數T，僅作為委托方法的參數來使用。此時上面的程序便可成功編譯並執行。

delegate void WorkIn<in T>(T item);
class Program
    {
        static void Main(string[] args)
        {
            WorkIn<Person> woker = (p) => { Console.WriteLine(p.Name); };
            WorkIn<Student> student_worker = woker;
            student_worker(new Student() { Name="tom", Like="C#" });

        }
    }

對於要求類型參數為子類型，允許賦值類型參數為父類型值的這種情況，稱為逆變。逆變在C#中需要用 in 標注泛型的類型參數。逆變雖叫逆變，但只是形式上看似父類對象賦值給子類變量，實質上是方法調用時參數的類型轉換。Student s = new Person()，這是不可能的，這不是逆變是錯誤。

上面的代碼如你能轉換為下面的形式，那你就可以忘卻逆變，本質比現象更重要😀：

delegate void WorkIn<in T>(T item);
 class Program
    {
        static void Main(string[] args)
        {
            WorkIn<Person> woker = (p) => { Console.WriteLine(p.Name); };
            WorkIn<Student> student_worker = (s)=> { woker(s); };
            student_worker(new Student() { Name="tom", Like="C#" });
        }
    }

協變

 現在修改我們的程序需求，要求Work委托執行后返回一個Person對象，如下：

    delegate T Work<T>();   
    class Program
    {
        static void Main(string[] args)
        {
            Work<Person> worker = () => { return new Person(); };
            Work<Student> student_worker = () => { return new Student(); };

            worker = student_worker;
        }
    }

同上 worker = student_worker 無法通過編譯，此時我們的目的為：用 Work<Student>  student_woker 的功能替代 Work<Person> 的功能，因為 student_woker 執行后返回一個Student對象，這完全符合 Work<Person> 的要求。

如果要實現上面的目的，程序同樣需做2方面的處理：

1、因在調用 worker()時，實質執行的是 student_worker()，所以需要 student_worker() 執行結果能功轉換為woker 執行后返回的類型。

2、需要告訴編譯器，此處允許將 Work<Student>類型的對象賦值給 Work<Person> 類型的變量。

此時條件1，上述代碼已經滿足，對於條件2，需要泛型委托Work做如下調整：

delegate T WorkOut<out T>();

委托名字改為WorkOut也為卻別修改前后的委托，關鍵之處為<out T>。通過增加 out 關鍵字，標注該泛型委托的類型參數T，僅作為委托方法的返回值類型來使用。此時上面的程序便可成功編譯並執行。

delegate T WorkOut<out T>();
class Program
    {
        static void Main(string[] args)
        {
            WorkOut<Person> worker = () => { return new Person(); };
            WorkOut<Student> student_worker = () => { return new Student(); };

            worker = student_worker;
            Person p = worker();
        }
    }

對於要求泛型類型參數為父類型，允許賦值類型參數為子類型值的這種情況，稱為協變。協變在C#中需要用 out 標注泛型的類型參數。

注意：逆變、協變類型說明的區別。根據引出的定義逆變的形式只可能發生在泛型上（泛型接口、泛型委托），而協變的代碼形式就比較多，但並不一定是協變。所以在協變中用紅色注明，必須是關於泛型參數的情況才是協變。下面這類情況不屬於協變（至少我不認為它們是協變）：

Person p = new Student();

上面的示例代碼如你能轉換為下面的形式，那你也可以忘卻協變😀：

delegate T WorkOut<out T>();
class Program
    {
        static void Main(string[] args)
        {
           
            WorkOut<Student> student_worker = () => { return new Student(); };
            WorkOut<Person> worker = () => { return student_worker (); };
            Person p = worker();
        }
    }

 

通過上面的內容可以發現，逆變、協變其實是方法參數、返回值類型的轉換與對委托方法的包裝而已。抓住其核心，再看各種形式的代碼就簡單了。

在C# 4.0 中 你可以查看 Action，Func的定義，以便更深入理解逆變、協變。