引言：
在上一個專題中介紹了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<>);
// 創建該類型的實例（同樣會失敗，出現異常）
o = CreateInstance(t);
Console.WriteLine();
// DictionaryStringKey<int>是一個封閉類型
t = typeof(DictionaryStringKey<int>);
// 創建封閉類型的一個實例（成功）
o = CreateInstance(t);
Console.WriteLine("對象類型 = " + o.GetType());
Console.Read();
}
// 創建類型
private static object CreateInstance(Type t)
{
object o = null;
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會定義一個新的類型對象， 所以每個靜態字段都是不一樣對象里面的靜態字段，所以才會每個都有各自的值） 通過以下代碼來更好說明下――每個封閉類型都有它自己的靜態字段：
View Code
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
{
public static string field;
public static void OutField()
{
Console.WriteLine(field);
}
}
class Program
{
static void Main(string[] args)
{
// 使用類型實參時，實際上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();
Console.Read();
}
}
}
運行結果：
同樣每個封閉類型都有一個靜態構造函數的，通過下面的代碼可以讓大家更加明白這點：
// 靜態構造函數的例子
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
{
static void Main(string[] args)
{
#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();
Outer<string>.Inner<int>.Print();
Console.Read();
#endregion
}
}
運行結果：
從上圖的運行結果可能會發現，我們代碼中7個需要輸出的，但是結果中只有6個結果輸出的，這是因為任何封閉類型的靜態構造函數只執行一次，最后一行的 Outer<string>.Inner<int>.Print();這行不會產生第7行輸出， 因為Outer<string>.Inner<int>.Print();的靜態構造函數在之前已經執行過的（第三行已經執行過了）。
三、編譯器如何解析泛型
在上一個專題中，我只是貼出了泛型與非泛型的比較結果來說明泛型具有高性能的好處，卻沒有給出具體導致泛型比非泛型效率高的原因，所以在這個部分來剖析下泛型效率的具體原因。
這里先貼出上一個專題中說明泛型高性能好處的代碼，然后再查看IL代碼來說明泛型的高性能（針對泛型和非泛型，C#編譯器是如何解析為IL代碼的）：
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
namespace GeneralDemo
{
public class Program
{
static void Main(string[] args)
{
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);
Console.Read();
}
}
}
當使用非泛型的的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代碼截圖（從圖片中可以看出，使用泛型時，沒有執行裝箱的操作，這樣就少了裝箱的時間，這樣當然就運行的快了，性能就好了。）：
四、小結
說到這里本專題的內容也就介紹結束了，本專題主要是進一步介紹了泛型的其他內容的，由于篇幅的關于我將泛型的其他內容放在下一專題中，如果都在放在這個專題中內容會顯得非常多，這樣也不利于大家的消化和大家的閱讀，所以我在下一個專題中繼續介紹泛型的其他的一些內容。
下面先附上泛型專題中用到的所有Demo的源代碼：GeneralDemo_jb51.rar
