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>也起作用，方法必須被作為泛型方法而編寫。泛型方法在方法的名字后面在“<”和“>”分界符之間指定了一個或多個類型參數。類型參數可以在參數列表，返回類型和方法體之內被使用。一個泛型的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 method）允許一個委托關聯的代碼被內聯的寫入使用委托的地方法，很方便的是這使得代碼對于委托的實例很直接。除了這種便利之外，匿名方法還共享了對本地語句包含的函數成員的訪問。為了使命名方法達成共享（區別于匿名方法），需要手工創建輔助類，并將本地成員“提升（lifting）”為類的域。
下面的例子展示了一個簡單的輸入表單，它包含一個列表框、一個文本框和一個按鈕。當按鈕被按下時，在文本框中一個包含文本的項就被添加到列表框。
class inputform:form
{
listbox listbox;
textbox textbox;
button addbutton;
pubic myform()
{
listbox = new listbox(…);
textbox = new textbox(…);
addbuton = 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;
pubic myform()
{
listbox = new listbox(…);
textbox = new textbox(…);
addbuton = 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事件的類型）的隱式轉換。這種隱式轉換是可能的，因為參數列表和委托類型的返回值與匿名方法是兼容的。關于兼容性的確切規則如下：
如果下列之一成立，那么委托的參數列表與匿名方法是兼容的。
- 匿名方法沒有參數列表，并且委托沒有out 參數。
- 匿名方法包含的參數列表與委托的參數在數量、類型和修飾符上是精確匹配的。
如果下列之一成立，那么委托的返回類型與匿名方法兼容。
- 委托的返回類型是void，匿名方法沒有返回語句，或者只有不帶表達式的return 語句。
- 委托的返回類型不是void ，并且在匿名方法中，所有return 語句相關的表達式可以被隱式轉換到委托的類型。
在委托類型的隱式轉換發生以前，委托的參數列表和返回類型二者都必須與匿名方法兼容。
下面的例子使用匿名方法編寫了“內聯”函數。匿名方法被作為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[i] = f(a[i]);
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[]元素的給定的function，并返回一個double[]作為結果。在main方法中，傳遞給apply的第二個參數是一個匿名方法，它與fucntion委托類型兼容。該匿名方法只是返回參數的平方，而apply調用的結果是一個double[] ，在a中包含了值的平方。
multiplyallby方法返回一個由一個給定factor（因數）的在參數數組a中的每個值相乘而創建的double[] 。要得到結果，multiplyallby調用了apply方法，并傳給它一個匿名方法（在參數上乘以因數factor）。
如果一個本地變量或參數的作用域包括了匿名方法，則該變量和參數被稱為匿名方法的外部變量（outer variable）。在multiplyallby方法中，a和factor是傳遞給apply的匿名方法的外部變量，因為匿名方法引用了factor，factor被匿名方法所捕獲（capture）。通常，局部變量的生存期被限制在它所關聯的塊或語句的執行區。然而，被捕獲的外部變量將一直存活到委托所引用的匿名方法可以被垃圾回收為止。
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）集合的所有元素。為了可以被枚舉，集合必須具有一個無參數getenumerator方法，它返回一個enumertor（枚舉器）。一般情況下，枚舉器是很難實現的，但這個問題使用迭代器就大大地簡化了。
迭代器是一個產生值的有序序列的語句塊。迭代器不同于有一個或多個yield語句存在的常規語句塊。
yield return語句產生迭代的下一個值。
yield break語句指明迭代已經完成。
只要函數成員的返回類型是枚舉器接口（enumerator interface）或可枚舉接口（enumerable interface）之一，迭代器就可以被用作函數體。
枚舉器接口是system.collections.ienumerator和由sysetm.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[i];
}
}
}
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
foreach語句隱式地調用了集合的無參數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()p{…}
public ienumerator<t> getenumerator()
{
for(int i= count-1;i>=0;--i)
{
yield return items[i];
}
}
public ienumerable<t> topbottom{
get{
return this;
}
}
public ienumerable<t> bottomtotop{
get{
for(int i = 0;i<count;i++)
{
yield return items[i];
}
}
}
}
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);
for(int i in stack..toptobottom) console.write(“{0}”,i);
console.writeline();
for(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方法 ，它一個枚舉器接口。一個枚舉充當一個枚舉器工廠。每當調用了一個正確地實現了可枚舉接口的類的getenumerator方法時，都會產生一個獨立的枚舉器。假定枚舉的內部狀態在兩次調用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.writeline(“{0,3}”,x*y);
}
console.writeline();
}
}
}
先前的代碼打印了整數1到10 的乘法表。注意，fromto方法只被調用了一次用來產生枚舉e。然而，e.getenumerator()被調用了多次（通過foreach語句），以產生多個等價的枚舉器。這些枚舉器都封裝了在fromto聲明中指定的迭代器代碼。注意迭代器代碼修改了from參數。
不過，枚舉器是獨立地運作的，因為每個枚舉器都給出 from 和to它自己的拷貝。枚舉器之間過渡狀態的共享是眾多細微的瑕疵之一，當實現枚舉和枚舉器時應該避免。c#迭代器的設計可用于避免這些問題，從而以一種簡單直觀地方式實現健壯的枚舉和枚舉器。
