本節內容為泛型

為什麼需要泛型

泛型是一個非常有趣的東西，他的出現對於減少程式碼複用率有了很大的幫助。比如說遇到兩個模組的功能非常相似，只是一個是處理int資料，另一個是處理string資料，或者其他自定義的資料型別，但我們沒有辦法，只能分別寫多個方法處理每個資料型別，因為方法的引數型別不同。有沒有一種辦法，在方法中傳入通用的資料型別，這樣不就可以合併程式碼了嗎？

泛型簡介

在我們的C#中，使用泛型對允許您延遲編寫類或方法中的程式設計元素的資料型別的規範，直到實際在程式中使用它的時候。換句話說，泛型允許您編寫一個可以與任何資料型別一起工作的類或方法。泛型的定義非常簡單，在類或函式名後使用作為佔位符即可，這個T也可以換成其他的字母代替。

注意：屬性和索引器不能指定自己的泛型引數，它們只能使用所屬類中定義的泛型引數進行操作。

你可以通過下面這個例子得到一些關於泛型定義的方法。
值得注意的是泛型是在執行時進行動態變化，並不是在編譯時發生。

泛型類與泛型函式

泛型類和泛型函式在使用上基本上是一樣的，只不過定義後的範圍不一樣。對於泛型類，泛型的範圍是整個類，泛型函式則是在函式內部。

例如這個例子

class A<T>
{
    public T getSomething<X>(X m,T n)
    {
        return n;
    }
    public static U test<U>(U x)
    {
        return x;
    }
}
// 例項泛型類必須指定型別
A<string> a = new A<string>()
//泛型推斷
A.test<int>(1);//原式
A.test(1);//推斷
 

在泛型函式的呼叫中，有一個語法糖，它就是泛型型別推斷。這非常好理解,C#的編譯器足夠聰明，它可以根據你傳入的引數型別，呼叫gettype方法進行型別的推斷。因此你可以在泛型函式中不顯式的指定型別。
型別推理的相同規則適用於靜態方法和例項方法。 編譯器可基於傳入的方法引數推斷型別引數；而無法僅根據約束或返回值推斷型別引數。 因此，型別推理不適用於不具有引數的方法。 型別推理髮生在編譯時，之後編譯器嘗試解析過載的方法簽名。 編譯器將型別推理邏輯應用於共用同一名稱的所有泛型方法。 在過載解決方案步驟中，編譯器僅包含在其上型別推理成功的泛型方法。

泛型的範圍則是包含關係。包含在泛型類中的泛型函式可以自由的訪問泛型類中的泛型，但是類不可以訪問泛型函式中指定的泛型。

泛型約束

如果我們使用了泛型，那麼必定面臨的一個問題就是許可權問題。例如class A，假定我希望某些型別不可以作為泛型傳入，那麼我們就應當使用我們的泛型約束。
泛型約束的使用如下例：

class A : T where T:class
{
    
}

泛型約束通常有下面幾類：

• where T : struct：型別引數必須是值型別。可以指定除 Nullable 以外的任何值型別。
• where T : class 型別引數必須是引用型別。 此約束還應用於任何類、介面、委託或陣列型別。
• where T : unmanaged 型別引數不能是引用型別，並且任何巢狀級別均不能包含任何引用型別成員。
• where T : new() 型別引數必須具有公共無引數建構函式。 與其他約束一起使用時，new() 約束必須最後指定。
• where T : <基類名> 型別引數必須是指定的基類或派生自指定的基類。
• where T : <介面名稱> 型別引數必須是指定的介面或實現指定的介面。 可指定多個介面約束。 約束介面也可以是泛型。
• where T : U 為 T 提供的型別引數必須是為 U 提供的引數或派生自為 U 提供的引數。

某些約束是互斥的。 所有值型別必須具有可訪問的無引數建構函式。 struct 約束包含 new() 約束，且 new() 約束不能與 struct 約束結合使用。 unmanaged 約束包含 struct 約束。 unmanaged 約束不能與 struct 或 new() 約束結合使用。使用的時候稍加註意即可。

你也可以指定多個型別佔位符，並且單獨為他們進行約束，如：

class A<T,U> 
        where T:struct
        where U:class

甚至你可以進行泛型自我約束，例如：

class A<T,U,K> 
        where T:struct
        where U:K

協變和逆變

這三個名詞來自於數學和物理，很多初學者都難以理解這些名詞。但事實上在C#上，這些詞是用於標示型別與型別之間的繫結。可變性是以一種型別安全的方式，將一個物件當做另一個物件來使用。如果不能將一個型別替換為另一個型別，那麼這個型別就稱之為：不變。

協變

如果某個返回的型別可以由其派生型別替換，那麼這個型別就是支援協變的。直白的說，協變就是合理的變化，例如貓->動物，這個看上去絲毫沒有問題。這就是協變，從小變大。

例如：

// Cat:Animal
//這種變化毫無問題
Cat c = new Cat();
Animal a = c;
//報錯，因為List<Cat>不繼承於List<Animal>
List<Cat> d = new List<Cat>();
List<Animal> = d;

對於泛型的引數，我們可以使用到我們之前講函式引數的時候所遇到的 in，out 關鍵字。In代表輸入，體現的就是逆變，Out代表輸出，代表的是協變。對於Out輸出的東西，自然不可以對他進行輸入操作，他只能作為結果返回，因此它不會被修改。因此進行隱式轉換的時候，編譯器認為該轉換是安全的（返回值不變）。

例如

IEnumerable<Cat> c = new List<Cat>();

IEnumerable<Animal> a = c;

很多人可能不不能很好地理解這些來自於物理和數學的名詞。我們無需去了解他們的數學定義，但是至少應該能分清協變和逆變。實際上這個詞來源於型別和型別之間的繫結。我們從陣列開始理解。陣列其實就是一種和具體型別之間發生繫結的型別。陣列型別Int32[]就對應於Int32這個原本的型別。任何型別T都有其對應的陣列型別T[]。那麼我們的問題就來了，如果兩個型別T和U之間存在一種安全的隱式轉換，那麼對應的陣列型別T[]和U[]之間是否也存在這種轉換呢？這就牽扯到了將原本型別上存在的型別轉換對映到他們的陣列型別上的能力，這種能力就稱為“可變性（Variance）”。在.NET世界中，唯一允許可變性的型別轉換就是由繼承關係帶來的“子類引用->父類引用”轉換。舉個例子，就是String型別繼承自Object型別，所以任何String的引用都可以安全地轉換為Object引用。我們發現String[]陣列型別的引用也繼承了這種轉換能力，它可以轉換成Object[]陣列型別的引用，陣列這種與原始型別轉換方向相同的可變性就稱作協變

逆變

逆變則恰恰與協變完全相反，逆變是指代型別往更小的派生類中進行轉換，顯然這有可能是不安全的，因為有可能會導致資料的丟失。在C#中使用逆變式的方法是使用In關鍵字，這意味著這個引數只能作為返回值返回，那麼我們就有可能對傳入的引數進行修改，因此使用強制轉換有可能是不合法的。
例如：

public interface IMyList<in T>
{
    T GetElement();
    void ChangeT(T t);
}

public class MyList<T> : IMyList<T>
{
    public T GetElement()
    {
        return default(T);
    }
    public void ChangeT(T t)
    {
        //Change T
    }
}

這段程式碼無法通過編譯，因為GetElement是將T返回，這顯然不符合逆變的定義。逆變的引數只允許輸入而不允許輸出。

對於逆變的實踐，各位可以去參閱下IList介面與IEnumerable介面的實現。這兩個介面很好的體現了在集合中的逆變與協變。

總結

對於泛型，並沒有太多的奇技淫巧可言，因為泛型的出現已經就是一個奇技淫巧了。泛型最常用的地方是泛型陣列。並且C#對於不確定型別和大小的陣列會使用一個非常好用的類，叫做List類，我們將會在中級篇中進行詳細的介紹。