第一章 C#2.0简介
第一章 C#2.0简介
C# 2.0引入了很多语言扩展，最重要的就是泛型（Generics）、匿名方法（Anonymous Methods）、迭代器
（Iterators）和不完全类型（Partial Types）。
● 泛型允许类、结构、接口、委托和方法通过它们所存贮和操作的数据的类型来参数化。泛型是很有
用的，因为它提供了更为强大的编译期间类型检查，需要更少的数据类型之间的显式转换，并且减少了
对装箱操作的需要和运行时的类型检查。
● 匿名方法允许在需要委托值时能够以“内联（in-line）”的方式书写代码块。匿名方法与Lisp语言
中的拉姆达函数（lambda functions）类似。
● 迭代器是能够增量地计算和产生一系列值得方法。迭代器使得一个类能够很容易地解释foreach语句
将如何迭代他的每一个元素。
● 不完全类型允许类、结构和接口被分成多个小块儿并存贮在不同的源文件中使其容易开发和维护。
另外，不完全类型可以分离机器产生的代码和用户书写的部分，这使得用工具来加强产生的代码变得容
易。
这一章首先对这些新特性做一个简介。简介之后有四章，提供了这些特性的完整的技术规范。
C# 2.0中的语言扩展的设计可以保证和现有代码的高度的兼容性。例如，尽管C#2.0在特定的环境中对
单词where、yield和partial赋予了特殊的意义，这些单词还是可以被用作标识符。确实，C# 2.0没有增加一
个会和现有代码中的标识符冲突的关键字。
1.1 泛型
泛型允许类、结构、接口、委托和方法通过它们所存贮和操作的数据的类型来参数化。C#泛型对使
用Eiffel或Ada语言泛型的用户和使用C++模板的用户来说相当亲切，尽管它们也许无法忍受后者的复杂
性。
1.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值时，必
file:///E|/mybook/C#2.0/C#2.0新特性/1.htm（第 1／11 页）2005-9-21 10:24:13
第一章 C#2.0简介
须显式的类型转换进行拆箱：
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类无疑会从具有限定其元素类型的能力中获益。使用泛型，这将成为可能。
1.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>
{
file:///E|/mybook/C#2.0/C#2.0新特性/1.htm（第 2／11 页）2005-9-21 10:24:13
第一章 C#2.0简介
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"];
1.1.3 泛型类型实例化
和非泛型类型类似，编译过的泛型类型也由中间语言（IL, Intermediate Language）指令和元数据表
示。泛型类型的IL表示当然已由类型参数进行了编码。
当程序第一次建立一个已构造的泛型类型的实例时，如Stack<int>，.NET公共语言运行时中的即时编
译器（JIT, just-in-time）将泛型IL和元数据转换为本地代码，并在进程中用实际类型代替类型参数。后面
的对这个以构造的泛型类型的引用使用相同的本地代码。从泛型类型建立一个特定的构造类型的过程称
为泛型类型实例化（generic type instantiation）。
.NET公共语言运行时为每个由之类型实例化的泛型类型建立一个专门的拷贝，而所有的引用类型共
享一个单独的拷贝（因为，在本地代码级别上，引用知识具有相同表现的指针）。
1.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）列表。一个类型参数的约束指定了一个类型必须遵守的要求，使得这个类型参数能够作
file:///E|/mybook/C#2.0/C#2.0新特性/1.htm（第 3／11 页）2005-9-21 10:24:13
第一章 C#2.0简介
为一个变量来使用。约束由关键字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方法从来没被实际调用过。
1.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>();
file:///E|/mybook/C#2.0/C#2.0新特性/1.htm（第 4／11 页）2005-9-21 10:24:13
评论0