C#高级编程(共372页)

2024年3月28日发(作者：)

图 1-4

本章还讨论了IL的特性，特别是其强数据类型和面向对象的特性。探讨了这些

特性如何影响面向.NET的语言，包括C#，并阐述了IL的强类型本质如何支持语

言的互操作性，以及CLR服务，例如垃圾收集和安全性。

本章的最后讨论了C#如何用作基于几个.NET技术(包括)的应用程序的

基础。

第2章将介绍如何用C#语言编写代码。

第2章 C#基础

理解了C#的用途后，就可以学习如何使用它。本章将介绍C#编程的基础知识，

并假定您具备C#编程的基本知识，这是后续章节的基础。本章的主要内容如下：

●

声明变量

●

变量的初始化和作用域

●

C#的预定义数据类型

●

在C#程序中使用循环和条件语句指定执行流

●

枚举

●

命名空间

●

Main()方法

●

基本的命令行C#编译器选项

●

使用e执行控制台I/O

●

在C#和Visual Studio .NET中使用文档编制功能

●

C#标识符和关键字

●

C#编程的推荐规则和约定

阅读完本章后，您就有足够的C#知识编写简单的程序了，但还不能使用继承或

其他面向对象的特征。这些内容将在本书后面的几章中讨论。

2.1 引言

如前所述，C#是一种面向对象的语言。在快速浏览C#语句的基础时，我们假定

您已经很好地掌握了面向对象(OO)编程的概念。换言之，我们希望您懂得类、对

象、接口和继承的含义。如果以前使用过C++或Java，就应有很好的面向对象编

程(OOP)的基础。但是，如果您不具备OOP的背景知识，这个主题有许多很好的

信息资源。本书的附录A就详细介绍了OOP。附录A可以从上下

载。

如果您对VB6、C++或 Java中的一种语言有丰富的编程经验，就应注意在介绍C

#基础知识时，我们对C#、C++、Java和VB6进行了许多比较。但是，您也许愿

意阅读一本有关C#和自己所选语言的比较的图书，来学习C#。如果是这样，可

以从Wrox Press网站()上下载不同的文档来学习C#。

2.2 第一个C#程序

下面采用传统的方式，看看一个最简单的C#程序——这是一个把信息写到屏幕上

的控制台应用程序。

2.2.1 代码

在文本编辑器(例如Notepad)中键入下面的代码，把它保存为.cs文件(例如Fir

)：

using System;

namespace

{

class MyFirstCSharpClass

{

static void Main()

{

ine("This isn't at all like Java!");

ne();

return;

}

}

}

注意：

在后面的几章中，介绍了许多代码示例。编写C#程序最常用的技巧是使用Visual Stud

io 2005生成一个基本项目，再把自己的代码添加进去。但是，前面几章的目的是讲授C#

语言，并使过程尽可能简单，在第14章之前避免涉及Visual Studio 2005。我们使代码显示

为简单的文件，这样您就可以使用任何文本编辑器键入它们，并在命令行上对其进行编译。

2.2.2 编译并运行程序

对源文件运行C#命令行编译器()，编译这个程序：

csc

如果使用csc命令在命令行上编译代码，就应注意.NET命令行工具，包括csc，

只有在设置了某些环境变量后才能使用。根据安装.NET(和Visual Studio 2005)

的方式，这里显示的结果可能与您机器上的结果不同。

注意：

如果没有设置环境变量，有两种解决方法。第一种方法是在运行csc之前，在命令行上

运行批处理文件%Microsoft Visual Studio 2005%。其中%Micr

osoft Visual Studio 2005是安装Visual Studio 2005的文件夹。第二种方法(更简单)是使用

Visual Studio 2005命令行代替通常的命令提示窗口。Visual Studio 2005命令提示在“开始”

菜单—“程序”—Microsoft Visual Studio 2005－Microsoft Visual Studio Tools子菜单下。

它只是一个命令提示窗口，打开时会自动运行。

编译代码，会生成一个可执行文件。在命令行或Windows Explorer

上，象运行任何可执行文件那样运行该文件，得到如下结果：

csc

Microsoft (R) Visual C# .NET Compiler version 8.00.40607.16

for Microsoft (R) .NET Framework version 2.0.40607

Copyright (C) Microsoft Corporation 2001-2003. All rights reserved.

This isn't at all like Java!

这些信息也许不那么真实！这与Java有一些非常相似的地方，但有一两个地方

与Java或C++不同(如大写的Main函数)。下面通过这个程序快速介绍C#程序的

基本结构。

2.2.3 详细介绍

首先对C#语法作几个解释。在C#中，与其他C风格的语言一样，每个语句都必

须用一个分号(;)结尾，语句可以写在多个代码行上，不需要使用续行字符(例如

VB中的下划线)。用花括号({ ... })把语句组合为块。单行注释以两个斜杠字

符开头(//)，多行注释以一个斜杠和一个星号(/*)开头，以一个星号和一个斜杠

(*/)结尾。在这些方面，C#与C++和Java一样，但与VB不同。分号和花括号使

C#代码与VB代码有完全不同的外观。如果您以前使用的是VB，就应特别注意每

个语句结尾的分号。对于使用C风格语言的新用户，忽略分号常常是导致编译错

误的一个最主要的原因。

在上面的代码示例中，前几行代码是处理命名空间(如本章后面所述)，这是把相

关类组合在一起的方式。Java和C++开发人员应很熟悉这个概念，但对于VB6

开发人员来说是新概念。C#命名空间与C++命名空间或Java的包基本相同，但V

B6中没有对应的概念。namespace关键字声明了应与类相关的命名空间。其后花

括号中的所有代码都被认为是在这个命名空间中。编译器在using指令指定的命

名空间中查找没有在当前命名空间中定义、但在代码中引用的类。这非常类似于

Java中的import语句和C++中的using namespace语句。

using System;

namespace

{

在文件中使用using指令的原因是下面要使用一个库类

le。using System指令允许把这个类简写为Console(类似于System命名空间中

的其他类)。标准的System命名空间包含了最常用的.NET类型。我们用C#做的

所有工作都依赖于.NET基类，认识到这一点是非常重要的；在本例中，我们使

用了System命名空间中的Console类，以写入控制台窗口。

注意：

几乎所有的C#程序都使用System命名空间中的类，所以假定本章所有的代码文件都包

含using System;语句。

C#没有用于输入和输出的内置关键字，而是完全依赖于.NET类。

接着，声明一个类，它表面上称为MyFirstClass。但是，因为该类位于Wrox.P

命名空间中，所以其完整的名称是.M

yFirstCSharpClass：

class MyFirstCSharpClass

{

与Java一样，所有的C#代码都必须包含在一个类中，C#中的类类似于Java和C

++中的类，大致相当于VB6子句的类模块。类的声明包括class关键字，其后是

类名和一对花括号。与类相关的所有代码都应放在这对花括号中。

下面声明方法Main()。每个C#可执行文件(例如控制台应用程序、Windows应用

程序和Windows服务)都必须有一个入口点—— Main方法(注意M大写)：

static void Main()

{

这个方法在程序启动时调用，类似于C++和Java中的main函数，或VB6模块中

的Sub Main。该方法要么不能有返回值void，要么返回一个整数(int)。C#方法

对应于C++ 和 Java中的方法(有时把C++中的方法称为成员函数)，它还对应于

VB的Function 或VB的Sub。这取决于方法是否有返回值(与VB不同，C#在函

数和子例程之间没有概念上的区别)。

注意，C#中的方法定义如下所示。

[modifiers] return_type MethodName([parameters])

{

// Method body. NB. This code block is pseudo-code

}

第一个方括号中的内容表示可选关键字。修饰符(modifiers)用于指定用户所定

义的方法的某些特性，例如可以在什么地方调用该方法。在本例中，有两个修饰

符public和static。修饰符public表示可以在任何地方访问该方法，所以可

以在类的外部调用。这与C++和Java中的public相同，与VB中的Public相同。

修饰符static表示方法不能在类的特定实例上执行，因此不必先实例化类再调

用。这是非常重要的，因为我们创建的是一个可执行文件，而不是类库。这与C

++和Java中的static关键字相同，但VB中没有对应的关键字(在VB中，Stat

ic关键字有不同的含义)。把返回类型设置为void，在本例中，不包含任何参数。

最后，看看代码语句。

ine("This isn't at all like Java!");

ne();

return;

在本例中，我们只调用了e类的WriteLine()方法，把一行文本

写到控制台窗口上。WriteLine()是一个静态方法，在调用之前不需要实例化Co

nsole对象。

ne()读取用户的输入，添加这行代码会让应用程序等待用户按下

回车键，之后退出应用程序。在Visual Studio 2005中，控制台窗口会消失。

然后调用return退出该方法(因为这是Main方法)。在方法的首部指定void，

因此没有返回值。Return语句等价于C++和Java中的return，也等价于VB中

的Exit Sub或Exit Function。

对C#基本语法有了大致的认识后，下面就要详细讨论C#的各个方面了。因为没

有变量是不可能编写出任何重要的程序的，所以首先介绍C#中的变量。

2.3 变量

在C#中声明变量使用下述语法：

datatype identifier;

例如：

int i;

该语句声明int变量i。编译器不会让我们使用这个变量，除非我们用一个值初

始化了该变量。但这个声明会在堆栈中给它分配4个字节，以保存其值。

声明i之后，就可以使用赋值运算符(=)给它分配一个值：

i = 10;

还可以在一行代码中声明变量，并初始化它的值：

int i = 10;

其语法与C++和Java语法相同，但与VB中声明变量的语法完全不同。如果用户

以前使用的是VB6，应记住C#不区分对象和简单的类型，所以不需要类似Set

的关键字，即使是要把变量指向一个对象，也不需要Set关键字。无论变量的数

据类型是什么，声明变量的C#语法都是相同的。

如果在一个语句中声明和初始化了多个变量，那么所有的变量都具有相同的数据

类型：

int x = 10, y =20; // x and y are both ints

要声明类型不同的变量，需要使用单独的语句。在多个变量的声明中，不能指定

不同的数据类型：

int x = 10;

bool y = true; // Creates a variable that stores true or false

int x = 10, bool y = true; // This won't compile!

注意上面例子中的//和其后的文本，它们是注释。//字符串告诉编译器，忽略其

后的文本。本章后面会详细讨论代码中的注释。

2.3.1 变量的初始化

变量的初始化是C#强调安全性的另一个例子。简单地说，C#编译器需要用某个

初始值对变量进行初始化，之后才能在操作中引用该变量。大多数现代编译器把

没有初始化标记为警告，但C#编译器把它当作错误来看待。这就可以防止我们

无意中从其他程序遗留下来的内存中获取垃圾值。

C#有两个方法可确保变量在使用前进行了初始化：

●

变量是类或结构中的字段，如果没有显式初始化，在默认状态下创建这些变量时，

其值就是0。

●

方法的局部变量必须在代码中显式初始化，之后才能在语句中使用它们的值。此

时，初始化不是在声明该变量时进行的，但编译器会通过方法检查所有可能的路

径，如果检测到局部变量在初始化之前就使用了它的值，就会产生错误。

C#的方法与C++的方法相反，在C++中，编译器让程序员确保变量在使用之前进

行了初始化，在VB中，所有的变量都会自动把其值设置为0。

例如，在C#中不能使用下面的语句：

public static int Main()

{

int d;

ine(d); // Can't do this! Need to initialize d before use

return 0;

}

注意在这段代码中，演示了如何定义Main()，使之返回一个int类型的数据，

而不是void。

在编译这些代码时，会得到下面的错误消息：

Use of unassigned local variable 'd'

同样的规则也适用于引用类型。考虑下面的语句：

Something objSomething;

在C++中，上面的代码会在堆栈中创建Something类的一个实例。在C#中，这行

代码仅会为Something对象创建一个引用，但这个引用还没有指向任何对象。对

该变量调用方法或属性会导致错误。

在C#中实例化一个引用对象需要使用new关键字。如上所述，创建一个引用，

使用new关键字把该引用指向存储在堆上的一个对象：

objSomething = new Something(); // This creates a Something on the heap

2.3.2 变量的作用域

变量的作用域是可以访问该变量的代码区域。一般情况下，确定作用域有以下规

则：

●

只要字段所属的类在某个作用域内，其字段(也称为成员变量)也在该作用域内(在

C++、Java和 VB中也是这样)。

●

局部变量存在于表示声明该变量的块语句或方法结束的封闭花括号之前的作用

域内。

●

在for、while或类似语句中声明的局部变量存在于该循环体内(C++程序员注意，

这与C++的ANSI标准相同。Microsoft C++编译器的早期版本不遵守该标准，但

在循环停止后这种变量仍存在)。

1. 局部变量的作用域冲突

大型程序在不同部分为不同的变量使用相同的变量名是很常见的。只要变量的作

用域是程序的不同部分，就不会有问题，也不会产生模糊性。但要注意，同名的

局部变量不能在同一作用域内声明两次，所以不能使用下面的代码：

int x = 20;

// some more code

int x = 30;

考虑下面的代码示例：

using System;

namespace

{

public class ScopeTest

{

public static int Main()

{

for (int i = 0; i < 10; i++)

{

ine(i);

} // i goes out of scope here

// We can declare a variable named i again, because

// there's no other variable with that name in scope

for (int i = 9; i >= 0; i--)

{

ine(i);

} // i goes out of scope here

return 0;

}

}

}

这段代码使用一个for循环打印出从0~9的数字，再打印从9~0的数字。重要的

是在同一个方法中，代码中的变量i声明了两次。可以这么做的原因是在两次声

明中，i都是在循环内部声明的，所以变量i对于循环来说是局部变量。

下面看看另一个例子：

public static int Main()

{

int j = 20;

for (int i = 0; i < 10; i++)

{

int j = 30; // Can't do this - j is still in scope

ine(j + i);

}

return 0;

}

如果试图编译它，就会产生如下错误：

(12,14): error CS0136: A local variable named 'j' cannot be declare

d in this scope because it would give a different meaning to 'j', which is already us

ed in a 'parent or current' scope to denote something else

其原因是：变量j是在for循环开始前定义的，在执行for循环时应处于其作用

域内，在Main方法结束执行后，变量j才超出作用域，第二个j(不合法)则在

循环的作用域内，该作用域嵌套在Main方法的作用域内。编译器无法区别这两

个变量，所以不允许声明第二个变量。这也是与C++不同的地方，在C++中，允

许隐藏变量。

2. 字段和局部变量的作用域冲突

在某些情况下，可以区分名称相同(尽管其完全限定的名称不同)、作用域相同的

两个标识符。此时编译器允许声明第二个变量。原因是C#在变量之间有一个基

本的区分，它把声明为类型级的变量看作是字段，而把在方法中声明的变量看作

局部变量。

考虑下面的代码：

using System;

namespace

{

class ScopeTest2

{

static int j = 20;

public static void Main()

{

int j = 30;

ine(j);

return;

}

}

}

即使在Main方法的作用域内声明了两个变量j，这段代码也会编译—— j被定义

在类级上，在该类删除前是不会超出作用域的(在本例中，当Main方法中断，程

序结束时，才会删除该类)。此时，在Main方法中声明的新变量j隐藏了同名的

类级变量，所以在运行这段代码时，会显示数字30。

但是，如果要引用类级变量，该怎么办？可以使用语法ame，在

对象的外部引用类的字段或结构。在上面的例子中，我们访问静态方法中的一个

静态字段(静态字段详见下一节)，所以不能使用类的实例，只能使用类本身的名

称：

…

public static void Main()

{

int j = 30;

ine(ScopeTest2.j);

}

...

如果要访问一个实例字段(该字段属于类的一个特定实例)，就需要使用this关

键字。this的作用与C++和Java中的this相同，与VB中的Me相同。

2.3.3 常量

在声明和初始化变量时，在变量的前面加上关键字const，就可以把该变量指定

为一个常量。顾名思义，常量是其值在使用过程中不会发生变化的变量：

const int a = 100; // This value cannot be changed

VB和C++开发人员会非常熟悉常量。但C++开发人员应注意，C#不支持C++常量

的所有细微的特性。在C++中，变量不仅可以声明为常量，而且根据声明，还可

以有常量指针，指向常量的变量指针、常量方法(不改变包含对象的内容)，方法

的常量参数等。这些细微的特性在C#中都删除了，只能把局部变量和字段声明

为常量。

常量具有如下特征：

●

常量必须在声明时初始化。指定了其值后，就不能再修改了。

●

常量的值必须能在编译时用于计算。因此，不能用从一个变量中提取的值来初始

化常量。如果需要这么做，应使用只读字段(详见第3章)。

●

常量总是静态的。但注意，不必(实际上，是不允许)在常量声明中包含修饰符st

atic。

在程序中使用常量至少有3个好处：

●

常量用易于理解的清楚的名称替代了含义不明确的数字或字符串，使程序

更易于阅读。

●

常量使程序更易于修改。例如，在C#程序中有一个SalesTax常量，该常量的值

为6%。如果以后销售税率发生变化，把新值赋给这个常量，就可以修改所有的税

款计算结果，而不必查找整个程序，修改税率为0.06的每个项。

●

常量更容易避免程序出现错误。如果要把另一个值赋给程序中的一个常量，而该

常量已经有了一个值，编译器就会报告错误。

2.4 预定义数据类型

前面介绍了如何声明变量和常量，下面要详细讨论C#中可用的数据类型。与其

他语言相比，C#对其可用的类型及其定义进行了过分的修饰。

2.4.1 值类型和引用类型

在开始介绍C#中的数据类型之前，理解C#把数据类型分为两种是非常重要的：

●

值类型

●

引用类型

下面几节将详细介绍值类型和引用类型的语法。从概念上看，其区别是值类型直

接存储其值，而引用类型存储对值的引用。与其他语言相比，C#中的值类型基本

上等价于VB或C++中的简单类型(整型、浮点型，但没有指针或引用)。引用类

型与VB中的引用类型相同，与C++中通过指针访问的类型类似。

这两种类型存储在内存的不同地方：值类型存储在堆栈中，而引用类型存储在托

管堆上。注意区分某个类型是值类型还是引用类型，因为这种存储位置的不同会

有不同的影响。例如，int是值类型，这表示下面的语句会在内存的两个地方存

储值20：

// i and j are both of type int

i = 20;

j = i;

但考虑下面的代码。这段代码假定已经定义了一个类Vector，Vector是一个引

用类型，它有一个int类型的成员变量Value：

Vector x, y

x = new Vector ();

= 30; // Value is a field defined in Vector class

y = x;

ine();

= 50;

ine();

要理解的重要一点是在执行这段代码后，只有一个Vector对象。x和y都指向

包含该对象的内存位置。因为x和y是引用类型的变量，声明这两个变量只是保

留了一个引用——而不会实例化给定类型的对象。这与在C++中声明指针和VB

中的对象引用是相同的——在C++和VB中，都不会创建对象。要创建对象，就

必须使用new关键字，如上所示。因为x和y引用同一个对象，所以对x的修改

会影响y，反之亦然。因此上面的代码会显示30和50。

注意：

C++开发人员应注意，这个语法类似于引用，而不是指针。我们使用.(句点)符号，而不

是->来访问对象成员。在语法上，C#引用看起来更类似于C++引用变量。但是，抛开表面

的语法，实际上它类似于C++指针。

如果变量是一个引用，就可以把其值设置为null，表示它不引用任何对象：

y = null;

这类似于Java中把引用设置为null，C++中把指针设置为NULL，或VB中把对象

引用设置为Nothing。如果将引用设置为null，显然就不可能对它调用任何非静

态的成员函数或字段，这么做会在运行时抛出一个异常。

在像C++这样的语言中，开发人员可以选择是直接访问某个给定的值，还是通过

指针来访问。VB的限制更多：COM对象是引用类型，简单类型总是值类型。C#

在这方面类似于VB：变量是值还是引用仅取决于其数据类型，所以，int总是值

类型。不能把int变量声明为引用(在第5章介绍装箱时，可以在类型为object

的引用中封装值类型)。

在C#中，基本数据类型如bool和long都是值类型。如果声明一个bool变量，

并给它赋予另一个bool变量的值，在内存中就会有两个bool值。如果以后修改

第一个bool变量的值，第二个bool变量的值也不会改变。这些类型是通过值来

复制的。

相反，大多数更复杂的C#数据类型，包括我们自己声明的类都是引用类型。它

们分配在堆中，其生存期可以跨多个函数调用，可以通过一个或几个别名来访问。

CLR执行一种精细的算法，来跟踪哪些引用变量仍是可以访问的，哪些引用变量

已经不能访问了。CLR会定期进行清理，删除不能访问的对象，把它们占用的内

存返回给操作系统。这是通过垃圾收集器实现的。

把基本类型(如int和bool)规定为值类型，而把包含许多字段的较大类型(通常

在有类的情况下)规定为引用类型，C#设计这种方式的原因是可以得到最佳性能。

如果要把自己的类型定义为值类型，就应把它声明为一个结构。

2.4.2 CTS类型

如第1章所述，C#认可的基本预定义类型并没有内置于语言中，而是内置于.NE

T Framework中。例如，在C#中声明一个int类型的数据时，声明的实际上是.

NET结构32的一个实例。这听起来似乎很深奥，但其意义深远：这

表示在语法上，可以把所有的基本数据类型看作是支持某些方法的类。例如，要

把int i转换为string，可以编写下面的代码：

string s = ng();

应强调的是，在这种便利语法的背后，类型实际上仍存储为基本类型。基本类型

在概念上用.NET结构表示，所以肯定没有性能损失。

下面看看C#中定义的类型。我们将列出每个类型，以及它们的定义和对应.NET

类型(CTS 类型)的名称。C#有15个预定义类型，其中13个是值类型，2个是引

用类型(string和object)。

2.4.3 预定义的值类型

内置的值类型表示基本数据类型，例如整型和浮点类型、字符类型和bool类型。

1. 整型

C#支持8个预定义整数类型，如表2-1所示。

表 2-1

名 称 CTS 类 型 说 明 范 围

sbyte

short

int

long

byte

ushort

uint

ulong

16

32

64

16

32

64

8位有符号的整数

16位有符号的整数

32位有符号的整数

64位有符号的整数

8位无符号的整数

16位无符号的整数

32位无符号的整数

64位无符号的整数

–128 到 127 (–2

7

到2

7

–1)

–32 768 到 32 767 (–2

15

到2

15

–1)

–2 147 483 648 到 2 147 483 647(–2

31

到2

31

–1)

–9 223 372 036 854 775 808到9 223 372 036 854

775 807(–2

63

到2

63

–1)

0到255(0到2

8

–1)

0到65535(0到2

16

–1)

0到4 294 967 295(0到2

32

–1)

0到18 446 744 073 709 551 615(0到2

64

–1)

Windows的将来版本将支持64位处理器，可以把更大的数据块移入移出内存，

获得更快的处理速度。因此，C#支持8至64位的有符号和无符号的整数。

当然，VB开发人员会发现有许多类型名称是新的。C++和Java开发人员应注意：

一些C#类型名称与C++和Java类型一致，但类型有不同的定义。例如，在C#中，

int总是32位带符号的整数，而在C++中，int是带符号的整数，但其位数取决

于平台(在Windows上是32位)。在C#中，所有的数据类型都以与平台无关的方

式定义，以备将来C#和.NET迁移到其他平台上。

byte是0~255(包括255)的标准8位类型。注意，在强调类型的安全性时，C#认

为byte类型和char类型完全不同，它们之间的编程转换必须显式写出。还要注

意，与整数中的其他类型不同，byte类型在默认状态下是无符号的，其有符号

的版本有一个特殊的名称sbyte。

在.NET中，short不再很短，现在它有16位，Int类型更长，有32位。 long

类型最长，有64位。所有整数类型的变量都能赋予10进制或16进制的值，后者

需要0x前缀：

long x = 0x12ab;

如果对一个整数是int、uint、long或是ulong没有任何显式的声明，则该变量

默认为int类型。为了把键入的值指定为其他整数类型，可以在数字后面加上如

下字符：

uint ui = 1234U;

long l = 1234L;

ulong ul = 1234UL;

也可以使用小写字母u和l，但后者会与整数1混淆。

2. 浮点类型

C#提供了许多整型数据类型，也支持浮点类型，如表2-2所示。C和C++程序员

很熟悉 它们。

表 2-2

名称

float

double

CTS类型

说 明

32位单精度浮点数

64位双精度浮点数

位 数

7

15/16

范围 (大致)

±1.5 × 10

-45

到 ±3.4 × 10

38

±5.0 × 10

-324

到 ±1.7 × 10

308

float数据类型用于较小的浮点数，因为它要求的精度较低。double数据类型比

float数据类型大，提供的精度也大一倍(15位)。

如果在代码中没有对某个非整数值(如12.3)硬编码，则编译器一般假定该变量

是double。如果想指定值为float，可以在其后加上字符F(或f)：

float f = 12.3F;

3. decimal类型

另外，decimal类型表示精度更高的浮点数，如表2-3所示。

表 2-3

名 称

decimal

CTS类型

System.

Decimal

说 明

128位高精度十

进制数表示法

位 数

28

范围(大致)

±1.0×10

-28

到±7.9 ×

10

28

CTS和C#一个重要的优点是提供了一种专用类型表示财务计算，这就是decimal

类型，使用decimal类型提供的28位的方式取决于用户。换言之，可以用较大

的精确度(带有美分)来表示较小的美元值，也可以在小数部分用更多的舍入来表

示较大的美元值。但应注意，decimal类型不是基本类型，所以在计算时使用该

类型会有性能损失。

要把数字指定为decimal类型，而不是double、 float或整型，可以在数字的

后面加上字符M(或m)，如下所示。

decimal d = 12.30M;

4. bool类型

C#的 bool 类型用于包含bool值true或false，如表2-4所示。

表 2-4

名 称

bool

CTS 类 型

n

值

true或false

bool值和整数值不能相互转换。如果变量(或函数的返回类型)声明为bool类型，

就只能使用值true或false。如果试图使用0表示false，非0值表示true，

就会出错。

5. 字符类型

为了保存单个字符的值，C#支持char数据类型，如表2-5所示。

表 2-5

名 称

char

CTS 类 型

值

表示一个16位的(Unicode)字符

虽然这个数据类型在表面上类似于C和C++中的char类型，但它们有重大区别。

C++的char表示一个8位字符，而C#的char包含16位。其部分原因是不允许

在char类型与8位byte类型之间进行隐式转换。

尽管8位足够编码英语中的每个字符和数字0~9了，但它们不够编码更大的符号

系统中的每个字符(例如中文)。为了面向全世界，计算机行业正在从8位字符集

转向16位的Unicode模式，ASCII编码是Unicode的一个子集。

char类型的字面量是用单引号括起来的，例如'A'。如果把字符放在双引号中，

编译器会把它看作是字符串，从而产生错误。

除了把char表示为字符字面量之外，还可以用4位16进制的Unicode值(例如'

u0041')，带有数据类型转换的整数值(例如(char)65)，或16进制数('x0041

')表示它们。它们还可以用转义序列表示，如表2-6所示。

表 2-6

转 义 序 列 字 符

'

"

0

a

b

f

n

r

t

v

单引号

双引号

反斜杠

空

警告

退格

换页

换行

回车

水平制表符

垂直制表符

C++开发人员应注意，因为C#本身有一个string类型，所以不需要把字符串表

示为char类型的数组。

2.4.4 预定义的引用类型

C#支持两个预定义的引用类型，如表2-7所示。

表 2-7

名 称

object

string

CTS 类

说 明

根类型，CTS中的其他类型都是从它派生而来的(包括值类型)

Unicode字符串

1. object类型

许多编程语言和类结构都提供了根类型，层次结构中的其他对象都从它派生而

来。C#和.NET也不例外。在C#中，object类型就是最终的父类型，所有内在和

用户定义的类型都从它派生而来。这是C#的一个重要特性，它把C#与VB和C+

+区分开来，但其行为与Java非常类似。所有的类型都隐含地最终派生于Syst

类，这样，object类型就可以用于两个目的：

●

可以使用object引用绑定任何子类型的对象。例如，第5章将说明如何使用obj

ect类型把堆栈中的一个值对象装箱，再移动到堆中。对象引用也可以用于反射，

此时必须有代码来处理类型未知的对象。这类似于C++中的void指针或VB中的

Variant数据类型。

●

object类型执行许多基本的一般用途的方法，包括Equals()、GetHashCode()、Ge

tType()和ToString()。用户定义的类需要使用一种面向对象技术—— 重写(见第4

章)，提供其中一些方法的替代执行代码。例如，重写ToString()时，要给类提供

一个方法，提供类本身的字符串表示。如果类中没有提供这些方法的实现代码，

编译器就会使用object类型中的实现代码，它们在类中的执行不一定正确。

后面的章节将详细讨论object类型。

2. string类型

有C和C++开发经验的人员可能在使用C风格的字符串时不太顺利。C或C++字

符串不过是一个字符数组，因此客户机程序员必须做许多工作，才能把一个字符

串复制到另一个字符串上，或者连接两个字符串。实际上，对于一般的C++程序

员来说，执行包装了这些操作细节的字符串类是一个非常头痛的耗时过程。VB

程序员的工作就比较简单，只需使用string类型即可。而Java程序员就更幸运

了，其String类在许多方面都类似于C#字符串。

C#有string关键字，在翻译为.NET类时，它就是。有了它，像

字符串连接和字符串复制这样的操作就很简单了：

string str1 = "Hello ";

string str2 = "World";

string str3 = str1 + str2; // string concatenation

尽管这是一个值类型的赋值，但string是一个引用类型。String对象保留在堆

上，而不是堆栈上。因此，当把一个字符串变量赋给另一个字符串时，会得到对

内存中同一个字符串的两个引用。但是，string与引用类型在常见的操作上有

一些区别。例如，修改其中一个字符串，就会创建一个全新的string对象，而

另一个字符串没有改变。考虑下面的代码：

using System;

class StringExample

{

public static int Main()

{

string s1 = "a string";

string s2 = s1;

ine("s1 is " + s1);

ine("s2 is " + s2);

s1 = "another string";

ine("s1 is now " + s1);

ine("s2 is now " + s2);

return 0;

}

}

其输出结果为：

s1 is a string

s2 is a string

s1 is now another string

s2 is now a string

换言之，改变s1的值对s2没有影响，这与我们期待的引用类型正好相反。当用

值"a string"初始化s1时，就在堆上分配了一个string对象。在初始化s2时，

引用也指向这个对象，所以s2的值也是"a string"。但是现在要改变s1的值，

而不是替换原来的值时，堆上就会为新值分配一个新对象。s2变量仍指向原来

的对象，所以它的值没有改变。这实际上是运算符重载的结果，运算符重载详见

第5章。基本上，string类实现为其语义遵循一般的、直观的字符串规则。

字符串字面量放在双引号中("...")；如果试图把字符串放在单引号中，编译器

就会把它当作char，从而引发错误。C#字符串和char一样，可以包含Unicode、

16进制数转义序列。因为这些转义序列以一个反斜杠开头，所以不能在字符串

中使用这个非转义的反斜杠字符。而需要用两个反斜杠字符()来表示它：

string filepath = "C:";

即使用户相信自己可以在任何情况下都记住要这么做，但键入两个反斜杠字符会

令人迷惑。幸好，C#提供了另一种替代方式。可以在字符串字面量的前面加上字

符@，在这个字符后的所有字符都看作是其原来的含义——它们不会解释为转义

字符：

string filepath = @"C:";

甚至允许在字符串字面量中包含换行符：

string jabberwocky = @"'Twas brillig and the slithy toves

Did gyre and gimble in the wabe.";

那么jabberwocky的值就是：

'Twas brillig and the slithy toves

Did gyre and gimble in the wabe.

2.5 流控制

本节将介绍C#语言的重要语句：控制程序流的语句，它们不是按代码在程序中的排列位置

顺序执行的。

2.5.1 条件语句

条件语句可以根据条件是否满足或根据表达式的值控制代码的执行分支。C#有两

个分支代码的结构：if语句，测试特定条件是否满足；switch语句，它比较表

达式和许多不同的值。

1. if语句

对于条件分支，C#继承了C和C++的if

...

else结构。对于用过程语言编程的人来

说，其语法是非常直观的：

if (condition)

statement(s)

else

statement(s)

如果在条件中要执行多个语句，就需要用花括号({

...

})把这些语句组合为一个

块。(这也适用于其他可以把语句组合为一个块的C#结构，例如for和while循

环)。

bool isZero;

if (i == 0)

{

isZero = true;

ine("i is Zero");

}

else

{

isZero = false;

ine("i is Non-zero");

}

其语法与C++和Java类似，但与VB不同。VB开发人员注意，C#中没有与VB的

EndIf对应的语句，其规则是if的每个子句都只包含一个语句。如果需要多个

语句，如上面的例子所示，就应把这些语句放在花括号中，这会把整组语句当作

一个语句块来处理。

还可以单独使用if语句，不加else语句。也可以合并else if子句，测试多个

条件。

using System;

namespace

{

class MainEntryPoint

{

static void Main(string[] args)

{

ine("Type in a string");

string input;

input = ne();

if (input == "")

{

ine("You typed in an empty string");

}

else if ( < 5)

{

ine("The string had less than 5 characters");

}

else if ( < 10)

{

ine("The string had at least 5 but less than 10

characters");

}

ine("The string was " + input);

}

}

}

添加到if子句中的else if语句的个数没有限制。

注意在上面的例子中，我们声明了一个字符串变量input，让用户在命令行上输

入文本，把文本填充到input中，然后测试该字符串变量的长度。代码还说明了

在C#中如何进行字符串处理。例如，要确定input的长度，可以使用

ngth。

对于if，要注意的一点是如果条件分支中只有一条语句，就无需使用花括号：

if (i == 0)

ine("i is Zero"); // This will only execute if i == 0

ine("i can be anything"); // Will execute whatever the

// value of i

但是，为了保持一致，许多程序员只要使用if语句，就使用花括号。

前面介绍的if语句还演示了比较值的一些C#运算符。特别注意，与C++和Java

一样，C#使用“==”对变量进行等于比较。此时不要使用“=”，“=”用于赋值。

在C#中，if子句中的表达式必须等于布尔值。C++程序员应特别注意这一点；与

C++不同，C#中的if语句不能直接测试整数(例如从函数中返回的值)，而必须明

确地把返回的整数转换为布尔值true 或 false，例如，比较值0和null：

if (DoSomething() != 0)

{

// Non-zero value returned

}

else

{

// Returned zero

}

这个限制用于防止C++中某些常见的运行错误，特别是在C++中，当应使用“==”

时，常常误输入“＝”，导致不希望的赋值。在C#中，这常常会导致一个编译

错误，因为除非在处理bool值，否则“＝”不会返回bool。

2. switch语句

switch…case语句适合于从一组互斥的分支中选择一个执行分支。C++和Java

程序员应很熟悉它，该语句类似于VB中的Select Case语句。

其形式是switch参数的后面跟一组case子句。如果switch参数中表达式的值

等于某个case子句旁边的某个值，就执行该case子句中的代码。此时不需要使

用花括号把语句组合到块中；只需使用break语句标记每个case代码的结尾即

可。也可以在switch语句中包含一个default子句，如果表达式不等于任何ca

se子句的值，就执行default子句的代码。下面的switch语句测试integerA

变量的值：

switch (integerA)

{

case 1:

ine("integerA =1");

break;

case 2:

ine("integerA =2");

break;

case 3:

ine("integerA =3");

break;

default:

ine("integerA is not 1,2, or 3");

break;

}

注意case的值必须是常量表达式——不允许使用变量。

C和C++程序员应很熟悉switch…case语句，而C#的switch…case语句更安全。

特别是它禁止所有case中的失败条件。如果激活了块中靠前的一个case子句，

后面的case子句就不会被激活，除非使用goto语句特别标记要激活后面的cas

e子句。编译器会把没有break语句的每个case子句标记为错误：

Control cannot fall through from one case label ('case 2:') to another

在有限的几种情况下，这种失败是允许的，但在大多数情况下，我们不希望出现这种失败，

而且这会导致出现很难察觉的逻辑错误。让代码正常工作，而不是出现异常，这样不是更好

吗？

但在使用goto语句时(C#支持)，会在switch…cases中重复出现失败。如果确

实想这么做，就应重新考虑设计方案了。下面的代码说明了如何使用goto模拟

失败，得到的代码会非常混乱：

// assume country and language are of type string

switch(country)

{

case "America":

CallAmericanOnlyMethod();

goto case "Britain";

case "France":

language = "French";

break;

case "Britain":

language = "English";

break;

}

但这有一种例外情况。如果一个case子句为空，就可以从这个case跳到下一个

case上，这样就可以用相同的方式处理两个或多个case子句了(不需要goto语

句)。

switch(country)

{

case "au":

case "uk":

case "us":

language = "English";

break;

case "at":

case "de":

language = "German";

break;

}

在C#中，switch语句的一个有趣的地方是case子句的排放顺序是无关紧要的，

甚至可以把default子句放在最前面！因此，任何两个case都不能相同。这包

括值相同的不同常量，所以不能这样编写：

// assume country is of type string

const string england = "uk";

const string britain = "uk";

switch(country)

{

case england:

case britain: // this will cause a compilation error

language = "English";

break;

}

上面的代码还说明了C#中的switch语句与C++中的switch语句的另一个不同之

处：在C#中，可以把字符串用作测试变量。

2.5.2 循环

C#提供了4种不同的循环机制(for、while、do...while和foreach)，在满足某

个条件之前，可以重复执行代码块。for、while和do...while循环与C++中的

对应循环相同。

1. for循环

C#的for循环提供的迭代循环机制是在执行下一次迭代前，测试是否满足某个条

件，其语法如下：

for (initializer; condition; iterator)

statement(s)

其中：

●

initializer是指在执行第一次迭代前要计算的表达式(通常把一个局部变量初始化

为循环计数器)；

●

condition是在每次迭代新循环前要测试的表达式(它必须等于true，才能执行

下一次迭代)；

●

iterator是每次迭代完要计算的表达式(通常是递增循环计数器)。当condition等于

false时，迭代停止。

for循环是所谓的预测试循环，因为循环条件是在执行循环语句前计算的，如果

循环条件为假，循环语句就根本不会执行。

for循环非常适合于一个语句或语句块重复执行预定的次数。下面的例子就是f

or循环的典型用法，这段代码输出从0~99的整数：

for (int i = 0; i < 100; i = i+1) // this is equivalent to

// For i = 0 To 99 in VB.

{

ine(i);

}

这里声明了一个int类型的变量i，并把它初始化为0，用作循环计数器。接着

测试它是否小于100。因为这个条件等于true，所以执行循环中的代码，显示值

0。然后给该计数器加1，再次执行该过程。当i等于100时，循环停止。

实际上，上述编写循环的方式并不常用。C#在给变量加1时有一种简化方式，即

不使用i = i+1，而简写为i++：

for (int i = 0; i < 100; i++)

{

//etc.

C#的for循环语法比VB中的For

…

Next循环的功能强大得多，因为迭代器可以是

任何语句。在VB中，只能对循环控制变量加减某个数字。在C#中，则可以做任

何事，例如，让循环控制变量乘以2。

嵌套的for循环非常常见，在每次迭代外部的循环时，内部循环都要彻底执行完

毕。这种模式通常用于在矩形多维数组中遍历每个元素。最外部的循环遍历每一

行，内部的循环遍历某行上的每个列。下面的代码显示数字行，它还使用另一个

Console方法()，该方法的作用与ine()相同，

但不在输出中添加回车换行符：

using System;

namespace

{

class MainEntryPoint

{

static void Main(string[ ] args)

{

// This loop iterates

for (int i = 0; i < 100; i+=10)

{

// This loop iterates

for (int j = i; j < i + 10; j++)

{

(" " + j);

}

ine();

}

}

}

}

尽管j是一个整数，但它会自动转换为字符串，以便进行连接。C++开发人员要

注意，这比在C++中处理字符串容易得多，VB开发人员则已经习惯于此了。

C程序员应注意上述例子中的一个特殊功能。在每次迭代后续的外部循环时，最

内部循环的计数器变量都要重新声明。这种语法不仅在C#中可行，在C++中也是

合法的。

上述例子的结果是：

csc

Microsoft (R) Visual C# .NET Compiler version 8.00.40607.16

for Microsoft (R) .NET Framework version 2.0.40607

Copyright (C) Microsoft Corporation 2001-2003. All rights reserved.

0 1 2 3 4 5 6 7 8 9

10 11 12 13 14 15 16 17 18 19

20 21 22 23 24 25 26 27 28 29

30 31 32 33 34 35 36 37 38 39

40 41 42 43 44 45 46 47 48 49

50 51 52 53 54 55 56 57 58 59

60 61 62 63 64 65 66 67 68 69

70 71 72 73 74 75 76 77 78 79

80 81 82 83 84 85 86 87 88 89

90 91 92 93 94 95 96 97 98 99

尽管在技术上，可以在for循环的测试条件中计算其他变量，而不计算计数器变

量，但这不太常见。也可以在for循环中忽略一个表达式(甚或所有表达式)。但

此时，要考虑使用while循环。

2. while循环

while循环与C++和Java中的while循环相同，与VB中的Wend循环相

同。与for循环一样，while也是一个预测试的循环。其语法是类似的，但whi

le循环只有一个表达式：

while(condition)

statement(s);

与for循环不同的是，while循环最常用于下述情况：在循环开始前，不知道重

复执行一个语句或语句块的次数。通常，在某次迭代中，while循环体中的语句

把布尔标记设置为false，结束循环，如下面的例子所示。

bool condition = false;

while (!condition)

{

// This loop spins until the condition is true

DoSomeWork();

condition = CheckCondition(); // assume CheckCondition() returns a bool

}

所有的C#循环机制，包括while循环，如果只重复执行一条语句，而不是一个

语句块，都可以省略花括号。许多程序员都认为最好在任何情况下都加上花括号。

3. do…while循环

do...while循环是while循环的后测试版本。它与C++和Java中的do...while

循环相同，与VB中的While循环相同，该循环的测试条件要在执行完循

环体之后执行。因此do...while循环适合于至少执行一次循环体的情况：

bool condition;

do

{

// this loop will at least execute once, even if Condition is false

MustBeCalledAtLeastOnce();

condition = CheckCondition();

} while (condition);

4. foreach循环

foreach循环是我们讨论的最后一种C#循环机制。其他循环机制都是C和C++的

最早期版本，而foreach语句是新增的循环机制(借用于VB)，也是非常受欢迎

的一种循环。

foreach循环可以迭代集合中的每一项。现在不必考虑集合的概念，第9章将介

绍集合。知道集合是一种包含其他对象的对象即可。从技术上看，要使用集合对

象，它必须支持IEnumerable接口。集合的例子有C#数组、tion

命名空间中的集合类，以及用户定义的集合类。从下面的代码中可以了解forea

ch循环的语法，其中假定arrayOfInts是一个整型数组：

foreach (int temp in arrayOfInts)

{

ine(temp);

}

其中，foreach循环每次迭代数组中的一个元素。它把每个元素的值放在int型

的变量temp中，然后执行一次循环迭代。

注意，不能改变集合中各项(上面的temp)的值，所以下面的代码不会编译：

foreach (int temp in arrayOfInts)

{

temp++;

ine(temp);

}

如果需要迭代集合中的各项，并改变它们的值，就应使用for循环。

2.5.3 跳转语句

C#提供了许多可以立即跳转到程序中另一行代码的语句，在此，先介绍goto语

句。

1. goto语句

goto语句可以直接跳转到程序中用标签指定的另一行(标签是一个标识符，后跟

一个冒号)：

goto Label1;

ine("This won't be executed");

Label1:

ine("Continuing execution from here");

goto语句有两个限制。不能跳转到像for循环这样的代码块中，也不能跳出类

的范围，不能退出atch块后面的finally块(第12章将介绍如何用

finally块处理异常)。

goto语句的名声不太好，在大多数情况下不允许使用它。一般情况下，使用它

肯定不是面向对象编程的好方式。但是有一个地方使用它是相当方便的——在s

witch语句的case子句之间跳转，这是因为C#的switch语句在故障处理方面非

常严格。前面介绍了其语法。

2. break语句

前面简要提到过break语句——在switch语句中使用它退出某个case语句。实

际上，break也可以用于退出for、foreach、while或do...while循环，循环

结束后，就执行循环后面的语句。

如果该语句放在嵌套的循环中，就执行最内部循环后面的语句。如果break放在

switch语句或循环外部，就会产生编译时错误。

3. continue语句

continue语句类似于break，也必须在for、foreach、while或 do...while循

环中使用。但它只从循环的当前迭代中退出，然后在循环的下一次迭代开始重新

执行，而不是退出循环。

4. return语句

return语句用于退出类的方法，把控制返回方法的调用者，如果方法有返回类

型，return语句必须返回这个类型的值，如果方法没有返回类型，应使用没有

表达式的return语句。

2.6 枚举

枚举是用户定义的整数类型。在声明一个枚举时，要指定该枚举可以包含的一组

可接受的实例值。不仅如此，还可以给值指定易于记忆的名称。如果在代码的某

个地方，要试图把一个不在可接受范围内的值赋予枚举的一个实例，编译器就会

报告一个错误。这个概念对于VB程序员来说是新的。C++支持枚举，但C#枚举

要比C++枚举强大得多。

从长远来看，创建枚举可以节省大量的时间，减少许多麻烦。使用枚举比使用无

格式的整数至少有如下三个优势：

●

如上所述，枚举可以使代码更易于维护，有助于确保给变量指定合法的、期望的

值。

●

枚举使代码更清晰，允许用描述性的名称表示整数值，而不是用含义模糊的数来

表示。

●

枚举使代码更易于键入。在给枚举类型的实例赋值时，VS .NET IDE会通过Int

elliSense弹出一个包含可接受值的列表框，减少了按键次数，并能够让我们回忆

起可选的值。

定义如下的枚举：

public enum TimeOfDay

{

Morning = 0,

Afternoon = 1,

Evening = 2

}

在本例中，在枚举中使用一个整数值，来表示一天的每个阶段。现在可以把这些

值作为枚举的成员来访问。例如，g返回数字0。使用这个枚

举一般是把合适的值传送给方法，在switch语句中迭代可能的值。

class EnumExample

{

public static int Main()

{

WriteGreeting(g);

return 0;

}

static void WriteGreeting(TimeOfDay timeOfDay)

{

switch(timeOfDay)

{

case g:

ine("Good morning!");

break;

case oon:

ine("Good afternoon!");

break;

case g:

ine("Good evening!");

break;

default:

ine("Hello!");

break;

}

}

}

在C#中，枚举的真正强大之处是它们在后台会实例化为派生于基类

m的结构。这表示可以对它们调用方法，执行有用的任务。注意因为.NET Frame

work的执行方式，在语法上把枚举当做结构是不会有性能损失的。实际上，一

旦代码编译好，枚举就成为基本类型，与int和float类似。

可以获取枚举的字符串表示，例如使用前面的TimeOfDay枚举：

TimeOfDay time = oon;

ine(ng());

会返回字符串Afternoon。

另外，还可以从字符串中获取枚举值：

TimeOfDay time2 = (TimeOfDay) (typeof(TimeOfDay), "afternoon", t

rue);

ine((int)time2);

这段代码说明了如何从字符串获取枚举值，并转换为整数。要从字符串中转换，

需要使用静态的()方法，这个方法带3个参数，第一个参数是要使

用的枚举类型。其句法是关键字typeof后跟放在括号中的枚举类名。typeof运

算符将在第5章详细论述。第二个参数是要转换的字符串，第三个参数是一个b

ool，指定在进行转换时是否忽略大小写。最后，注意()方法实际上

返回一个对象引用—— 我们需要把这个字符串显式转换为需要的枚举类型(这是

一个拆箱操作的例子)。对于上面的代码，将返回1，作为一个对象，对应于Ti

meOfDay. Afternoon的枚举值。在显式转换为int时，会再次生成1。

上的其他方法可以返回枚举定义中的值的个数、列出值的名称等。

详细信息参见MSDN文档。

2.7 数组

本章不打算详细介绍数组，因为第9章将详细论述数组和集合。但本章将介绍编

写一维数组的句法。在声明C#中的数组时，要在各个元素的变量类型后面，加

上一组方括号(注意数组中的所有元素必须有相同的数据类型)。

提示：

VB用户注意，C#中的数组使用方括号，而不是圆括号。C++用户很熟悉方括号，但应

仔细查看这里给出的代码，因为声明数组变量的C#语法与C++语法并不相同。

例如，int表示一个整数，而int[]表示一个整型数组：

int[] integers;

要初始化特定大小的数组，可以使用new关键字，在类型名后面的方括号中给出

大小：

// Create a new array of 32 ints

int[] integers = new int[32];

所有的数组都是引用类型，并遵循引用的语义。因此，即使各个元素都是基本的

值类型，integers数组也是引用类型。如果以后编写如下代码：

int[] copy = integers;

该代码也只是把变量copy指向同一个数组，而不是创建一个新数组。

要访问数组中的单个元素，可以使用通常的语法，在数组名的后面，把元素的下

标放在方括号中。所有的C#数组都使用基于0的下标方式，所以要用下标0引

用第一个变量：

integers[0] = 35;

同样，用下标值31引用有32个元素的数组中的最后一个元素：

integers[31] = 432;

C#的数组句法也非常灵活，实际上，C#可以在声明数组时不进行初始化，这样以

后就可以在程序中动态地指定其大小。利用这项技术，可以创建一个空引用，以

后再使用new关键字把这个引用指向请求动态分配的内存位置：

int[] integers;

integers = new int[32];

可以使用下面的语法查看一个数组包含多少个元素：

int numElements = ; // integers is any reference to an array

2.8 命名空间

如前所述，命名空间提供了一种组织相关类和其他类型的方式。与文件或组件不

同，命名空间是一种逻辑组合，而不是物理组合。在C#文件中定义类时，可以

把它包括在命名空间定义中。以后，在定义另一个类，在另一个文件中执行相关

操作时，就可以在同一个命名空间中包含它，创建一个逻辑组合，告诉使用类

的其他开发人员：这两个类是如何相关的以及如何使用它们：

namespace CustomerPhoneBookApp

{

using System;

public struct Subscriber

{

// Code for

}

}

把一个类型放在命名空间中，可以有效地给这个类型指定一个较长的名称，该名

称包括类型的命名空间，后面是句点(.)和类的名称。在上面的例子中，Subscr

iber结构的全名是iber。这样，有相同短名的

不同的类就可以在同一个程序中使用了。

也可以在命名空间中嵌套其他命名空间，为类型创建层次结构：

namespace Wrox

{

namespace ProCSharp

{

namespace Basics

{

class NamespaceExample

{

// Code for the

}

}

}

}

每个命名空间名都由它所在命名空间的名称组成，这些名称用句点分隔开，首先

是最外层的命名空间，最后是它自己的短名。所以ProCSharp命名空间的全名是

arp，NamespaceExample类的全名是

spaceExample。

使用这个语法也可以组织自己的命名空间定义中的命名空间，所以上面的代码也

可以写为：

namespace

{

class NamespaceExample

{

// Code for the

}

}

注意不允许在另一个嵌套的命名空间中声明多部分的命名空间。

命名空间与程序集无关。同一个程序集中可以有不同的命名空间，也可以在不同

的程序集中定义同一个命名空间中的类型。

2.8.1 using语句

显然，命名空间相当长，键入起来很繁琐，用这种方式指定某个类也是不必要的。

如本章开头所述，C#允许简写类的全名。为此，要在文件的顶部列出类的命名空

间，前面加上using关键字。在文件的其他地方，就可以使用其类型名称来引用

命名空间中的类型了：

using System;

using arp;

如前所述，所有的C#源代码都以语句using System;开头，这仅是因为Microso

ft提供的许多有用的类都包含在System命名空间中。

如果using指令引用的两个命名空间包含同名的类，就必须使用完整的名称(或

者至少较长的名称)，确保编译器知道访问哪个类型，例如，类NamespaceExamp

le同时存在于Wrox. 和命名空间中，

如果要在命名空间arp中创建一个类Test，并在该类中实例化一个

NamespaceExample类，就需要指定使用哪个类：

using arp;

class Test

{

public static int Main()

{

aceExample nSEx = new aceExample();

//do something with the nSEx variable

return 0;

}

}

因为using语句在C#文件的开头，C和C++也把#include语句放在这里，所以从

C++迁移到C#的程序员常把命名空间与C++风格的头文件相混淆。不要犯这种错

误，using语句在这些文件之间并没有真正建立物理链接。C#也没有对应于C++

头文件的部分。

公司应花一定的时间开发一种命名空间模式，这样其开发人员才能快速定位他们

需要的功能，而且公司内部使用的类名也不会与外部的类库相冲突。本章后面将

介绍建立命名空间模式的规则和其他命名约定。

2.8.2 命名空间的别名

using关键字的另一个用途是给类和命名空间指定别名。如果命名空间的名称非

常长，又要在代码中使用多次，但不希望该命名空间的名称包含在using指令中

(例如，避免类名冲突)，就可以给该命名空间指定一个别名，其语法如下：

using alias = NamespaceName;

下面的例子(前面例子的修订版本)给命名空间指定Int

roduction别名，并使用这个别名实例化了一个NamespaceExample对象，这个

对象是在该命名空间中定义的。注意命名空间别名的修饰符是::。因此将先从I

ntroduction命名空间别名开始搜索。如果在相同的作用域中引入了一个Intro

duction类，就会发生冲突。即使出现了冲突，::操作符也允许引用别名。Name

spaceExample类有一个方法GetNamespace()，该方法调用每个类都有的GetTyp

e()方法，以访问表示类的类型的Type对象。下面使用这个对象来返回类的命名

空间名：

using System;

using Introduction = ;

class Test

{

public static int Main()

{

Introduction::NamespaceExample NSEx =

new Introduction::NamespaceExample();

ine(espace());

return 0;

}

}

namespace

{

class NamespaceExample

{

public string GetNamespace()

{

return e().Namespace;

}

}

}

2.9 Main()方法

本章的开头提到过，C#程序是从方法Main()开始执行的。这个方法必须是类或

结构的静态方法，并且其返回类型必须是int或void。

虽然显式指定public修饰符是很常见的，因为按照定义，必须在程序外部调用

该方法，但我们给该方法指定什么访问级别并不重要，即使把该方法标记为pri

vate，它也可以运行。

2.9.1 多个Main()方法

在编译C#控制台或Windows应用程序时，默认情况下，编译器会在与上述签名匹

配的类中查找Main方法，并使这个类方法成为程序的入口。如果有多个Main

方法，编译器就会返回一个错误，例如，考虑下面的代码：

using System;

namespace

{

class Client

{

public static int Main()

{

();

return 0;

}

}

class MathExample

{

static int Add(int x, int y)

{

return x + y;

}

public static int Main()

{

int i = Add(5,10);

ine(i);

return 0;

}

}

}

上述代码中包含两个类，它们都有一个Main()方法。如果按照通常的方式编译

这段代码，就会得到下述错误：

csc

Microsoft (R) Visual C# .NET Compiler version 8.00.40607.16

for Microsoft (R) .NET Framework version 2.00.40607

Copyright (C) Microsoft Corporation 2001-2003. All rights reserved.

(7,23): error CS0017: Program '' has more than

one entry point defined: '()'

(21,23): error CS0017: Program '' has more tha

n one entry point defined: '()'

但是，可以使用/main选项，其后跟Main()方法所属类的全名(包括命名空间)，

明确告诉编译器把哪个方法作为程序的入口点：

csc /main:ample

2.9.2 给Main()方法传送参数

前面的例子只介绍了不带参数的Main()方法。但在调用程序时，可以让CLR包

含一个参数，将命令行参数转送给程序。这个参数是一个字符串数组，传统称为

args(但C#可以接受任何名称)。在启动程序时，可以使用这个数组，访问通过

命令行传送过来的选项。

下面的例子是在传送给Main方法的字符串数组中迭代，并把

每个选项的值写入控制台窗口：

using System;

namespace

{

class ArgsExample

{

public static int Main(string[] args)

{

for (int i = 0; i < ; i++)

{

ine(args[i]);

}

return 0;

}

}

}

通常使用命令行就可以编译这段代码。在运行编译好的可执行文件时，可以在程

序名的后面加上参数，例如：

ArgsExample /a /b /c

/a

/b

/c

2.10 有关编译C#文件的更多内容

前面介绍了如何使用编译控制台应用程序，但其他类型的应用程序应如

何编译？如果要引用一个类库，该怎么办？MSDN文档介绍了C#编译器的所有编

译选项，这里只介绍其中最重要的选项。

要回答第一个问题，应使用/target选项(常简写为/t)来指定要创建的文件类

型。文件类型可以是表2-8所示的类型中的一种。

表 2-8

选 项

/t:exe

/t:library

/t:module

/t:winexe

输 出

控制台应用程序 (默认)

带有清单的类库

没有清单的组件

Windows应用程序 (没有控制台窗口)

如果想得到一个可由.NET运行库加载的非可执行文件(例如DLL)，就必须把它编

译为一个库。如果把C#文件编译为一个模块，就不会创建任何程序集。虽然模

块不能由运行库加载，但可以使用/addmodule选项编译到另一个清单中。

另一个需要注意的选项是/out，该选项可以指定由编译器生成的输出文件名。如

果没有指定/out选项，编译器就会使用输入的C#文件名，加上目标类型的扩展

名来建立输出文件名(例如.exe表示Windows或控制台应用程序，.dll表示类

库)。注意/out和/t(或/target)选项必须放在要编译的文件名前面。

默认状态下，如果在未引用的程序集中引用类型，可以使用/reference或/r选

项，后跟程序集的路径和文件名。下面的例子说明了如何编译类库，并在另一个

程序集中引用这个库。它包含两个文件：

●

类库

●

控制台应用程序，该应用程序调用库中的一个类。

第一个文件包含DLL的代码，为了简单起见，它只包含一个公

共类Math和一个方法，该方法把两个int类型的数据加在一起：

namespace

{

public class MathLib

{

public int Add(int x, int y)

{

return x + y;

}

}

}

使用下述命令把这个C#文件编译为. NET DLL：

csc /t:library

控制台应用程序将简单地实例化这个对象，调用其Add方法，在

控制台窗口中显示结果：

using System;

namespace

{

class Client

{

public static void Main()

{

MathLib mathObj = new MathLib();

ine((7,8));

}

}

}

使用/r选项编译这个文件，使之指向新编译的DLL：

csc /r:

当然，下面就可以像往常一样运行它了：在命令提示符上输入MathClient，其

结果是显示数字15—— 加运算的结果。

2.11 控制台I/O

现在，您应基本熟悉了C#的数据类型以及如何在操作这些数据类型的程序中完

成任务。本章还要使用Console类的几个静态方法来读写数据，这些方法在编写

基本的C#程序时非常有效，下面就详细介绍它们。

要从控制台窗口中读取一行文本，可以使用ne()方法，它会从

控制台窗口中取一个输入流(在用户按下回车键时停止)，并返回输入的字符串。

写入控制台也有两个对应的方法，前面已经使用过它们：

●

Console. Write()方法将指定的值写入控制台窗口。

●

ine()方法类似，但在输出结果的最后添加一个换行符。

所有预定义类型(包括object) 都有这些函数的各种形式(重载)，所以在大多数

情况下，在显示值之前不必把它们转换为字符串。

例如，下面的代码允许用户输入一行文本，并显示该文本：

string s = ne();

ine(s);

ine()还允许用与C的printf()函数类似的方式显示格式化的结

果。要以这种方式使用WriteLine()，应传入许多参数。第一个参数是花括号中

包含标记的字符串，在这个花括号中，要把后续的参数插入到文本中。每个标记

都包含一个基于0的索引，表示列表中参数的序号。例如，"{0}"表示列表中的

第一个参数，所以下面的代码：

int i = 10;

int j = 20;

ine("{0} plus {1} equals {2}", i, j, i + j);

会显示：

10 plus 20 equals 30

也可以为值指定宽度，调整文本在该宽度中的位置，正值表示右对齐，负值表示

左对齐。为此可以使用格式{n,w}，其中n是参数索引，w是宽度值。

int i = 940;

int j = 73;

ine(" {0,4}n+{1,4}n––––n {2,4}", i, j, i + j);

结果如下：

940

+ 73

1013

最后，还可以添加一个格式字符串，和一个可选的精度值。这里没有列出格式字

符串的完整列表，因为如第8章所述，我们可以定义自己的格式字符串。但用于

预定义类型的主要格式字符串如表2-9所示。

表 2-9

字 符 串

C

D

E

说 明

本地货币格式

十进制格式，把整数转换为以10为基数的数，如果给定一个精度说明符，就加上前导0

科学计数法(指数)格式。精度说明符设置小数位数(默认为6)。格式字符串的大小写("e" 或

"E")确定指数符号的大小写

F

G

N

P

X

固定点格式，精度说明符设置小数位数，可以为0

普通格式，使用E 或 F格式取决于哪种格式较简单

数字格式，用逗号表示千分符，例如32,767.44

百分数格式

16进制格式，精度说明符用于加上前导0

注意格式字符串都不需要考虑大小写，除e/E之外。

如果要使用格式字符串，应把它放在给出参数个数和字段宽度的标记后面，并用

一个冒号把它们分隔开。例如，要把decimal值格式化为货币格式，且使用计算

机上的地区设置，其精度为两位小数，则使用C2：

decimal i = 940.23m;

decimal j = 73.7m;

ine(" {0,9:C2}n+{1,9:C2}n ––––––n {2,9:C2}", i, j, i + j);

在美国，其结果是：

$940.23

+ $73.70

$1,013.93

最后一个技巧是，可以使用占位符来代替这些格式字符串，例如：

double d = 0.234;

ine("{0:#.00}", d);

其结果为0.23，因为如果在符号(#)的位置上没有字符，就会忽略该符号(#)，

如果0的位置上有一个字符，就用这个字符代替0，否则就显示0。

2.12 使用注释

本节的内容表面上看起来很简单——给代码添加注释。

2.12.1 源文件中的内部注释

在本章开头提到过，C#使用传统的C风格注释方式：单行注释使用//

...

，多行

注释使用 /*

...

*/：

// This is a single-line comment

/* This comment

spans multiple lines */

单行注释中的任何内容，即//后面的内容都会被编译器忽略。多行注释中/* 和

*/之间的所有内容也会被忽略。显然不能在多行注释中包含*/组合，因为这会被

当作注释的结尾。

实际上，可以把多行注释放在一行代码中：

ine(/*Here's a comment! */ "This will compile");

像这样的内联注释在使用时应小心，因为它们会使代码难以理解。但这样的注释

在调试时是非常有用的，例如，在运行代码时要临时使用另一个值：

DoSomething(Width, /*Height*/ 100);

当然，字符串字面值中的注释字符会按照一般的字符来处理：

string s = "/* This is just a normal string */";

2.12.2 XML文档说明

如前所述，除了C风格的注释外，C#还有一个非常好的功能，本章将讨论这一功

能。根据特定的注释自动创建XML格式的文档说明。这些注释都是单行注释，但

都以3个斜杠(///)开头，而不是通常的两个斜杠。在这些注释中，可以把包含

类型和类型成员的文档说明的XML标识符放在代码中。

编译器可以识别表2-10中所示的标识符。

表 2-10

标 识 符