19.1.1 為什么泛型？ 沒有泛型，一些通用的數據結構只能使用object類型來存貯各種類型的數據。例如，下面這個簡單的stack類將它的數據存放在一個object數組中，而它的兩個方法，push和pop，分別使用object來接受和返回數據： public class stack { object[] items; int count; public void push(object item) {...} public object pop() {...} } 盡管使用object類型使得stack類非常靈活，但它也不是沒有缺點。例如，可以向堆棧中壓入任何類型的值，譬如一個customer實例。然而，重新取回一個值得時候，必須將pop方法返回的值顯式地轉換為合適的類型，書寫這些轉換變更要提防運行時類型檢查錯誤是很乏味的： stack stack = new stack(); stack.push(new customer()); customer c = (customer)stack.pop(); 如果一個值類型的值，如int，傳遞給了push方法，它會自動裝箱。而當待會兒取回這個int值時，必須顯式的類型轉換進行拆箱： stack stack = new stack(); stack.push(3); int i = (int)stack.pop(); 這種裝箱和拆箱操作增加了執行的負擔，因為它帶來了動態內存分配和運行時類型檢查。 stack類的另外一個問題是無法強制堆棧中的數據的種類。確實，一個customer實例可以被壓入棧中，而在取回它的時候會意外地轉換成一個錯誤的類型： stack stack = new stack(); stack.push(new customer()); string s = (string)stack.pop(); 盡管上面的代碼是stack類的一種不正確的用法，但這段代碼從技術上來說是正確的，并且不會發生編譯期間錯誤。為題知道這段代碼運行的時候才會出現，這時會拋出一個invalidcastexception異常。 stack類無疑會從具有限定其元素類型的能力中獲益。使用泛型，這將成為可能。
19.1.2 建立和使用泛型 泛型提供了一個技巧來建立帶有類型參數（type parameters）的類型。下面的例子聲明了一個帶有類型參數t的泛型stack類。類型參數又類名字后面的定界符“<”和“>”指定。通過某種類型建立的stack<t>的實例 可以無欲轉換地接受該種類型的數據，這強過于與object相互裝換。類型參數t扮演一個占位符的角色，直到使用時指定了一個實際的類型。注意t相當于內部數組的數據類型、push方法接受的參數類型和pop方法的返回值類型： public class stack<t> { t[] items; int count; public void push(t item) {...} public t pop() {...} } 使用泛型類stack<t>時，需要指定實際的類型來替代t。下面的例子中，指定int作為參數類型t： stack<int> stack = new stack<int>(); stack.push(3); int x = stack.pop(); stack<int>類型稱為已構造類型（constructed type）。在stack<int>類型中出現的所有t被替換為類型參數int。當一個stack<int>的實例被創建時，items數組的本地存貯是int[]而不是object[]，這提供了一個實質的存貯，效率要高過非泛型的stack。同樣，stack<int>中的push和pop方法只操作int值，如果向堆棧中壓入其他類型的值將會得到編譯期間的錯誤，而且取回一個值時不必將它顯示轉換為原類型。 泛型可以提供強類型，這意味著例如向一個customer對象的堆棧上壓入一個int將會產生錯誤。這是因為stack<int>只能操作int值，而stack<customer>也只能操作customer對象。下面例子中的最后兩行會導致編譯器報錯： stack<customer> stack = new stack<customer>(); stack.push(new customer()); customer c = stack.pop(); stack.push(3); // 類型不匹配錯誤 int x = stack.pop(); // 類型不匹配錯誤 泛型類型的聲明允許任意數目的類型參數。上面的stack<t>例子只有一個類型參數，但一個泛型的dictionary類可能有兩個類型參數，一個是鍵的類型另一個是值的類型： public class dictionary<k,v> { public void add(k key, v value) {...} public v this[k key] {...} } 使用dictionary<k,v>時，需要提供兩個類型參數： dictionary<string,customer> dict = new dictionary<string,customer>(); dict.add("peter", new customer()); customer c = dict["peter"];
19.1.3 泛型類型實例化 和非泛型類型類似，編譯過的泛型類型也由中間語言（il, intermediate language）指令和元數據表示。泛型類型的il表示當然已由類型參數進行了編碼。 當程序第一次建立一個已構造的泛型類型的實例時，如stack<int>，.net公共語言運行時中的即時編譯器（jit, just-in-time）將泛型il和元數據轉換為本地代碼，并在進程中用實際類型代替類型參數。后面的對這個以構造的泛型類型的引用使用相同的本地代碼。從泛型類型建立一個特定的構造類型的過程稱為泛型類型實例化（generic type instantiation）。 .net公共語言運行時為每個由之類型實例化的泛型類型建立一個專門的拷貝，而所有的引用類型共享一個單獨的拷貝（因為，在本地代碼級別上，引用知識具有相同表現的指針）。
19.1.4 約束 通常，一個泛型類不會只是存貯基于某一類型參數的數據，他還會調用給定類型的對象的方法。例如，dictionary<k,v>中的add方法可能需要使用compareto方法來比較鍵值： public class dictionary<k,v> { public void add(k key, v value) { ... if (key.compareto(x) < 0) {...} // 錯誤，沒有compareto方法 ... } } 由于指定的類型參數k可以是任何類型，可以假定存在的參數key具有的成員只有來自object的成員，如equals、gethashcode和tostring；因此上面的例子會發生編譯錯誤。當然可以將參數key轉換成為一具有compareto方法的類型。例如，參數key可以轉換為icomparable： public class dictionary<k,v> { public void add(k key, v value) { ... if (((icomparable)key).compareto(x) < 0) {...} ... } } 當這種方案工作時，會在運行時引起動態類型轉換，會增加開銷。更要命的是，它還可能將錯誤報告推遲到運行時。如果一個鍵沒有實現icomparable接口，會拋出invalidcastexception異常。 為了提供更強大的編譯期間類型檢查和減少類型轉換，c#允許一個可選的為每個類型參數提供的約束（constraints）列表。一個類型參數的約束指定了一個類型必須遵守的要求，使得這個類型參數能夠作為一個變量來使用。約束由關鍵字where來聲明，后跟類型參數的名字，再后是一個類或接口類型的列表，或構造器約束new()。 要想使dictionary<k,v>類能保證鍵值始終實現了icomparable接口，類的聲明中應該對類型參數k指定一個約束： public class dictionary<k,v> where k: icomparable { public void add(k key, v value) { ... if (key.compareto(x) < 0) {...} ... } } 通過這個聲明，編譯器能夠保證所有提供給類型參數k的類型都實現了icomparable接口。進而，在調用compareto方法前不再需要將鍵值顯式轉換為一個icomparable接口；一個受約束的類型參數類型的值的所有成員都可以直接使用。 對于給定的類型參數，可以指定任意數目的接口作為約束，但只能指定一個類（作為約束）。每一個被約束的類型參數都有一個獨立的where子句。在下面的例子中，類型參數k有兩個接口約束，而類型參數e有一個類約束和一個構造器約束： public class entitytable<k,e> where k: icomparable<k>, ipersistable where e: entity, new() { public void add(k key, e entity) { ... if (key.compareto(x) < 0) {...} ... } } 上面例子中的構造器約束，new()，保證了作為的e類型變量的類型具有一個公共、無參的構造器，并允許泛型類使用new e()來建立該類型的一個實例。 類型參數約束的使用要小心。盡管它們提供了更強大的編譯期間類型檢查并在一些情況下改進了性能，它還是限制了泛型類型的使用。例如，一個泛型類list<t>可能約束t實現icomparable接口以便sort方法能夠比較其中的元素。然而，這么做使list<t>不能用于那些沒有實現icomparable接口的類型，盡管在這種情況下sort方法從來沒被實際調用過。
19.1.5 泛型方法 有的時候一個類型參數并不是整個類所必需的，而只用于一個特定的方法中。通常，這種情況發生在建立一個需要一個泛型類型作為參數的方法時。例如，在使用前面描述過的stack<t>類時，一種公共的模式就是在一行中壓入多個值，如果寫一個方法通過單獨調用它類完成這一工作會很方便。對于一個特定的構造過的類型，如stack<int>，這個方法看起來會是這樣： void pushmultiple(stack<int> stack, params int[] values) { foreach (int value in values) stack.push(value); } 這個方法可以用于將多個int值壓入一個stack<int>： stack<int> stack = new stack<int>(); pushmultiple(stack, 1, 2, 3, 4); 然而，上面的方法只能工作于特定的構造過的類型stack<int>。要想使他工作于任何stack<t>，這個方法必須寫成泛型方法（generic method）。一個泛型方法有一個或多個類型參數，有方法名后面的“<”和“>”限定符指定。這個類型參數可以用在參數列表、返回至和方法體中。一個泛型的pushmultiple方法看起來會是這樣： void pushmultiple<t>(stack<t> stack, params t[] values) { foreach (t value in values) stack.push(value); } 使用這個方法，可以將多個元素壓入任何stack<t>中。當調用一個泛型方法時，要在函數的調用中將類型參數放入尖括號中。例如： stack<int> stack = new stack<int>(); pushmultiple<int>(stack, 1, 2, 3, 4); 這個泛型的pushmultiple方法比上面的版本更具可重用性，因為它能工作于任何stack<t>，但這看起來并不舒服，因為必須為t提供一個類型參數。然而，很多時候編譯器可以通過傳遞給方法的其他參數來推斷出正確的類型參數，這個過程稱為類型推斷（type inferencing）。在上面的例子中，由于第一個正式的參數的類型是stack<int>，并且后面的參數類型都是int，編譯器可以認定類型參數一定是int。因此，在調用泛型的pushmultiple方法時可以不用提供類型參數： stack<int> stack = new stack<int>(); pushmultiple(stack, 1, 2, 3, 4);
19.2 匿名方法 實踐處理方法和其他回調方法通常需要通過專門的委托來調用，而不是直接調用。因此，迄今為止我們還只能將一個實踐處理和回調的代碼放在一個具體的方法中，再為其顯式地建立委托。相反，匿名方法（anonymous methods）允許將與一個委托關聯的代碼“內聯（in-line）”到使用委托的地方，我們可以很方便地將代碼直接寫在委托實例中。除了看起來舒服，匿名方法還共享對本地語句所包含的函數成員的訪問。如果想在命名方法（區別于匿名方法）中達成這種共享，需要手動創建一個輔助類并將本地成員“提升（lifting）”到這個類的域中。 下面的例子展示了從一個包含一個列表框、一個文本框和一個按鈕的窗體中獲取一個簡單的輸入。當按鈕按下時文本框中的文本會被添加到列表框中。 class inputform: form { listbox listbox; textbox textbox; button addbutton; public myform() { listbox = new listbox(...); textbox = new textbox(...); addbutton = new button(...); addbutton.click += new eventhandler(addclick); } void addclick(object sender, eventargs e) { listbox.items.add(textbox.text); } } 盡管對按鈕的click事件的響應只有一條語句，這條語句也必須放到一個獨立的具有完整的參數列表的方法中，并且要手動創建引用該方法的eventhandler委托。使用匿名方法，事件處理的代碼會變得更加簡潔： class inputform: form { listbox listbox; textbox textbox; button addbutton; public myform() { listbox = new listbox(...); textbox = new textbox(...); addbutton = new button(...); addbutton.click += delegate { listbox.items.add(textbox.text); }; } } 一個匿名方法由關鍵字delegate和一個可選的參數列表組成，并將語句放入“{”和“}”限定符中。前面例子中的匿名方法沒有使用提供給委托的參數，因此可以省略參數列表。要想訪問參數，你名方法應該包含一個參數列表： addbutton.click += delegate(object sender, eventargs e) { messagebox.show(((button)sender).text); }; 上面的例子中，在匿名方法和eventhandler委托類型（click事件的類型）之間發生了一個隱式的轉換。這個隱式的轉換是可行的，因為這個委托的參數列表和返回值類型和匿名方法是兼容的。精確的兼容規則如下： • 當下面條例中有一條為真時，則委托的參數列表和匿名方法是兼容的： o 匿名方法沒有參數列表且委托沒有輸出（out）參數。 o 匿名方法的參數列表在參數數目、類型和修飾符上與委托參數精確匹配。 • 當下面的條例中有一條為真時，委托的返回值與匿名方法兼容： o 委托的返回值類型是void且匿名方法沒有return語句或其return語句不帶任何表達式。 o 委托的返回值類型不是void但和匿名方法的return語句關聯的表達式的值可以被顯式地轉換為委托的返回值類型。 只有參數列表和返回值類型都兼容的時候，才會發生匿名類型向委托類型的隱式轉換。 下面的例子使用了匿名方法對函數進行了“內聯（in-lian）”。匿名方法被作為一個function委托類型傳遞。 using system; delegate double function(double x); class test { static double[] apply(double[] a, function f) { double[] result = new double[a.length]; for (int i = 0; i < a.length; i++) result = f(a); return result; } static double[] multiplyallby(double[] a, double factor) { return apply(a, delegate(double x) { return x * factor; }); } static void main() { double[] a = {0.0, 0.5, 1.0}; double[] squares = apply(a, delegate(double x) { return x * x; }); double[] doubles = multiplyallby(a, 2.0); } } apply方法需要一個給定的接受double[]元素并返回double[]作為結果的function。在main方法中，傳遞給apply方法的第二個參數是一個匿名方法，它與function委托類型是兼容的。這個匿名方法只簡單地返回每個元素的平方值，因此調用apply方法得到的double[]包含了a中每個值的平方值。 multiplyallby方法通過將參數數組中的每一個值乘以一個給定的factor來建立一個double[]并返回。為了產生這個結果，multiplyallby方法調用了apply方法，向它傳遞了一個能夠將參數x與factor相乘的匿名方法。 如果一個本地變量或參數的作用域包括了匿名方法，則該變量或參數稱為匿名方法的外部變量（outer variables）。在multiplyallby方法中，a和factor就是傳遞給apply方法的匿名方法的外部變量。通常，一個局部變量的生存期被限制在塊內或與之相關聯的語句內。然而，一個被捕獲的外部變量的生存期要擴展到至少對匿名方法的委托引用符合垃圾收集條件時。
19.2.1 方法組轉換 像前面章節中描述過的那樣，一個匿名方法可以被隱式轉換為一個兼容的委托類型。c# 2.0允許對一組方法進行相同的轉換，即所任何時候都可以省略一個委托的顯式實例化。例如，下面的語句： addbutton.click += new eventhandler(addclick); apply(a, new function(math.sin)); 還可以寫做： addbutton.click += addclick; apply(a, math.sin); 當使用短形式時，編譯器可以自動地推斷應該實例化哪一個委托類型，不過除此之外的效果都和長形式相同。
19.3 迭代器 c#中的foreach語句用于迭代一個可枚舉（enumerable）的集合中的元素。為了實現可枚舉，一個集合必須要有一個無參的、返回枚舉器（enumerator）的getenumerator方法。通常，枚舉器是很難實現的，因此簡化枚舉器的任務意義重大。 迭代器（iterator）是一塊可以產生（yields）值的有序序列的語句塊。迭代器通過出現的一個或多個yield語句來區別于一般的語句塊： • yield return語句產生本次迭代的下一個值。 • yield break語句指出本次迭代完成。 只要一個函數成員的返回值是一個枚舉器接口（enumerator interfaces）或一個可枚舉接口（enumerable interfaces），我們就可以使用迭代器： • 所謂枚舉器借口是指system.collections.ienumerator和從system.collections.generic.ienumerator<t>構造的類型。 • 所謂可枚舉接口是指system.collections.ienumerable和從system.collections.generic.ienumerable<t>構造的類型。 理解迭代器并不是一種成員，而是實現一個功能成員是很重要的。一個通過迭代器實現的成員可以用一個或使用或不使用迭代器的成員覆蓋或重寫。 下面的stack<t>類使用迭代器實現了它的getenumerator方法。其中的迭代器按照從頂端到底端的順序枚舉了棧中的元素。 using system.collections.generic; public class stack<t>: ienumerable<t> { t[] items; int count; public void push(t data) {...} public t pop() {...} public ienumerator<t> getenumerator() { for (int i = count – 1; i >= 0; --i) { yield return items; } } } getenumerator方法的出現使得stack<t>成為一個可枚舉類型，這允許stack<t>的實例使用foreach語句。下面的例子將值0至9壓入一個整數堆棧，然后使用foreach循環按照從頂端到底端的順序顯示每一個值。 using system; class test { static void main() { stack<int> stack = new stack<int>(); for (int i = 0; i < 10; i++) stack.push(i); foreach (int i in stack) console.write("{0} ", i); console.writeline(); } } 這個例子的輸出為： 9 8 7 6 5 4 3 2 1 0 語句隱式地調用了集合的無參的getenumerator方法來得到一個枚舉器。一個集合類中只能定義一個這樣的無參的getenumerator方法，不過通常可以通過很多途徑來實現枚舉，包括使用參數來控制枚舉。在這些情況下，一個集合可以使用迭代器來實現能夠返回可枚舉接口的屬性和方法。例如，stack<t>可以引入兩個新的屬性——ienumerable<t>類型的toptobottom和bottomtotop： using system.collections.generic; public class stack<t>: ienumerable<t> { t[] items; int count; public void push(t data) {...} public t pop() {...} public ienumerator<t> getenumerator() { for (int i = count – 1; i >= 0; --i) { yield return items; } } public ienumerable<t> toptobottom { get { return this; } } public ienumerable<t> bottomtotop { get { for (int i = 0; i < count; i++) { yield return items; } } } } toptobottom屬性的get訪問器只返回this，因為堆棧本身就是一個可枚舉類型。bottomtotop屬性使用c#迭代器返回了一個可枚舉接口。下面的例子顯示了如何使用這兩個屬性來以任意順序枚舉棧中的元素： using system; class test { static void main() { stack<int> stack = new stack<int>(); for (int i = 0; i < 10; i++) stack.push(i); foreach (int i in stack.toptobottom) console.write("{0} ", i); console.writeline(); foreach (int i in stack.bottomtotop) console.write("{0} ", i); console.writeline(); } } 當然，這些屬性還可以用在foreach語句的外面。下面的例子將調用屬性的結果傳遞給一個獨立的print方法。這個例子還展示了一個迭代器被用作一個帶參的fromtoby方法的方法體： using system; using system.collections.generic; class test { static void print(ienumerable<int> collection) { foreach (int i in collection) console.write("{0} ", i); console.writeline(); } static ienumerable<int> fromtoby(int from, int to, int by) { for (int i = from; i <= to; i += by) { yield return i; } } static void main() { stack<int> stack = new stack<int>(); for (int i = 0; i < 10; i++) stack.push(i); print(stack.toptobottom); print(stack.bottomtotop); print(fromtoby(10, 20, 2)); } } 這個例子的輸出為： 9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9 10 12 14 16 18 20 泛型和非泛型的可枚舉接口都只有一個單獨的成員，一個無參的getenumerator方法，它返回一個枚舉器接口。一個可枚舉接口很像一個枚舉器工廠（enumerator factory）。每當調用了一個正確地實現了可枚舉接口的類的getenumerator方法時，都會產生一個獨立的枚舉器。 using system; using system.collections.generic; class test { static ienumerable<int> fromto(int from, int to) { while (from <= to) yield return from++; } static void main() { ienumerable<int> e = fromto(1, 10); foreach (int x in e) { foreach (int y in e) { console.write("{0,3} ", x * y); } console.writeline(); } } } 上面的代碼打印了一個從1到10的簡單乘法表。注意fromto方法只調用了一次用來產生可枚舉接口e。而e.getenumerator()被調用了多次（通過foreach語句）來產生多個相同的枚舉器。這些枚舉器都封裝了fromto聲明中指定的代碼。注意，迭代其代碼改變了from參數。不過，枚舉器是獨立的，因為對于from參數和to參數，每個枚舉器擁有它自己的一份拷貝。在實現可枚舉類和枚舉器類時，枚舉器之間的過渡狀態（一個不穩定狀態）是必須消除的眾多細微瑕疵之一。c#中的迭代器的設計可以幫助消除這些問題，并且可以用一種簡單的本能的方式來實現健壯的可枚舉類和枚舉器類。
19.4 不完全類型 盡管在一個單獨的文件中維護一個類型的所有代碼是一項很好的編程實踐，但有些時候，當一個類變得非常大，這就成了一種不切實際的約束。而且，程序員經常使用代碼生成器來生成一個應用程序的初始結構，然后修改產生的代碼。不幸的是，當以后需要再次發布原代碼的時候，現存的修正會被重寫。 不完全類型允許類、結構和接口被分成多個小塊兒并存貯在不同的源文件中使其容易開發和維護。另外，不完全類型可以分離機器產生的代碼和用戶書寫的部分，這使得用工具來加強產生的代碼變得容易。 要在多個部分中定義一個類型的時候，我們使用一個新的修飾符——partial。下面的例子在兩個部分中實現了一個不完全類。這兩個部分可能在不同的源文件中，例如第一部分可能是機器通過數據庫影射工具產生的，而第二部分是手動創作的： public partial class customer { private int id; private string name; private string address; private list<order> orders; public customer() { ... } } public partial class customer { public void submitorder(order order) { orders.add(order); } public bool hasoutstandingorders() { return orders.count > 0; } } 當上面的兩部分編譯到一起時，產生的代碼就好像這個類被寫在一個單元中一樣： public class customer { private int id; private string name; private string address; private list<order> orders; public customer() { ... } public void submitorder(order order) { orders.add(order); } public bool hasoutstandingorders() { return orders.count > 0; } } 不完全類型的所有部分必須放到一起編譯，才能在編譯期間將它們合并。需要特別注意的是，不完全類型并不允許擴展已編譯的類型。
