/// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="tParameter"></param>
        public static void Show<T>(T tParameter) where T : People
        {
            Console.WriteLine($"{tParameter.Id}_{tParameter.Name}");
            tParameter.Hi();
        }

註意：

基類約束時，基類不能是密封類，即不能是sealed類。sealed類表示該類不能被繼承，在這裡用作約束就無任何意義，因為sealed類沒有子類。

2、介面約束

        /// <summary>
        /// 介面約束
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <returns></returns>
        public static T Get<T>(T t) where T : ISports
        {
            t.Pingpang();
            return t;
        }

3、引用類型約束 class

引用類型約束保證T一定是引用類型的。

        /// 引用類型約束
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <returns></returns>
        public static T Get<T>(T t) where T : class
        {
            return t;
        }

4、值類型約束 struct

值類型約束保證T一定是值類型的。

        /// 值類型類型約束
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <returns></returns>
        public static T Get<T>(T t) where T : struct
        {
            return t;
        }

5、無參數構造函數約束 new()

        /// new()約束
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t"></param>
        /// <returns></returns>
        public static T Get<T>(T t) where T : new()
        {
            return t;
        }

泛型約束也可以同時約束多個，例如：

        /// <summary>
        ///  泛型：不同的參數類型都能進來；任何類型都能過來，你知道我是誰?
        /// 沒有約束，也就沒有自由
        ///  泛型約束--基類約束（不能是sealed）：
        /// 1 可以使用基類的一切屬性方法---權利
        /// 2  強制保證T一定是People或者People的子類---義務
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="tParameter"></param>
        public static void Show<T>(T tParameter)
        where T : People, ISports, IWork, new()
        {
            Console.WriteLine($"{tParameter.Id}_{tParameter.Name}");
            tParameter.Hi();
            tParameter.Pingpang();
            tParameter.Work();
        }

註意：有多個泛型約束時，new()約束一定是在最後。

泛型的協變和逆變

    public class Animal
    {
        public int Id { get; set; }
    }

    public class Cat : Animal
    {
        public string Name { get; set; }
    }
    

 static void Main(string[] args)
 {
    #region 協變和逆變

    // 直接聲明Animal類
    Animal animal = new Animal();
    // 直接聲明Cat類
    Cat cat = new Cat();
    // 聲明子類對象指向父類
    Animal animal2 = new Cat();
    // 聲明Animal類的集合
    List<Animal> listAnimal = new List<Animal>();
    // 聲明Cat類的集合
    List<Cat> listCat = new List<Cat>();

    #endregion
 }

那麼問題來了：下麵的一句代碼是不是正確的呢？

1 List<Animal> list = new List<Cat>();

可能有人會認為是正確的：因為一隻Cat屬於Animal，那麼一群Cat也應該屬於Animal啊。但是實際上這樣聲明是錯誤的：因為List和List之間沒有父子關係。

這時就可以用到協變和逆變了。

1 // 協變
2 IEnumerable<Animal> List1 = new List<Animal>();
3 IEnumerable<Animal> List2 = new List<Cat>();

F12查看定義：

可以看到，在泛型介面的T前面有一個out關鍵字修飾，而且T只能是返回值類型，不能作為參數類型，這就是協變。使用了協變以後，左邊聲明的是基類，右邊可以聲明基類或者基類的子類。

協變除了可以用在介面上面，也可以用在委托上面：

 Func<Animal> func = new Func<Cat>(() => null);

除了使用.NET框架定義好的以為，我們還可以自定義協變，例如：

    /// <summary>
    /// out 協變 只能是返回結果
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public interface ICustomerListOut<out T>
    {
        T Get();
    }

    public class CustomerListOut<T> : ICustomerListOut<T>
    {
        public T Get()
        {
            return default(T);
        }
    }

使用自定義的協變：

 // 使用自定義協變
 ICustomerListOut<Animal> customerList1 = new CustomerListOut<Animal>();
 ICustomerListOut<Animal> customerList2 = new CustomerListOut<Cat>();

在來看看逆變。

在泛型介面的T前面有一個In關鍵字修飾，而且T只能方法參數，不能作為返回值類型，這就是逆變。請看下麵的自定義逆變：

    /// <summary>
    /// 逆變 只能是方法參數
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public interface ICustomerListIn<in T>
    {
        void Show(T t);
    }

    public class CustomerListIn<T> : ICustomerListIn<T>
    {
        public void Show(T t)
        {
        }
    }

使用自定義逆變：

 // 使用自定義逆變
 ICustomerListIn<Cat> customerListCat1 = new CustomerListIn<Cat>();
 ICustomerListIn<Cat> customerListCat2 = new CustomerListIn<Animal>();

協變和逆變也可以同時使用，看看下麵的例子：

    /// <summary>
    /// inT 逆變
    /// outT 協變
    /// </summary>
    /// <typeparam name="inT"></typeparam>
    /// <typeparam name="outT"></typeparam>
    public interface IMyList<in inT, out outT>
    {
        void Show(inT t);
        outT Get();
        outT Do(inT t);
    }

    public class MyList<T1, T2> : IMyList<T1, T2>
    {

        public void Show(T1 t)
        {
            Console.WriteLine(t.GetType().Name);
        }

        public T2 Get()
        {
            Console.WriteLine(typeof(T2).Name);
            return default(T2);
        }

        public T2 Do(T1 t)
        {
            Console.WriteLine(t.GetType().Name);
            Console.WriteLine(typeof(T2).Name);
            return default(T2);
        }
    }

使用：

 IMyList<Cat, Animal> myList1 = new MyList<Cat, Animal>();
 IMyList<Cat, Animal> myList2 = new MyList<Cat, Cat>();//協變
 IMyList<Cat, Animal> myList3 = new MyList<Animal, Animal>();//逆變
 IMyList<Cat, Animal> myList4 = new MyList<Animal, Cat>();//逆變+協變

有關可變性的註意事項

• 變化只適用於引用類型，因為不能直接從值類型派生其他類型
• 顯示變化使用in和out關鍵字只適用於委托和介面，不適用於類、結構和方法
• 不包括in和out關鍵字的委托和介面類型參數叫做不變

泛型緩存

在前面我們學習過，類中的靜態類型無論實例化多少次，在記憶體中只會有一個。靜態構造函數只會執行一次。在泛型類中，T類型不同，每個不同的T類型，都會產生一個不同的副本，所以會產生不同的靜態屬性、不同的靜態構造函數，請看下麵的例子：

public class GenericCache<T>
{
    static GenericCache()
    {
        Console.WriteLine("This is GenericCache 靜態構造函數");
        _TypeTime = string.Format("{0}_{1}", typeof(T).FullName, DateTime.Now.ToString("yyyyMMddHHmmss.fff"));
    }

    private static string _TypeTime = "";

    public static string GetCache()
    {
        return _TypeTime;
    }
}
public class GenericCacheTest
{
    public static void Show()
    {
        for (int i = 0; i < 5; i++)
        {
            Console.WriteLine(GenericCache<int>.GetCache());
            Thread.Sleep(10);
            Console.WriteLine(GenericCache<long>.GetCache());
            Thread.Sleep(10);
            Console.WriteLine(GenericCache<DateTime>.GetCache());
            Thread.Sleep(10);
            Console.WriteLine(GenericCache<string>.GetCache());
            Thread.Sleep(10);
            Console.WriteLine(GenericCache<GenericCacheTest>.GetCache());
            Thread.Sleep(10);
        }
    }
}

Main()方法裡面調用：

 static void Main(string[] args)
 {
    #region 泛型緩存
	GenericCacheTest.Show();
    #endregion
 }

結果：

從上面的截圖中可以看出，泛型會為不同的類型都創建一個副本，所以靜態構造函數會執行5次。 而且每次靜態屬性的值都是一樣的。利用泛型的這一特性，可以實現緩存。

註意：只能為不同的類型緩存一次。泛型緩存比字典緩存效率高。泛型緩存不能主動釋放。

註意

1.泛型代碼中的 default 關鍵字

在泛型類和泛型方法中會出現的一個問題是，如何把預設值賦給參數化類型，此時無法預先知道以下兩點：

• T將是值類型還是引用類型

• 如果T是值類型，那麼T將是數值還是結構

對於一個參數化類型T的變數t，僅當T是引用類型時，t = null語句才是合法的； t = 0只對數值的有效，而對結構則不行。這個問題的解決辦法是用default關鍵字，它對引用類型返回空，對值類型的數值型返回零。而對於結構，它將返回結構每個成員，並根據成員是值類型還是引用類型，返回零或空。下麵GenericList類的例子顯示瞭如何使用default關鍵字。

    static void Main(string[] args)
    {
        #region 泛型代碼預設關鍵字default
        // 使用非空的整數列表進行測試.
        GenericList<int> gll = new GenericList<int>();
        gll.AddNode(5);
        gll.AddNode(4);
        gll.AddNode(3);
        int intVal = gll.GetLast();
        // 下麵一行顯示5.
        Console.WriteLine(intVal);

        // 用一個空的整數列表進行測試.
        GenericList<int> gll2 = new GenericList<int>();
        intVal = gll2.GetLast();
        // 下麵一行顯示0.
        Console.WriteLine(intVal);

        // 使用非空字元串列表進行測試.
        GenericList<string> gll3 = new GenericList<string>();
        gll3.AddNode("five");
        gll3.AddNode("four");
        string sVal = gll3.GetLast();
        // 下麵一行顯示five.
        Console.WriteLine(sVal);

        // 使用一個空字元串列表進行測試.
        GenericList<string> gll4 = new GenericList<string>();
        sVal = gll4.GetLast();
        // 下麵一行顯示一條空白行.
        Console.WriteLine(sVal);
        #endregion
        Console.ReadKey();
    }

    public class GenericList<T>
    {
        private class Node
        {
            // 每個節點都有一個指向列表中的下一個節點的引用.
            public Node Next;
            // 每個節點都有一個T類型的值.
            public T Data;
        }

        // 這個列表最初是空的.
        private Node head = null;

        // 在列表開始的時候添加一個節點，用t作為它的數據值.
        public void AddNode(T t)
        {
            Node newNode = new Node();
            newNode.Next = head;
            newNode.Data = t;
            head = newNode;
        }

        // 下麵的方法返回存儲在最後一個節點中的數據值列表. 如果列表是空的, 返回類型T的預設值.
        public T GetLast()
        {
            // 臨時變數的值作為方法的值返回. 
            // 下麵的聲明初始化了臨時的溫度 
            // 類型T的預設值. 如果該列表為空返回預設值.
            T temp = default(T);

            Node current = head;
            while (current != null)
            {
                temp = current.Data;
                current = current.Next;
            }
            return temp;
        }
    }

2.泛型集合

通常情況下，建議您使用泛型集合，因為這樣可以獲得類型安全的直接優點而不需要從基集合類型派生並實現類型特定的成員。下麵的泛型類型對應於現有的集合類型：

1、List 是對應於 ArrayList 的泛型類。
2、Dictionary 是對應於 Hashtable 的泛型類。
3、Collection 是對應於 CollectionBase 的泛型類。
4、ReadOnlyCollection 是對應於 ReadOnlyCollectionBase 的泛型類。
5、Queue、Stack 和 SortedList 泛型類分別對應於與其同名的非泛型類。
6、LinkedList 是一個通用鏈接列表，它提供運算複雜度為 O(1) 的插入和移除操作。
7、SortedDictionary 是一個排序的字典，其插入和檢索操作的運算複雜度為 O(log n)，這使得它成為 SortedList 的十分有用的替代類型。
8、KeyedCollection 是介於列表和字典之間的混合類型，它提供了一種存儲包含自己鍵的對象的方法。

總結

1. 作為一個開發人員，當我們程式代碼有相同的邏輯，有可能是方法、介面、類或者委托，只是某些參數類型不同，我們希望代碼可以通用、復用，甚至是說為了偷懶，也可以說是在不確定類型的情況下，就應該考慮用泛型的思維去實現。
2. 在非泛型編程中，雖然所有的東西都可以作為Object傳遞，但是在傳遞的過程中免不了要進行類型轉換。而類型轉換在運行時是不安全的。使用泛型編程將可以減少不必要的類型轉換，從而提高安全性。不僅是值類型，引用類型也存在這樣的問題，因此有必要的儘量的去使用泛型集合。
3. 在非泛型編程中，將簡單類型作為Object傳遞時會引起裝箱和拆箱的操作，這兩個過程都是具有很大開銷的。使用泛型編程就不必進行裝箱和拆箱操作了。

參考 文檔 《C#圖解教程》

註：搜索關註公眾號【DotNet技術谷】--回覆【C#圖解】，可獲取 C#圖解教程文件