C# 2.0 Specification(二)

19.1.5泛型方法

在某些情形下，类型参数对于整个类不是必需的，而只对特定方法内是必需的。经常，当创建一个接受泛型类型作为参数的方法时就是这样。例如，当使用早先描述的Stack8742468051c85b06f0a0af9e3e506b5c类时，

一个通用的模式可能是在一行中压入多个值，在一个单一的调用中写一个方法这么做也是很方便的。对于特定的构造类型，例如Stackbd43222e33876353aff11e13a7dc75f6，这个方法看起来像这样。

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);

然而，先前的方法只对于特定的构造类型Stackbd43222e33876353aff11e13a7dc75f6有效。要让它对于Stack8742468051c85b06f0a0af9e3e506b5c也起作用，方法必须被作为泛型方法而编写。泛型方法在方法的名字后面在“e84aacd5f768f485facc4bd6b8750f46”分界符之间

指定了一个或多个类型参数。类型参数可以在参数列表，返回类型和方法体之内被使用。一个泛型的PushMultiple方法将会是这样。

void PushMultiple<T>(Stack<>T stack , params T[] values)
{
foreach(T value in values) stack.Push(value);
}

使用这个泛型方法，你可以压入多个项到任意Stack8742468051c85b06f0a0af9e3e506b5c中。当调用一个泛型方法时，类型参数值在方法调用的尖括号中被给定。例如

Stack<int> stack = new Stack<int>();
PushMultiple<int>(stack , 1,2,3,4);

这个泛型PushMultiple方法比先前的版本更具有重用性，因为它可以工作在任何Stack8742468051c85b06f0a0af9e3e506b5c上，但似乎在调用的时候不太方便，因为必须提供T作为一个类型参数传递给方法。在许多情形下，编译器使用一种称为类型推断（type inferencing）处理，从传递给方法的其他参数推断正确的类型参数。在先前的例子中，因为第一个正式参数是Stackbd43222e33876353aff11e13a7dc75f6类型，而后续的参数是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）[/b]。通常，局部变量的生存期被限制在它所关联的块或语句的执行区。然而，被捕获的外部变量将一直存活到委托所引用的匿名方法可以被垃圾回收为止。

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.IEnumerator8742468051c85b06f0a0af9e3e506b5c所构造的类型。 
可枚举接口是System.Collections.IEnumerable和由System.Collections.Generic.IEnumerable8742468051c85b06f0a0af9e3e506b5c构造的类型。


迭代器不是一种成员，它只是实现一个函数成员的方式，理解这点是很重要的。一个通过迭代器被实现的成员，可以被其他可能或不可能通过迭代器而被实现的成员覆盖和重载。

下面的Stack8742468051c85b06f0a0af9e3e506b5c类使用迭代器实现了它的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方法的存在使得Stack8742468051c85b06f0a0af9e3e506b5c成为一个可枚举类型，它使得Stack8742468051c85b06f0a0af9e3e506b5c的实例可被用在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方法，但经常有多种枚举方式，以及通过参数控制枚举的方法。在这种情况下，集合可以使用迭代器实现返回可枚举接口之一的属性和方法。例如，Stack8742468051c85b06f0a0af9e3e506b5c可能引入两个IEnumerable8742468051c85b06f0a0af9e3e506b5c类型的新属性，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#迭代器的设计可用于避免这些问题，从而以一种简单直观地方式实现健壮的枚举和枚举器。

以上就是C# 2.0 Specification(二)的内容，更多相关内容请关注PHP中文网（www.php.cn）！