荔园在线
荔园之美，在春之萌芽，在夏之绽放，在秋之收获，在冬之沉淀
[回到开始]
[上一篇][下一篇]
发信人: Version (Vampire&Yukon&Whidbey&Scorpio), 信区: DotNET
标 题: C#程序设计语言Version2.0简介(zt)
发信站: 荔园晨风BBS站 (Thu Jan 29 14:08:00 2004), 站内信件
C#程序设计语言Version2.0简介
[翻译] lover_P 2004-01-26
------------------------------------------------------------------------
--------
------------------------------------------------------------------------
----
本文翻译自Microsoft官方参考材料，提供给我们的计算机科学技术网的网友相互
学习，任
何人不得用于商业用途，转载请注明出处。
------------------------------------------------------------------------
----
C# 2.0引入了很多语言扩展，最重要的就是泛型（Generics）、匿名方法（
Anonymous
Methods）、迭代器（Iterators）和不完全类型（Partial Types）。
? 泛型允许类、结构、接口、委托和方法通过它们所存贮和操作的数据的类型来参
数化。泛
型是很有用的，因为它提供了更为强大的编译期间类型检查，需要更少的数据类型
之间的显
式转换，并且减少了对装箱操作的需要和运行时的类型检查。
? 匿名方法允许在需要委托值时能够以“内联（in-line）”的方式书写代码块。
匿名方法
与Lisp语言中的拉姆达函数（lambda functions）类似。
? 迭代器是能够增量地计算和产生一系列值得方法。迭代器使得一个类能够很容易
地解释fo
reach语句将如何迭代他的每一个元素。
? 不完全类型允许类、结构和接口被分成多个小块儿并存贮在不同的源文件中使其
容易开发
和维护。另外，不完全类型可以分离机器产生的代码和用户书写的部分，这使得用
工具来加
强产生的代码变得容易。
这一章首先对这些新特性做一个简介。简介之后有四章，提供了这些特性的完
整的技术
规范。
C# 2.0中的语言扩展的设计可以保证和现有代码的高度的兼容性。例如，尽管
C#2.0在特
定的环境中对单词where、yield和partial赋予了特殊的意义，这些单词还是可以
被用作标
识符。确实，C# 2.0没有增加一个会和现有代码中的标识符冲突的关键字。
19.1 泛型
泛型允许类、结构、接口、委托和方法通过它们所存贮和操作的数据的类型来
参数化。
C#泛型对使用Eiffel或Ada语言泛型的用户和使用C++模板的用户来说相当亲切，尽
管它们也
许无法忍受后者的复杂性。
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类的一种不正确的用法，但这段代码从技术上来说是
正确的，
并且不会发生编译期间错误。为题知道这段代码运行的时候才会出现，这时会抛出
一个Inva
lidCastException异常。
Stack类无疑会从具有限定其元素类型的能力中获益。使用泛型，这将成为可
能。
19.1.2 建立和使用泛型
泛型提供了一个技巧来建立带有类型参数（type parameters）的类型。下面
的例子声
明了一个带有类型参数T的泛型Stack类。类型参数又类名字后面的定界符“<”和
“>”指定
。通过某种类型建立的Stack的实例 可以无欲转换地接受该种类型的数据，这强过
于与obje
ct相互装换。类型参数T扮演一个占位符的角色，直到使用时指定了一个实际的类
型。注意
T相当于内部数组的数据类型、Push方法接受的参数类型和Pop方法的返回值类型：
public class Stack
{
T[] items;
int count;
public void Push(T item) {...}
public T Pop() {...}
}
使用泛型类Stack时，需要指定实际的类型来替代T。下面的例子中，指定int
作为参数
类型T：
Stack stack = new Stack();
stack.Push(3);
int x = stack.Pop();
Stack类型称为已构造类型（constructed type）。在Stack类型中出现的所有
T被替换
为类型参数int。当一个Stack的实例被创建时，items数组的本地存贮是int[]而不
是object
[]，这提供了一个实质的存贮，效率要高过非泛型的Stack。同样，Stack中的
Push和Pop方
法只操作int值，如果向堆栈中压入其他类型的值将会得到编译期间的错误，而且
取回一个
值时不必将它显示转换为原类型。
泛型可以提供强类型，这意味着例如向一个Customer对象的堆栈上压入一个
int将会产
生错误。这是因为Stack只能操作int值，而Stack也只能操作Customer对象。下面
例子中的
最后两行会导致编译器报错：
Stack stack = new Stack();
stack.Push(new Customer());
Customer c = stack.Pop();
stack.Push(3); // 类型不匹配错误
int x = stack.Pop(); // 类型不匹配错误
泛型类型的声明允许任意数目的类型参数。上面的Stack例子只有一个类型参
数，但一
个泛型的Dictionary类可能有两个类型参数，一个是键的类型另一个是值的类型：
public class Dictionary
{
public void Add(K key, V value) {...}
public V this[K key] {...}
}
使用Dictionary时，需要提供两个类型参数：
Dictionary dict = new Dictionary();
dict.Add("Peter", new Customer());
Customer c = dict["Peter">;
19.1.3 泛型类型实例化
和非泛型类型类似，编译过的泛型类型也由中间语言（IL, Intermediate
Language）
指令和元数据表示。泛型类型的IL表示当然已由类型参数进行了编码。
当程序第一次建立一个已构造的泛型类型的实例时，如Stack，.NET公共语言
运行时中
的即时编译器（JIT, just-in-time）将泛型IL和元数据转换为本地代码，并在进
程中用实
际类型代替类型参数。后面的对这个以构造的泛型类型的引用使用相同的本地代码
。从泛型
类型建立一个特定的构造类型的过程称为泛型类型实例化（generic type
instantiation）
。
.NET公共语言运行时为每个由之类型实例化的泛型类型建立一个专门的拷贝
，而所有
的引用类型共享一个单独的拷贝（因为，在本地代码级别上，引用知识具有相同表
现的指针
）。
19.1.4 约束
通常，一个泛型类不会只是存贮基于某一类型参数的数据，他还会调用给定类
型的对象
的方法。例如，Dictionary中的Add方法可能需要使用CompareTo方法来比较键值：
public class Dictionary
{
public void Add(K key, V value)
{
...
if (key.CompareTo(x) < 0) {...} // 错误，没有CompareTo方法
...
}
}
由于指定的类型参数K可以是任何类型，可以假定存在的参数key具有的成员只
有来自ob
ject的成员，如Equals、GetHashCode和ToString；因此上面的例子会发生编译错
误。当然
可以将参数key转换成为一具有CompareTo方法的类型。例如，参数key可以转换为
IComparab
le：
public class Dictionary
{
public void Add(K key, V value)
{
...
if (((IComparable)key).CompareTo(x) < 0) {...}
...
}
}
当这种方案工作时，会在运行时引起动态类型转换，会增加开销。更要命的是
，它还可
能将错误报告推迟到运行时。如果一个键没有实现IComparable接口，会抛出
InvalidCastEx
ception异常。
为了提供更强大的编译期间类型检查和减少类型转换，C#允许一个可选的为每
个类型参
数提供的约束（constraints）列表。一个类型参数的约束指定了一个类型必须遵
守的要求
，使得这个类型参数能够作为一个变量来使用。约束由关键字where来声明，后跟
类型参数
的名字，再后是一个类或接口类型的列表，或构造器约束new()。
要想使Dictionary类能保证键值始终实现了IComparable接口，类的声明中应
该对类型
参数K指定一个约束：
public class Dictionary 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
where K: IComparable, IPersistable
where E: Entity, new()
{
public void Add(K key, E entity)
{
...
if (key.CompareTo(x) < 0) {...}
...
}
}
上面例子中的构造器约束，new()，保证了作为的E类型变量的类型具有一个公
共、无参
的构造器，并允许泛型类使用new E()来建立该类型的一个实例。
类型参数约束的使用要小心。尽管它们提供了更强大的编译期间类型检查并在
一些情况
下改进了性能，它还是限制了泛型类型的使用。例如，一个泛型类List可能约束T
实现IComp
arable接口以便Sort方法能够比较其中的元素。然而，这么做使List不能用于那些
没有实现
IComparable接口的类型，尽管在这种情况下Sort方法从来没被实际调用过。
19.1.5 泛型方法
有的时候一个类型参数并不是整个类所必需的，而只用于一个特定的方法中。
通常，这
种情况发生在建立一个需要一个泛型类型作为参数的方法时。例如，在使用前面描
述过的St
ack类时，一种公共的模式就是在一行中压入多个值，如果写一个方法通过单独调
用它类完
成这一工作会很方便。对于一个特定的构造过的类型，如Stack，这个方法看起来
会是这样
：
void PushMultiple(Stack stack, params int[] values) {
foreach (int value in values) stack.Push(value);
}
这个方法可以用于将多个int值压入一个Stack：
Stack stack = new Stack();
PushMultiple(stack, 1, 2, 3, 4);
然而，上面的方法只能工作于特定的构造过的类型Stack。要想使他工作于任
何Stack，
这个方法必须写成泛型方法（generic method）。一个泛型方法有一个或多个类型
参数，有
方法名后面的“<”和“>”限定符指定。这个类型参数可以用在参数列表、返回至
和方法体
中。一个泛型的PushMultiple方法看起来会是这样：
void PushMultiple(Stack stack, params T[] values) {
foreach (T value in values) stack.Push(value);
}
使用这个方法，可以将多个元素压入任何Stack中。当调用一个泛型方法时，要
在函数的
调用中将类型参数放入尖括号中。例如：
Stack stack = new Stack();
PushMultiple(stack, 1, 2, 3, 4);
这个泛型的PushMultiple方法比上面的版本更具可重用性，因为它能工作于任
何Stack
，但这看起来并不舒服，因为必须为T提供一个类型参数。然而，很多时候编译器
可以通过
传递给方法的其他参数来推断出正确的类型参数，这个过程称为类型推断（type
inferenci
ng）。在上面的例子中，由于第一个正式的参数的类型是Stack，并且后面的参数
类型都是i
nt，编译器可以认定类型参数一定是int。因此，在调用泛型的PushMultiple方法
时可以不
用提供类型参数：
Stack stack = new Stack();
PushMultiple(stack, 1, 2, 3, 4);
19.2 匿名方法
实践处理方法和其他回调方法通常需要通过专门的委托来调用，而不是直接调
用。因此
，迄今为止我们还只能将一个实践处理和回调的代码放在一个具体的方法中，再为
其显式地
建立委托。相反，匿名方法（anonymous methods）允许将与一个委托关联的代码
“内联（i
n-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）”。匿名方法被
作为一个F
unction委托类型传递。
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[]元素并返回double[]作为结果的
Function。在
Main方法中，传递给Apply方法的第二个参数是一个匿名方法，它与Function委托
类型是兼
容的。这个匿名方法只简单地返回每个元素的平方值，因此调用Apply方法得到的
double[]
包含了a中每个值的平方值。
MultiplyAllBy方法通过将参数数组中的每一个值乘以一个给定的factor来建
立一个do
uble[]并返回。为了产生这个结果，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构造的类型。
? 所谓可枚举接口是指System.Collections.IEnumerable和从System.
Collections.Generic
.IEnumerable构造的类型。
理解迭代器并不是一种成员，而是实现一个功能成员是很重要的。一个通过迭
代器实现
的成员可以用一个或使用或不使用迭代器的成员覆盖或重写。
下面的Stack类使用迭代器实现了它的GetEnumerator方法。其中的迭代器按照
从顶端到
底端的顺序枚举了栈中的元素。
using System.Collections.Generic;
public class Stack: IEnumerable
{
T[] items;
int count;
public void Push(T data) {...}
public T Pop() {...}
public IEnumerator GetEnumerator() {
for (int i = count – 1; i >= 0; --i) {
yield return items[i];
}
}
}
GetEnumerator方法的出现使得Stack成为一个可枚举类型，这允许Stack的实
例使用for
each语句。下面的例子将值0至9压入一个整数堆栈，然后使用foreach循环按照从
顶端到底
端的顺序显示每一个值。
using System;
class Test
{
static void Main() {
Stack stack = new Stack();
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可以引入两个新的属性——IEnumerable类型的
TopToBotto
m和BottomToTop：
using System.Collections.Generic;
public class Stack: IEnumerable
{
T[] items;
int count;
public void Push(T data) {...}
public T Pop() {...}
public IEnumerator GetEnumerator() {
for (int i = count – 1; i >= 0; --i) {
yield return items[i];
}
}
public IEnumerable TopToBottom {
get {
return this;
}
}
public IEnumerable BottomToTop {
get {
for (int i = 0; i < count; i++) {
yield return items[i];
}
}
}
}
TopToBottom属性的get访问器只返回this，因为堆栈本身就是一个可枚举类型
。BottomT
oTop属性使用C#迭代器返回了一个可枚举接口。下面的例子显示了如何使用这两个
属性来以
任意顺序枚举栈中的元素：
using System;
class Test
{
static void Main() {
Stack stack = new Stack();
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 collection) {
foreach (int i in collection) Console.Write("{0} ",
i);
Console.WriteLine();
}
static IEnumerable FromToBy(int from, int to, int by) {
for (int i = from; i <= to; i += by) {
yield return i;
}
}
static void Main() {
Stack stack = new Stack();
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 FromTo(int from, int to) {
while (from <= to) yield return from++;
}
static void Main() {
IEnumerable 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 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 orders;
public Customer() {
...
}
public void SubmitOrder(Order order) {
orders.Add(order);
}
public bool HasOutstandingOrders() {
return orders.Count > 0;
}
}
不完全类型的所有部分必须放到一起编译，才能在编译期间将它们合并。需要
特别注意
的是，不完全类型并不允许扩展已编译的类型。
--
*
* *
* *
no more to say
★ just wish you ★
good luck
※ 来源:·荔园晨风BBS站 bbs.szu.edu.cn·[FROM: 192.168.1.50]
[回到开始]
[上一篇][下一篇]
荔园在线首页 友情链接：深圳大学 深大招生 荔园晨风BBS S-Term软件 网络书店