[C# 基礎知識系列]專題七: 泛型深入了解(一)

引言：

　　在上一個專題中介紹了C#2.0 中引入泛型的原因以及有了泛型後所帶來的好處，然而上一專題相當于是介紹了泛型的一些基本知識的，對于泛型的性能為什麼會比非泛型的性能高卻沒有給出理由，是以在這個專題就中将會介紹原因和一些關于泛型的其他知識。

一、泛型類型和類型參數

　　泛型類型和其他int,string一樣都是一種類型，泛型類型有兩種表現形式的：泛型類型（包括類、接口、委托和結構，但是沒有泛型枚舉的）和泛型方法。那什麼樣的類、接口、委托和方法才稱作泛型類型的呢 ？我的了解是類、接口、委托、結構或方法中有類型參數就是泛型類型，這樣就有類型參數的概念的。 類型參數 ——是一個真實類型的一個占位符（我想到一個很形象的比喻的，比如大家在學校的時候，一到中午下課的時候食堂人特别多的，是以很多應該都有用書本占位置的習慣的， 書本就相當于一個占位符，真真坐在位置上的當然是自己的，講到占位置，以前聽過我同學說，他們班有個很牛逼的MM，中午下完課的時候用手機占位子的，等它打完飯回來的時候手機已經不見， 當時聽完我就和我同學說，你們班這位女生真牛逼的，後面我們就），泛型聲明中，類型參數必須放在一對尖括号裡面（即<>這個符号），并且用逗号分隔多個類型參數，如List<T>類中T就是類型參數，在使用泛型類型或方法的時候，我們要用真實類型來代替，就像用書本占位子一個，書本隻是暫時的在那個位置上，等打好飯了就要換成你坐在位置上了，同樣在C#中泛型也是同樣道理，類型參數隻是暫時的在那個位置，真真使用中要用真實的類型去代替它的位置，此時我們把真實類型又取名為類型實參，如上一專題的代碼中List<int>，類型實參就是int(代替T的位置)。

　　如果沒有為類型參數提供類型實參，此時我們就聲明了一個未綁定的泛型類型，如果指定了類型實參，此時的類型就叫做已構造類型（這裡同樣可以以書占位置去了解），然而已構造類型又可以是開放類型或封閉類型的，這裡先給出這個兩個概念的定義的：開放類型——具有類型參數的類型就是開放類型（所有的未綁定的泛型類型都屬于開放類型的），封閉類型——為每個類型參數都傳遞了實際的資料類型。對于開放類型，我們建立開放類型的執行個體。

　　注意:在C#代碼中，我們唯一可以看到未綁定泛型類型的地方（除了作為聲明之外）就是在typeof操作符裡。

下面通過以下代碼來更好的說明這點：

using System;  

using System.Collections.Generic;  

namespace CloseTypeAndOpenType  

{  

    // 聲明開放泛型類型  

    public sealed class DictionaryStringKey<T> : Dictionary<string, T>  

    {  

    }  

   public class Program  

        static void Main(string[] args)  

        {  

            object o = null;  

            // Dictionary<,>是一個開放類型，它有2個類型參數  

            Type t = typeof(Dictionary<,>);  

            // 建立開放類型的執行個體（建立失敗，出現異常）  

            o = CreateInstance(t);  

            Console.WriteLine();  

            // DictionaryStringKey<>也是一個開放類型，但它有1個類型參數  

            t = typeof(DictionaryStringKey<>);  

            // 建立該類型的執行個體（同樣會失敗，出現異常）  

            // DictionaryStringKey<int>是一個封閉類型  

            t = typeof(DictionaryStringKey<int>);  

            // 建立封閉類型的一個執行個體（成功）  

            Console.WriteLine("對象類型 = " + o.GetType());  

            Console.Read();  

        }  

       // 建立類型  

        private static object CreateInstance(Type t)  

            try 

            {  

                // 使用指定類型t的預設構造函數來建立該類型的執行個體  

                o = Activator.CreateInstance(t);  

                Console.WriteLine("已建立{0}的執行個體", t.ToString());  

            }  

            catch(Exception ex)  

                Console.WriteLine(ex.Message);  

            return o;  

} 

運作結果為（從結果中也可以看出開放類型不能建立該類型的一個執行個體，異常資訊中指出類型中包含泛型參數）：

二、泛型類型中的靜态字段和靜态構造函數

　　首先執行個體字段是屬于一個執行個體的，靜态字段是從屬于它們聲明的類型，即如果在某個Myclass類中聲明了一個靜态字段field,則不管建立Myclass的多少個執行個體，也不管從Myclass中派生出多少個執行個體，都隻有一個Myclass.x字段。然而每個封閉類型都有它自己的靜态字段（使用類型實參時，實際上CLR會定義一個新的類型對象， 是以每個靜态字段都是不一樣對象裡面的靜态字段，是以才會每個都有各自的值） 通過以下代碼來更好說明下——每個封閉類型都有它自己的靜态字段：

namespace GenericStaticFieldAndStaticFunction  

    // 泛型類，具有一個類型參數  

    public static class TypeWithStaticField<T>  

        public static string field;  

        public static void OutField()  

            Console.WriteLine(field+":"+typeof(T).Name);  

    // 非泛型類  

    public static class NoGenericTypeWithStaticField  

            Console.WriteLine(field);  

    class Program  

            // 使用類型實參時，實際上CLR會定義一個新的類型對象  

            // 是以每個靜态字段都是不一樣對象裡面的靜态字段，是以才會每個都有各自的值  

            // 對泛型類型類的靜态字段指派  

            TypeWithStaticField<int>.field = "一";  

            TypeWithStaticField<string>.field = "二";  

            TypeWithStaticField<Guid>.field = "三";  

            // 此時filed 值隻會有一個值，每個指派都是改變了原來的值  

            NoGenericTypeWithStaticField.field = "非泛型類靜态字段一";  

            NoGenericTypeWithStaticField.field = "非泛型類靜态字段二";  

            NoGenericTypeWithStaticField.field = "非泛型類靜态字段三";  

            NoGenericTypeWithStaticField.OutField();  

            // 證明每個封閉類型都有一個靜态字段  

            TypeWithStaticField<int>.OutField();  

            TypeWithStaticField<string>.OutField();  

            TypeWithStaticField<Guid>.OutField();  

運作結果：

同樣每個封閉類型都有一個靜态構造函數的，通過下面的代碼可以讓大家更加明白這點：

// 靜态構造函數的例子  

    public static class Outer<Tx>  

        // 嵌套類  

        public class Inner<Ty>  

            // 靜态構造函數  

            static Inner()  

                Console.WriteLine("Outer<{0}>.Inner<{1}>", typeof(Tx), typeof(Ty));  

            public static void Print()  

            {   

class Program  

   #region 靜态函數的示範  

            // 靜态構造函數會運作多次  

            // 因為每個封閉類型都有單獨的一個靜态構造函數  

            Outer<int>.Inner<string>.Print();  

            Outer<int>.Inner<int>.Print();  

            Outer<string>.Inner<int>.Print();  

            Outer<string>.Inner<string>.Print();  

            Outer<object>.Inner<string>.Print();  

            Outer<object>.Inner<object>.Print();  

            #endregion  

    } 

    從上圖的運作結果可能會發現，我們代碼中7個需要輸出的，但是結果中隻有6個結果輸出的，這是因為任何封閉類型的靜态構造函數隻執行一次，最後一行的 Outer<string>.Inner<int>.Print();這行不會産生第7行輸出， 因為Outer<string>.Inner<int>.Print();的靜态構造函數在之前已經執行過的（第三行已經執行過了）。

三、編譯器如何解析泛型

　　在上一個專題中，我隻是貼出了泛型與非泛型的比較結果來說明泛型具有高性能的好處，卻沒有給出具體導緻泛型比非泛型效率高的原因，是以在這個部分來剖析下泛型效率的具體原因。

這裡先貼出上一個專題中說明泛型高性能好處的代碼，然後再檢視IL代碼來說明泛型的高性能（針對泛型和非泛型，C#編譯器是如何解析為IL代碼的）：

using System.Collections;  

using System.Diagnostics;  

namespace GeneralDemo  

    public class Program  

            Stopwatch stopwatch = new Stopwatch();  

            // 非泛型數組  

            ArrayList arraylist = new ArrayList();  

            // 泛型數組  

            List<int> genericlist= new List<int>();  

            // 開始計時  

            stopwatch.Start();  

            for (int i = 1; i < 10000000; i++)  

                //genericlist.Add(i);  

                arraylist.Add(i);  

            // 結束計時  

            stopwatch.Stop();  

            // 輸出所用的時間  

            TimeSpan ts = stopwatch.Elapsed;  

            string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",  

             ts.Hours, ts.Minutes, ts.Seconds,  

             ts.Milliseconds/10);  

            Console.WriteLine("運作的時間： " + elapsedTime);  

當使用非泛型的的ArrayList數組時，IL的代碼如下（這裡隻是貼出了部分主要的中間代碼，具體的大家可以下載下傳示例源碼用IL反彙程式設計式檢視的）：

IL_001f:  ldloc.1  

IL_0020:  ldloc.3  

IL_0021:  box        [mscorlib]System.Int32  

IL_0026:  callvirt   instance int32 [mscorlib]System.Collections.ArrayList::Add(object)  

IL_002b:  pop  

IL_002c:  nop  

IL_002d:  ldloc.3  

IL_002e:  ldc.i4.1  

IL_002f:  add 

    在上面的IL代碼中，我用紅色的标記的代碼主要是在執行裝箱操作（裝箱過程肯定是要消耗時間的吧， 就像生活中寄包裹一樣，包裝起來肯定是要花費一定時間， 裝箱操作同樣會，然而對于泛型類型就可以避免裝箱操作，下面會貼出使用泛型類型的IL代碼的截圖）——這個操作也是影響非泛型的性能不如泛型類型的根本原因。然而為什麼使用ArrayList類型在調用Add方法來向數組添加元素之前要裝箱的呢？原因其實主要出在Add方法上的， 大家可以用Reflector反射工具檢視ArrayList的Add方法定義，下面是一張Add方法原型的截圖：

    從上面截圖可以看出，Add(objec value)需要接收object類型的參數，然而我們代碼中需要傳遞的是int實參，此時就會發生裝箱操作（值類型int轉化為object引用類型,這個過程就是裝箱操作），這樣也就解釋了為什麼調用Add方法會執行裝箱操作的， 同時也就說明泛型的高性能。

下面是使用泛型List<T>的IL代碼截圖（從圖檔中可以看出，使用泛型時，沒有執行裝箱的操作，這樣就少了裝箱的時間，這樣當然就運作的快了，性能就好了。）：

四、小結

　　說到這裡本專題的内容也就介紹結束了，本專題主要是進一步介紹了泛型的其他内容的，由于篇幅的關于我将泛型的其他内容放在下一專題中，如果都在放在這個專題中内容會顯得非常多，這樣也不利于大家的消化和大家的閱讀，是以我在下一個專題中繼續介紹泛型的其他的一些内容。

<a href="http://down.51cto.com/data/2361729" target="_blank">附件：http://down.51cto.com/data/2361729</a>

     本文轉自LearningHard 51CTO部落格，原文連結：http://blog.51cto.com/learninghard/1053386，如需轉載請自行聯系原作者