泛型：通過引數化型別來實現在同一份程式碼上操作多種資料型別。利用“引數化型別”將型別抽象化，從而實現靈活的複用。 例子程式碼： class Program     {         static void Main(string[] args)         {             int obj = 2;             Test<int> test = new Test<int>(obj);             Console.WriteLine("int:" + test.obj);             string obj2 = "hello world";             Test<string> test1 = new Test

<string>(obj2);             Console.WriteLine("String:" + test1.obj);             Console.Read();         }     }     class Test<T>     {         public T obj;         public Test(T obj)         {             this.obj = obj;         } } 輸出結果是：     int:2 String:hello world 程式分析： 1、 Test

是一個泛型類。T是要例項化的範型型別。如果T被例項化為int型，那麼成員變數obj就是int型的，如果T被例項化為string型，那麼obj就是string型別的。 2、 根據不同的型別，上面的程式顯示出不同的值。 C#泛型機制： C#泛型能力有CLR在執行時支援：C#泛型程式碼在編譯為IL程式碼和元資料時，採用特殊的佔位符來表示範型型別，並用專有的IL指令支援泛型操作。而真正的泛型例項化工作以“on-demand”的方式，發生在JIT編譯時。 看看剛才的程式碼中Main函式的元資料 .method private hidebysig static void Main(string[] args) cil managed {  .entrypoint  // Code size       79 (0x4f)  .maxstack 2  .locals init ([0] int32 obj,            [1] class CSharpStudy1.Test`1<int32> test,            [2] string obj2,            [3] class CSharpStudy1.Test`1<string> test1)  IL_0000: nop  IL_0001: ldc.i4.2  IL_0002: stloc.0  IL_0003: ldloc.0  IL_0004: newobj     instance void class CSharpStudy1.Test`1<int32>::.ctor(!0)  IL_0009: stloc.1  IL_000a: ldstr      "int:"  IL_000f: ldloc.1  IL_0010: ldfld      !0 class CSharpStudy1.Test`1<int32>::obj  IL_0015: box        [mscorlib]System.Int32  IL_001a: call       string [mscorlib]System.String::Concat(object,                                                               object)  IL_001f: call       void [mscorlib]System.Console::WriteLine(string)  IL_0024: nop  IL_0025: ldstr      "hello world"  IL_002a: stloc.2  IL_002b: ldloc.2  IL_002c: newobj     instance void class CSharpStudy1.Test`1<string>::.ctor(!0)  IL_0031: stloc.3  IL_0032: ldstr      "String:"  IL_0037: ldloc.3  IL_0038: ldfld      !0 class CSharpStudy1.Test`1<string>::obj  IL_003d: call       string [mscorlib]System.String::Concat(string,                                                               string)  IL_0042: call       void [mscorlib]System.Console::WriteLine(string)  IL_0047: nop  IL_0048: call       int32 [mscorlib]System.Console::Read()  IL_004d: pop  IL_004e: ret } // end of method Program::Main 再來看看Test類中建構函式的元資料 .method public hidebysig specialname rtspecialname         instance void .ctor(!T obj) cil managed {  // Code size       17 (0x11)  .maxstack 8  IL_0000: ldarg.0  IL_0001: call       instance void [mscorlib]System.Object::.ctor()  IL_0006: nop  IL_0007: nop  IL_0008: ldarg.0  IL_0009: ldarg.1  IL_000a: stfld      !0 class ConsoleCSharpTest1.Test`1<!T>::obj  IL_000f: nop  IL_0010: ret } // end of method Test`1::.ctor 1、第一輪編譯時，編譯器只為Test<T>型別產生“泛型版”的IL程式碼與元資料——並不進行泛型的例項化，T在中間只充當佔位符。例如：Test型別元資料中顯示的<!T> 2、JIT編譯時，當JIT編譯器第一次遇到Test<int>時，將用int替換“範型版”IL程式碼與元資料中的T——進行泛型型別的例項化。例如：Main函式中顯示的<int> 3、CLR為所有型別引數為“引用型別”的泛型型別產生同一份程式碼；但是如果型別引數為“值型別”，對每一個不同的“值型別”，CLR將為其產生一份獨立的程式碼。因為例項化一個引用型別的泛型，它在記憶體中分配的大小是一樣的，但是當例項化一個值型別的時候，在記憶體中分配的大小是不一樣的。 C#泛型特點： 1、如果例項化泛型型別的引數相同，那麼JIT編輯器會重複使用該型別，因此C#的動態泛型能力避免了C++靜態模板可能導致的程式碼膨脹的問題。 2、C#泛型型別攜帶有豐富的元資料，因此C#的泛型型別可以應用於強大的反射技術。 3、C#的泛型採用“基類、介面、構造器，值型別/引用型別”的約束方式來實現對型別引數的“顯示約束”，提高了型別安全的同時，也喪失了C++模板基於“簽名”的隱式約束所具有的高靈活性 C#泛型繼承： C#除了可以單獨宣告泛型型別（包括類與結構）外，也可以在基類中包含泛型型別的宣告。但基類如果是泛型類，它的型別要麼以例項化，要麼來源於子類（同樣是泛型型別）宣告的型別引數，看如下型別 class C<U,V> class D:C<string,int> class E<U,V>:C<U,V> class F<U,V>:C<string,int> class G:C<U,V> //非法 E型別為C型別提供了U、V，也就是上面說的來源於子類 F型別繼承於C<string,int>，個人認為可以看成F繼承一個非泛型的類 G型別為非法的，因為G型別不是泛型，C是泛型，G無法給C提供泛型的例項化 泛型型別的成員： 泛型型別的成員可以使用泛型型別宣告中的型別引數。但型別引數如果沒有任何約束，則只能在該型別上使用從System.Object繼承的公有成員。如下圖： 泛型介面： 泛型介面的型別引數要麼已例項化，要麼來源於實現類宣告的型別引數 泛型委託： 泛型委託支援在委託返回值和引數上應用引數型別，這些引數型別同樣可以附帶合法的約束 delegate bool MyDelegate<T>(T value); class MyClass {     static bool F(int i){...}     static bool G(string s){...}     static void Main()     {         MyDelegate<string> p2 = G;         MyDelegate<int> p1 = new MyDelegate<int>(F);     } } 泛型方法： 1、C#泛型機制只支援“在方法宣告上包含型別引數”——即泛型方法。 2、C#泛型機制不支援在除方法外的其他成員（包括屬性、事件、索引器、構造器、析構器）的宣告上包含型別引數，但這些成員本身可以包含在泛型型別中，並使用泛型型別的型別引數。 3、泛型方法既可以包含在泛型型別中，也可以包含在非泛型型別中。 泛型方法宣告：如下 public static int FunctionName<T>(T value){...} 泛型方法的過載： public void Function1<T>(T a); public void Function1<U>(U a); 這樣是不能構成泛型方法的過載。因為編譯器無法確定泛型型別T和U是否不同，也就無法確定這兩個方法是否不同 public void Function1<T>(int x); public void Function1(int x); 這樣可以構成過載 public void Function1<T>(T t) where T:A; public void Function1<T>(T t) where T:B; 這樣不能構成泛型方法的過載。因為編譯器無法確定約束條件中的A和B是否不同，也就無法確定這兩個方法是否不同 泛型方法重寫： 在重寫的過程中，抽象類中的抽象方法的約束是被預設繼承的。如下： abstract class Base {     public abstract T F<T,U>(T t,U u) where U:T;     public abstract T G<T>(T t) where T:IComparable; } class MyClass:Base {     public override X F<X,Y>(X x,Y y){...}     public override T G<T>(T t) where T:IComparable{} } 對於MyClass中兩個重寫的方法來說 F方法是合法的，約束被預設繼承 G方法是非法的，指定任何約束都是多餘的 泛型約束： 1、C#泛型要求對“所有泛型型別或泛型方法的型別引數”的任何假定，都要基於“顯式的約束”，以維護C#所要求的型別安全。 2、“顯式約束”由where子句表達，可以指定“基類約束”，“介面約束”，“構造器約束”，“值型別/引用型別約束”共四種約束。 3、“顯式約束”並非必須，如果沒有指定“顯式約束”，範型型別引數將只能訪問System.Object型別中的公有方法。例如：在開始的例子中，定義的那個obj成員變數。比如我們在開始的那個例子中加入一個Test1類，在它當中定義兩個公共方法Func1、Func2，如下圖： 基類約束： class A     {         public void Func1()         { }     }     class B     {         public void Func2()         { }     }     class C<S, T>         where S : A         where T : B     {         public C(S s,T t)         {             //S的變數可以呼叫Func1方法             s.Func1();             //T的變數可以呼叫Func2方法             t.Func2();         }     } 介面約束： interface IA<T>     {         T Func1();     }     interface IB     {         void Func2();     }     interface IC<T>     {         T Func3();     }     class MyClass<T, V>         where T : IA<T>         where V : IB, IC<V>     {         public MyClass(T t,V v)         {             //T的物件可以呼叫Func1             t.Func1();             //V的物件可以呼叫Func2和Func3             v.Func2();             v.Func3();         }     } 構造器約束： class A         {             public A()             { }         }         class B         {             public B(int i)             { }         }         class C<T> where T : new()         {             T t;             public C()             {                 t = new T();             }         }         class D         {             public void Func()             {                 C<A> c = new C<A>();                 C<B> d = new C<B>();             }         }     d物件在編譯時報錯：The type B must have a public parameterless constructor in order to use it as parameter 'T' in the generic type or method C<T> 注意：C#現在只支援無參的構造器約束 此時由於我們為B型別寫入了一個有參構造器，使得系統不會再為B自動建立一個無參的構造器，但是如果我們將B型別中加一個無參構造器，那麼物件d的例項化就不會報錯了。B型別定義如下： class B         {             public B()             { }             public B(int i)             { }         } 值型別/引用型別： public struct A { }         public class B { }         public class C<T> where T : struct         {         }         C<A> c1 = new C<A>();         C<B> c2 = new C<B>();     c2物件在編譯時報錯：The type 'B' must be a non-nullable value type in order to use it as parameter 'T' in the generic type or methor 'C<T>' 總結： 1、C#的泛型能力由CLR在執行時支援，它既不同於C++在編譯時所支援的靜態模板，也不同於Java在編譯器層面使用“擦拭法”支援的簡單的泛型。 2、C#的泛型支援包括類、結構、介面、委託四種泛型型別，以及方法成員。 3、C#的泛型採用“基類，介面，構造器，值型別/引用型別”的約束方式來實現對型別引數的“顯式約束”，它不支援C++模板那樣的基於簽名的隱式約束。

下面就開始分析這些約束：