協變

協變概念令人費解，多半是取名或者翻譯的鍋，其實是很容易理解的。

比如大街上有一只狗，我說大家快看，這有一只動物！這個非常自然，雖然動物并不嚴格等于狗，但不會有人覺得我說的不對，把狗變成動物就是協變，C#也支持這個：

// C#6頂級語句
Dog dog= new Dog();
Animal animal= dog;

interface Animal
{}

class Dog : Animal
{}

那么接下來，大街上有一群狗，我說有一群動物，按理說也是對的，但看樣子C#不這么認為

List<Dog> dogLst = new List<Dog>();
List<Animal> aniLst = dogLst;       //飆紅飆紅飆紅了
interface Animal {}
class Dog : Animal {}

原因其實很容易理解，畢竟在上述的代碼中，寫了Dog:Animal，即聲明了狗是動物的子類，但是并沒有寫List<Animal> : List<Dog>，換言之，從來沒有聲明過一群狗是一群動物的子類。

但是，如果不用List，而用其父類IEnumerable，寫成下面這樣，就又不報錯了。

List<Dog> dogLst = new List<Dog>();
IEnumerable<Animal> aniLst = dogLst;

換言之，C#承認List<Dog>是IEnumerable<Animal>的子類，個中差別，只需一覽源碼，就會知曉：

public interface IEnumerable<out T> : IEnumerable
public class List<T> : ..., IEnumerable<T>, ...

IEnumerable無非比List多了一個out參數，有了這個參數，就擁有了協變的功能，從而當U是T的子類時，可以支持IEnumerable<U>到IEnumerable<T>的轉換。

在官方文檔中，指明了具有out關鍵字的泛型接口包括IEnumerable<T>, IEnumerator<T>, IQueryable<T>和IGrouping<TKey,TElement>。

協變接口的實現

協變和逆變目前只能在泛型接口和委托中使用，下面新建一個泛型接口，并使用關鍵字out。由于使用.Net6.0的頂級語句，所以接口和類的聲明放在后面。

IOut<string> outStr = new Out();
IOut<object> outObj = outStr;
Console.WriteLine(outObj.getName());

interface IOut<out T>
{
    T getName();
}

class Out : IOut<string>
{
    public string getName()
    {
        return GetType().Name;
    }
}

編譯運行，最后輸出Out，即outObj盡管在聲明的時候用的是IOut<object>，但在IOut的out修飾符的作用下，成功讓IOut<object>變成了IOut<string>的父類，得以順利調用Out中的方法。

那么接下來，如果想讓getName更加完備一些，例如要求實現getName(T name)這樣的功能，那么經out修飾的協變接口就無能為力了，像下面這樣的寫法果然被無情地飆紅了

interface IOut<out T>
{
    void getName(T name);
}

逆變

VS作為宇宙頂級IDE，協變逆變十分拎得清，上述代碼在飆紅的同時，直接給出如下錯誤

變型無效: 類型參數“T”必須是在“IOut.getName(T)”上有效的 逆變式。“T”為 協變。

換言之，如果想讓泛型接口可以輸入泛型參數，那么需要用到逆變，具體寫法如下，其中修飾符in表示逆變

IIn<object> inObj = new In();
IIn<string> inStr = inObj;
inStr.getName("in");

interface IIn<in T>
{
    void getName(T name);
}

class In : IIn<object>
{
    public void getName(object name)
    {
        Console.WriteLine(name);
    }
}

逆變和協變最大的不同，并非in和out這兩個修飾符的字數，而是整個替換邏輯發生了變化，上述代碼中，實際上是作為子類的string調用了通過父類object作為參數定義的函數。

里氏替換原則

在具體實現了協變與逆變之后，總覺得那里怪怪的，最怪的其實還是下面這行代碼的錯誤

//錯錯錯錯錯錯錯錯錯錯錯錯錯錯錯錯錯錯錯錯錯錯錯錯錯錯
interface IOut<out T>
{
    void getName(T name);
}

而且可以想象，與之相對應的下面的逆變代碼也是不對的

//錯錯錯錯錯錯錯錯錯錯錯錯錯錯錯錯錯錯錯錯錯錯錯錯錯錯
interface IOut<in T>
{
    T getName();
}

接下來復盤一下產生這種現象的原因，為了破除命名帶來的困擾，接下來考慮泛型接口I<T>，其中有一個函數T test(T t)?，F有兩個特定的繼承自泛型接口I<A>和I<B>的類，假設I<A>要調用I<B>中的方法，那么其流程如下

1.A I<A>.test(A t)，即輸入一個A類型的參數

2.將這個A類型的參數t，傳入到B I<B>.test(B t)。由于I<B>要求輸入B類型的參數，所以要求A可以轉換為B類型。

3.B I<B>.test(B t)計算完畢，返回一個B類型的參數

4.這個B類型的參數又被返回給最初的調用者A I<A>.test，而這時I<A>的函數最終將返回一個A類型的參數，換言之，在這個步驟，要求B可以轉換為A。

A能轉為B，然后還得B能轉為A，同時A和B還不相等，這顯然是不可能的。

所以逆變和協變分別實現了第2步和第4步。

如果I<A>想要調用I<B>test(B t)中的函數，那么A類型必須可以轉成B類型。正如string可以轉為object一樣，此即逆變，用in修飾，其作用場合為子類調用父類中的方法。

如果I<A>想要調用B I<B>test()，那么作為返回值的B類型必須可以轉化為A類型，此即協變，用out修飾，正是父類調用子類的方法。

協變和逆變的統一之處在于，二者都嚴格遵循這子類可以轉變為父類的規則，此即里氏替換。這是1987年，芭芭拉·利斯科夫提出的，她也是2008年圖靈獎得主。

在協變逆變的過程中，對里氏替換的遵循主要表現在當子類方法重載父類方法時

• 方法的輸入參數要更加寬松，此即逆變(IOut<object>調用IOut<string>，object比string更寬松)
• 方法的返回值要更加嚴格，此即協變(IOut<string>調用IOut<object>，string比object更嚴格)