c #教程第一课简单的欢迎程序

c#教程第一课:简单的欢迎程序

在本文开始写作的时候，虽然商用c#编译器尚未推

出，但你可以下载微软的.NETFrameworksSDKBeta1.

本节课通过介绍几个简单的程序，使得你对C#有所入门。本

节程要达到如下几个目的：

1.理解一个C#程序的基本结构。

2.初步了解〃名称空间〃的概念。

3.初步了解〃类〃的概念。

4.了解〃Main〃方法所做的工作。

5.学会如何读取命令行输入信息。

6.学会使用控制台输入/输出（I/O）语句。

1.清单1-1.一个简单的欢迎程序Welcome,cs

//NamespaceDeclaration

usingSystem;

//Programstartclass

classWelcomeCSS{

//Mainbeginsprogramexecution.

publicstaticvoidMain(){

//Writetoconsole

Console.WriteLine(^WelcometotheC#Station

Tutorial!v);

说明

1.清单1-1中的程序包括四个基本元素：名称空间的声明，

类，〃Main”方法和语句。

2.本例中对名称空间的声明，表明正在使用〃System〃这个名

称空间。

名称空间内包含了一组可以被C#程序调用的代码。有了〃us

ingSystem;〃这个声明，就表明程序可以引用该〃System”名

称空间内的代码，而无需在每个引用的前面加上〃System〃。

关于这一点，我将在后面专门介绍名称空间的课程中详细介

绍。

3.类〃classWelcomeCSS〃包含了程序所要用到的数据，和所

要执行的方法的定义。

同诸如接口和结构这样的元素类似，类在程序中是用来描述

对象的，这些元素都将会在后续课程中详细介绍。本例中的

类不包含数据，只包含一个方法。该方法定义了该类的行为

（或者称为该类所能做的事情）。

4.程序运行时，WelcomeCSS类中的该方法表明了该类所要完

成的事情。

方法名〃Main〃作为保留字，作为程序的起点。〃Main〃前面是

个名为〃static〃的修饰符。“static〃修饰符表明该方法仅仅

在该特定的类中工作，而不是在在该类的实例中工作。这是

必需的，因为一旦程序启动后，并不存在对象的实例。类，

对象和实例的具体用法将会在后面的课程中覆盖到。每个方

法必须有个返回值类型。本例中，返回值类型是〃void〃，它

表明〃Main〃函数没有返回值。每个方法名的后面也都跟着个

参数表，参数表包含有零个或者多个参数并用括号括起来。

为了简单起见，没有在"Main"后面添加参数。后面的课程中,

将介绍〃Main〃方法所允许采用的参数类型。

5.”Main〃方法通过〃Console.WriteLine(...)”语句表明其

行为。

“Console"是"System”名称空间中的类。〃WriteLine(...)

〃是〃Console”类中的方法。我们使用〃.〃这个句点操作符来

标记程序中的从属元素。注意到，我们也可以这样来书写：

“System.Console.WriteLine(...)〃,这样的书写格式是很

有趣的，它是根据"namespace,class,method〃的格式进行

书写的。如果在程序的一开始，没有采用〃usingSystem”的

声明，那么就必须严格遵守"System.Console.WriteLine

(...)〃这样的书写格式。该语句的执行结果是在控制台控制

台上输出字符串“WelcometotheC#StationTutorial!，z

o

6.注释是由'7/〃标出的。

例子中的这些注释都是单行注释，表明从该注释符号的开始

处到该行结束处，都是注释部分。如果你的注释要跨越若干

行，即多行注释，可以以符号7*〃开始，以符号〃*/〃结束，

其中所包含的全部是注释。你也可以在多行注释符号中包含

单行注释。但是，不能在单行注释符号后面放上多行注释符

号。程序编译时，将忽略掉注释部分。注释的目的是为了用

简单的英语给程序所要完成的工作加上注解。

7.所有语句都以分号〃；〃结束。

类和方法以〃{〃开始，以〃}〃结束。任何位于〃{〃和〃}〃之间的

语句定义为块。块定义了程序元素的活动范围（或者称为生

命期和可见性），这些概念将在后面的课程中加以介绍。

8.可以编写出能够接受命令行输入信息的程序。

命令行输入信息的集合是在“Main〃方法中进行处理的。清单

1-2中的程序，可以从命令行中接受输入一个名字，之后在

控制台上显示出来。

2.清单1-2.读取命令行输入信息的程序NamedWelcome.cs

//NamespaceDeclaration

usingSystem;

//Programstartclass

classNamedWelcome{

//Mainbeginsprogramexecution.

publicstaticvoidMain(string[]args){

//Writetoconsole

Console.WriteLine(^Hello,{0}!〃，args[0]);

Console.WriteLine(^WelcometotheC#Station

Tutorial!v);

说明

1.记住，要把你的名字添加到命令行中。

例如，在命令行中打入〃NamedWelcomeJoe〃。如果不这样做,

程序就会崩溃，在后面的课程中，将介绍如何检测这种情况,

以及如何避免这种情况的出现。

2.在清单1-2中，在〃Main”方法的参数表中有个入口。

参数名是〃args〃。在程序的后面部分就要引用该参数。〃st

ring□〃是参数〃args〃的类型。〃string〃类型用于存放字符。

这些字符可以是一个单词，也可以是多个单词。方括号〃口〃

表示数组，〃args〃参数由命令行上的若干个单词构成。

3.在〃Main”方法的语句中，多了一条“Console.WriteLine

(...)〃语句。

该语句中的参数表同以往的写法不同，其中有个格式字符串

〃{0}〃参数。格式串中的第一个参数从数字0开始，第二

个参数从数字1开始，依此类推。〃{0}〃参数意味着引号

后面的参数值将会输出到该位置。现在让我们来看看引号后

面的参数。

4.〃args[0]〃参数，它指向"args〃数组中的第一个字符串。

数组中的第一个元素是args[0],第二个元素是args[1],

依此类推。例如，如果我在命令行中写上"NamedWelcomeJo

e〃，〃args[0]〃的值就为〃Joe〃.

让我们回到在格式字符串中嵌入的〃{0}〃参数吧，因为〃arg

s[0]〃是格式串后面的第一个参数，一旦执行该命令时，〃a

rgs[0]〃的值〃Joe〃就会替换掉格式串中的〃{0}〃。一旦执行

命令："NamedWelcomeJoe”,输出结果就会为:

>Hello,Joe!

>WelcometotheC#StationTutorial!

通过控制台也可以把输入信息提供给程序。清单「3演示了

交互式处理用户输入的信息的方法。

3.清单1-3.交互式处理输入信息的程序

InteractiveWelcome.cs

//NamespaceDeclaration

usingSystem;

//Programstartclass

classNamedWelcome{

//Mainbeginsprogramexecution.

publicstaticvoidMain(){

//Writetoconsole/getinput

Console.Write(z，Whatisyourname?:〃)；

Console.Write(''Hello,{0}!〃，Console.ReadLineO);

Console.WriteLine(^WelcometotheC#Station

Tutorial!z，);

说明

这一次，〃Main”方法没有用到任何参数，但现在程序中有了

三条语句，前面两条语句不同于第三条语句，它们是：〃Con

sole.Write(...)〃而不是"Console.WriteLine区

别是："Console.Write(...)〃语句把信息输出到控制台，之

后光标停留在同一行，而“Console.WriteLine(...)“把信息

输出，之后换行。

第一条语句仅仅输出“Whatisyourname?:〃到控制台。

第二条语句要等到其参数被适当地处理之后，才会输出信

息。格式串后面的第一个参数是：〃Console.ReadLine()〃。

这就使得程序要等待用户在控制台输入信息，输入信息以回

车或者换行结束。该方法的返回值替换了格式串中的〃{0}〃

参数，并输出到控制台上。

最后一个语句也用来输出信息到控制台，这一点我们在前面

已经介绍过。一旦运行了程序“InteractiveWelcome”,其输

出结果为：

>WhatisyourName?

>Hello,!WelcometotheC#StationTutorial!

小结

到现在为止，你已经了解了C#程序的基本结构，名称空间和

类。你还了解到〃Main〃方法是C#程序的入口，并学会了如

何捕捉命令行的输入信息，以及如何进行交互式的I/O操作。

C#教程第二课:表达式,类型和变量

右

逻辑与&左

逻辑异或左

逻辑或1左

条件与&&左

条件或II左

条件?:右

赋值等=*=/=%=+=-=<<=>>=&二"==右

左结合意味着运算符是从左到右进行运算的。右结合意味着

所有的运算是从右到左进行的，如赋值运算符，要等到其右

边的计算出来之后，才把结果放到左边的变量中。

2.清单1-2.单目运算符：Unary,cs

usingSystem;

classUnary{

publicstaticvoidMain(){

intunary=0;

intpreincrement;

intpreDecrement;

intpostincrement;

intpostDecrement;

intpositive;

intnegative;

sbytebitNot;

boollogNot;

preincrement=++unary;

Console.WriteLine(z，Pre-Increment:{0}〃，preincrement);

preDecrement=一unary;

Console.WriteLine(',Pre-Decrement:{0}〃，preDecrement);

postDecrement=unary一;

Console.WriteLine("Post-Decrement:{0}〃，

postDecrement);

postincrement=unary++;

Console.WriteLine(''Post-Increment:{0}〃，

postincrement);

Console.WriteLine(z，FinalValueofUnary:{0}〃，unary);

positive=-postincrement;

Console.WriteLine(''Positive:{0}〃，positive);

negative=+postlncrement;

Console.WriteLine(''Negative:{0}”,negative);

bitNot=0;

bitNot=(sbyte)(^bitNot);

Console.WriteLine(''BitwiseNot:{0}〃，bitNot);

logNot=false;

logNot=!logNot;

Console.WriteLine(''LogicalNot:{0}〃，logNot);

说明

1.当计算表达式的时候，在后置增一和后置减一运算符进行

运算时，先返回其值，再进行增一或者减一运算。当使用前

置加号和减号运算符进行运算时，是先进行增一或者减一的

运算，然后再返回其结果值。

2.在清单1-2中，变量unary初始化为0,诩行++x运算时,

"unary〃的值加1,再把其值1赋给"preincrement〃变量。在

进行一x运算时，先把〃unary〃的值减到0,再把值0赋给〃

preDecrement”变量。

3.进行x-运算时，先把"unary〃的值0赋给〃postDecrement

"变量，之后再把〃unary〃减到-1。进行x++运算时，先把〃

unary”的值T赋给"postincrement”变量，之后再对〃unary

〃加1,使得〃unary〃变量现在的值为0。

4.变量〃bitNot〃初始值为0,进行按位取反运算，本例中，

数0表示为二进制“00000000〃，按位取反之后变为T,其二

进制表示为〃11111111〃。

5.了解一下表达式〃(sbyte)(~bitNot)〃，任何对类型sbyt

e,byte,short或者ushort类型数据的运算，返回结果

都是整数。要把值赋给bitNot变量，我们必须使用cast

（类型）运算符（强制类型转换），其中Type表示你希望

转换成的类型（本例中为sbyte）。Cast运算符把大范围

类型的数据转换为小范围类型的数据时，须特别谨慎，因为

此时有丢失数据的危险。一般来说，把小类型的数据赋给大

类型变量，并没有问题，因为大范围数据类型的变量具有

足够的空间存放小类型数据。注意在signed和unsigned

类型之间进行Cast运算时，也存在此类危险。许多初级程

序设计教程对变量的位表示作出了很好的讲解，同时也介绍

了直接进行Cast运算的危险。

逻辑非（!）运算符可以处理布尔变量值。本例中，〃logNot〃

变量从false变为true。

上述程序的输出结果如下：

>Pre-Increment:1

>Pre-Decrement0

>Post-Decrement:0

>Post-Increment-1

>FinalValueofUnary:0

>Positive:1

>Netative:-1

>BitwiseNot:-1

>LogicalNot:True

3.清单1-3.二元运算符Binary,cs

usingSystem;

classBinary{

publicstaticvoidMain(){

intx,y,result;

floatfloatResult;

x=7;

y=5;

result=x+y;

Console.WriteLine(z/x+y:{0}”,result);

result=x-y;

Console.WriteLine(z/x-y:{0}〃，result);

result=x*y;

Console.WriteLine(〃x*y:{0}〃，result);

result=x/y;

Console.WriteLine('/x/y:{0}〃，result);

floatResult=(float)x/(float)y;

Console.WriteLine（'/x/y:{0}〃，floatResult）;

result=x%y;

Console.WriteLine（z，x%y:{0}〃，result）;

result+=x;

Console.WriteLine（，，result+=x:{0}〃，result）;

说明

清单「3演示了二元操作符的几个例子。加法(+),减法

(-),乘法(*)和除法(/)的运算结果，就是我们通常

进行的的四则运算的结果。

因为〃floatResult〃变量是浮点运算类型，所以整型变量〃x〃

和〃y〃被强制转换成浮点类型来计算FloatResulto

这里有个求余数的运算符，两个操作数相除，返回余数。

最后一条语句给出了另外一种赋值形式，这里用了(+=)运

算符.无论什么时候你使用(+=)运算符，那么这个二进制

运算符就应该在运算符左右两边都进行运算，然后把值赋给

左边的参数。本语句相当于〃result=result+x”,并返

回同样的值。

前面的课程中，你看到的使用次数较多的一种类型是〃strin

g〃（字符串）类型。“string〃类型是由包含在引号内的Un

icode编码的字符构成。例如"Thisisastring.

另外一种数据类型是数组。数组可以看成是同种类型的元素

构成的集合。当声明数组时，你要指定类型名，数组名，维

数和数组大小。

4.清单1-4.ArrayOperations:Array,cs

usingSystem;

classArray{

publicstaticvoidMain(){

int[]mylnts={5,10,15);

bool[][]myBools=newbool[2][];

myBools[0]=newbool[2];

myBools[1]=newbool[1];

double[,]myDoubles=newdouble[2,2];

string[]myStrings=newstring[3];

Console.WriteLine(''inylnts[0]:{0},mylnts[1]:{1},

mylnts[2]:⑵”,mylnts[0],mylnts[1],mylnts[2]);

myBools[0][0]=true;

myBools[0][1]=false;

myBools[1][0]=true;

Console.WriteLine(''myBools[0][0]:{0},myBools[1][0]:

{1}〃，myBools[0][0],myBools[1][0]);

myDoubles[0,0]=3.147;

myDoubles[0,1]=7.157;

myDoubles[1,1]=2.117;

myDoubles[1,0]=56.00138917;

Console.WriteLine(''myDoubles[0,0]:{0},myDoubles[1,

0]:{1}”,myDoubles[0,0],myDoubles[1,0]);

myStrings[0]=〃Joe”;

myStrings[1]=〃Matt〃；

myStrings[2]="Robert”;

Console.WriteLine(''myStrings[0]:{0},myStrings[1]:

{1},myStrings[2]:{2}〃，myStrings[0],myStrings[1],

myStrings[2]);

说明

清单广4演示了数组的各种不同实现方法。第一个例子是

“mylnts〃数组，它在声明的同时进行了初始化。

接着是个二维数组，可以把它理解为数组的数组。我们需要

使用〃new〃运算符来实例化初始数组的大小，之后，再对每

个子数组使用new运算符。

第三个例子是个二维数组。数组可以是多维的，每一维可以

通过逗号隔开，也必须用〃new〃运算符进行实例化。

最后定义了一个一维的字符串数组。

每种情况下，对于数据元素的访问可以通过引用元素的位置

（下标）来进行。数组的大小可以是任何整型值。其下标从

0开始。

小结

到现在为止，你已经了解了C#的变量，简单数据类型，数

组和字符串。我们还学习了如何用C#的运算符构成表达式。

C#教程第三课:选择控制语句

本节课将介绍如何使用C#选择控制语句，第三课将达到如下

几个目的：

1.学会〃if〃语句的用法。

2.学会〃switch〃语句的用法。

3.学会在“switch〃语句中如何使用"break”语句。

4.理解〃goto"语句的正确用法。

在前面几节课中，你所看到的程序都是顺序执行的。你无法

控制输入语句，你所能做的就是跟着程序执行直到终止。本

节课中，将介绍基于条件进行判断，从而选择进入相应的逻

辑分支中去执行。

我们所介绍的第一个选择语句是〃if〃语句，它有三种基本形

式：单条选择，如果/否则，以及多情形选择。

1.清单3T.IF语句的格式：IfSelection.cs

usingSystem;

classIfSelect{

publicstaticvoidMain(){

stringmylnput;

intmylnt;

Console.Write(^Pleaseenteranumber:〃)；

mylnput=Console.ReadLineO;

mylnt=Int32.Parse(mylnput);

//SingleDecisionandActionwithbrackets

if(mylnt>0){

Console.WriteLine(Z/Yournumber{0}isgreaterthan

zero.”,mylnt);

}

//SingleDecisionandActionwithoutbrackets

if(mylnt<0)

Console.WriteLine(''Yournumber{0}islessthanzero.”,

mylnt);

//Either/OrDecision

if(mylnt!=0){

Console.WriteLine(，zYournumber{0}isnotequalto

zero.,mylnt);

}

else{

Console.WriteLine(''Yournumber{0}isequaltozero.”,

mylnt);

)

//MultipleCaseDecision

if(mylnt<0||mylnt==0){

Console.WriteLine(Z/Yournumber{0}islessthanorequal

tozero.〃，mylnt);

)

elseif(mylnt>0&&mylnt<=10){

Console.WriteLine("Yournumber{0}isbetween1and10.〃，

mylnt);

)

elseif(mylnt>10&&mylnt<=20){

Console.WriteLine(''Yournumber{0}isbetween11and

20.”,mylnt);

elseif(mylnt>20&&mylnt<=30){

Console.WriteLine(Z/Yournumber{0}isbetween21and

30.”,mylnt);

else{

Console.WriteLine(z，Yournumber{0}isgreaterthan30.”,

mylnt);

说明

1.清单3-1中的IF语句的各种格式都使用了同一个输入变

量〃mylnt”。

这是从用户获得交互内容的另一种方式。我们首先输出一行

信息：“Pleaseenteranumber:〃到控制台。"Console.Rea

dLine()〃语句使得程序等待来自用户的输入，一旦用户输入

一个数字，按回车键之后，该数字以字符串的形式返回到〃m

ylnput〃变量中，由于我们需要的是一个整数，所以需要转

换变量"mylnput”成整型数据。用命令”Int32.Parse(mylnpu

t)〃即可完成。(Int32等数据类型将在后面的课程中加以

介绍。)转换结果放到〃mylnt〃变量中，这是个整数类型。

2.有了我们所需要的类型的数据，就可以用"iF语句来进行条

件判断了。

对于第一种形式的IF语句，格式为：if(booleanexpression)

{statements}0该语句必须以关键字,F开始。之后，括号中

为布尔表达式。该布尔表达式必须计算出一个true或者false

值。在本例中，我们检查用户的输入，看看输入值是否大于

0,如果表达式运算结果为true,就执行大括号中的语句。(我

们把大括号之间的语句部分称为“block"。)块中有一个或者

多个语句。如果布尔表达式的值为false,我们就忽略块中的

语句，直接执行块后面的语句。

3.除了没有块之外，第二种"if"语句的格式非常类似于第一

种。

因此，如果布尔表达式为true,将会执行布尔表达式之后的

第一条语句。当布尔表达式的值为false,布尔表达式之后的

第一条语句将被忽略掉，而直接执行其后的程序语句。如果

你只有一条语句需要执行，就用该格式的"if"语句。如果你打

算在布尔表达式的值为true时-，执行两条或者两条以上的语

句，就必须把它们放到块中。我个人的建议是：无论需要执

行几条语句，要养成把if语句放到块中的习惯，这就使得

你避免犯如下错误：当添加了一条语句之后，忘记了添加一

对括号。

4.大多数时候，你需要作出如下选择：当条件满足时做一件

事，否则做另外一件事。

清单3-1中，程序演示了这种if语句格式的用法。当布尔表

达式为true时，就立刻执行"if"后面的那条语句，而当布

尔表达式为false时，就执行"else”关键字后面的语句。

5.当要计算多个布尔表达式时，你可以使用if/elseif/else这

种格式,上面的例子程序演示了这种形式,从关键字"if'开始，

一旦布尔表达式为真，就执行if后面的块。但是，这一次，

在组合关键字"elseif"后面还可以进行多个条件的判断。"else

if"语句后面也有个布尔表达式，一旦该布尔表达式的值为

true,就会执行紧接其后的块。这种情形可以一直持续下去,

直到所有的情况都已经计算出来，但是整个“if/elseif"序列必

须以“else”结束。当所有的“if"或者"elseif"后面的布尔表达

式的值都为false时，就执行关键字“else”后面的块。对于

if/elseif/else格式的语句，每次仅仅执行一个其中部分的语

句。

6.上面的例子中，布尔表达式(mylntv0IImylnt==0)包含了

条件OR(II)运算符。

对于常规OR(I)运算符和条件OR(II)运算符来说，只要有运

算符两边的子表达式之一为真，整个布尔表达式的值就为

真。两个运算符的区别在于：正规OR运算符(I)每次都对运

算符(I)两边的表达式进行计算。而条件运算符OR(II)只有当

第一个子表达式的值为false时，才计算第二个子表达式的

值。

7.布尔表达式(mylnt>0&&mylnt<=10)包含了条件运算符

ANDo

对于常规AND(&)运算符和条件AND(&&)运算符来说，

只有当运算符两边的子表达式的值都为真时，整个布尔表达

式的值为真。两种运算符的区别在于：正规AND(&)运算符

每次都计算运算符两边的子表达式的值,但是对于条件AND

运算符来说，只有当第一个子表达式的值为真时，才计算第

二个表达式的值。条件运算符(&&和II)通常称为运算优化

的运算符，因为有时不需要计算整个表达式的值。这样就可

以忽略掉不必要的逻辑表达式的计算，可以生成有效的代

码。

同if/elseif/else格式的"if"语句类似，"switch"语句的用法如

下：

2.清单3-2.分支选择语句：SwitchSelection.cs

usingSystem;

classSwitchSelect{

publicstaticvoidMain(){

stringmylnput;

intmylnt;

begin:

Console.Write("Pleaseenteranumberbetween1and3:〃)；

mylnput=Console.ReadLineO;

mylnt=Int32.Parse(mylnput);

//switchwithintegertype

switch(mylnt){

case1:

Console.WriteLine(^Yournumberis{0}.〃，mylnt);

break;

case2:

Console.WriteLine(''Yournumberis{0}.〃，mylnt);

break;

case3:

Console.WriteLine("Yournumberis{0}.〃，mylnt);

break;

default:

Console.WriteLine(^Yournumber{0}isnotbetween1and

3.〃，mylnt);

decide:

Console.Write("Type\"continue、”togoonor\〃quit\"to

stop:);

myInput=Console.ReadLineO;

//switchwithstringtype

switch(mylnput){

case〃cont..inue〃:

gotobegin;

case〃qui•t/〃:

Console.WriteLine(〃Bye.〃);

break;

default:

Console.WriteLine(''Yourinput{0}isincorrect.

mylnput);

gotodecide;

说明

1.清单3-2演示了多分支选择语句switch的用法。

关键字“switch〃后面是switch表达式。Switch表达式必须

是以下类型中的一种：sbyte,byte,short,ushort,int,

uint,long,ulong,char,string,或者enum类型。（enum

类型将在后面的课程中加以介绍）。在清单3-2的第一个

“switch〃语句中，switch表达式计算的是整数类型的数

据。

2.在switch表达式后面是个switch块，当Switch表达式

的值同某一个case后面的常量表达式的值相匹配时，就执

行此case后面的语句，直到遇到〃break〃语句或者〃goto〃语

句为止。每个分支以关键字〃case〃作为标号，其后为常量表

达式，然后是分号（：）o本例子程序中，我们有〃case1：

〃，“case2：〃和“case3：〃。

3.你可以在所有的分支选择的后面加上一个〃default〃分

支。

如果没有匹配的常量表达式，就进入default分支，并执行

该分支的语句。虽然default标号是可选的，我建议你加上

该分支。这将有助于处理一些意外事件，使得你的程序能

够捕捉和处理不可预见的事件，从而使得程序更加可靠。

4.每个〃case〃标号必须以"break〃语句作为结束。

"break”语句将使得程序退出switch语句，并从switch块

后面的一条语句开始执行。对于〃default〃标号来说，

“break〃语句是可选的，因为有〃break〃语句和没有“break”

语句，其运行结果是一样的。如果你在switch块中放置了

一个〃goto〃语句，情况就不一样了。

5.清单3-2中的第二个〃switch〃语句演示了“goto〃语句的用

法。

“goto〃语句可以让程序跳到关键字〃goto〃后面的标号中去

执行。程序执行过程中，如果用户打入“continue”,switch

语句就匹配case"continue”中的常量表达式,并执行“goto

begin:"语句。程序就会离开"switch〃语句，开始执行标号

“begin:〃后的第一条语句。这是个有效的循环，可以让你多

次重复执行同样一段代码。一旦用户打入字符串〃quit〃，循

环将会结束。此时，将进入case〃quit〃分支。该分支将输

出信息〃Bye.〃到控制台上，之后跳出switch语句，再结束

程序。

一旦输入的字符串既不是"continue〃也不是〃quit”,就会进

入〃default:〃分支。于是，将会输出一个出错信息到控制台

上，之后执行〃gotodecide:〃命令。这就使得程序转跳到

“decide:〃标号后面的第一条语句，该语句执行后，将会询

问用户是否愿意continue（继续）还是quit（退出）。这

是个有效的循环。

显然，"goto〃语句功能强大，在受控的场合下，〃got。〃语句

是很有用途的。但是，必须指出的是，〃got。〃如果出现被滥

用的趋势，程序的调试和维护将会变得很困难。想象一下，

如果程序到处可见goto语句，其流程将会变得难以阅读和

理解。下节课中，将介绍在程序中创建循环语句的更好方法。

小结

现在，你已经了解了如何使用〃if〃语句的各种格式，也了解

了如何使用"switch〃语句。你也了解了使用“break〃语句可

以从〃switch〃语句中推出。最后，你也了解了如何使用

“goto〃语句跳到程序的另外一个部分。

C#教程第四课:循环控制语句

作者：未知阅读人次：65561文章来源：赢政天

下发布时间：2004-9-13网友评论（⑼条

本节课将介绍如何使用C#控制语句中的循环语句，本课目的

如下：

1.学会〃while〃循环的用法。

2.学会〃do〃循环的用法。

3.学会〃for〃循环的用法。

4.学会foreach循环的用法。

5.进一步了解“break〃语句的用法。

6.如何使用"continue”语句。

在C#中，使用〃got。〃语句并不是一个最佳的建立循环的方

法。本节课将介绍建立循环的常用方法。

第一个要介绍的语句是while循环语句

1.清单4-1.While循环：Whileloop,cs

usingSystem;

classWhileloop{

publicstaticvoidMain(){

intmylnt=0;

while(mylnt<10){

Console.Write(z，{0}〃，mylnt);

mylnt++;

)

Console.WriteLine();

说明

1.清单4-1演示了一个简单的while循环。

以关键字〃while〃开始，后面是个布尔表达式。所有的控制

语句都使用了布尔表达式。这就意味着表达式必须计算出t

rue或者false值。本例中，我们将检查mylnt变量，看看

它是否小于10o因为mylnt已经初始化为0,第一次计算

时，该布尔表达式将返回true值。一旦布尔表达式的值为t

rue,将执行该布尔表达式后面块中的语句。

2.在while块中，我们把数字和空格输出到控制台中，之后,

对mylnt进行加1运算。一旦执行了while块中的语句之后，

再次计算布尔表达式的值，这种情况将一直循环下去，直到

该布尔表达式的值为false为止。一旦布尔表达式的值为f

alse,程序将从while块之后的第一条语句开始执行。在本

例中，我们把数字0到9输出到控制台中，之后退出while

块，再输出一个新行到控制台。

同“while〃循环类似的是〃do〃循环语句。

2.清单4-2.Do循环：Doloop,cs

usingSystem;

classDoloop{

publicstaticvoidMain(){

stringmyChoice;

do(

//PrintAMenu

Console.WriteLine(，zMyAddressBook\n〃)；

Console.WriteLine(Z，A-AddNewAddress");

Console.WriteLine(Z，D-DeleteAddress");

Console.WriteLine(Z，M-ModifyAddress");

Console.WriteLine(Z，V-ViewAddresses");

Console.WriteLine(，ZQ-Quit\n〃)；

Console.WriteLine(''Choice(A,D,M,V,orQ):〃)；

//Retrievetheuser'schoice

myChoice=Console.ReadLineO;

//Makeadecisionbasedontheuser'schoice

switch(myChoice){

caseA:

〃〃

casea:

Console.WriteLine(''Youwishtoaddanaddress.");

break;

case〃Dn〃:

cased:

Console.WriteLine(/zYouwishtodeleteanaddress.，z);

break;

case〃打M〃:

〃〃

casem:

Console.WriteLine(''Youwishtomodifyanaddress.");

break;

case〃、V了〃:

case〃v〃:

Console.WriteLine("Youwishtoviewtheaddresslist.〃);

break;

case〃八Q〃:

case〃q〃:

Console.WriteLine(〃Bye.〃);

break;

default:

，，

Console.WriteLineC{0}isnotavalidchoice,myChoice);

)

//Pausetoallowtheusertoseetheresults

Console.Write(^Pressanykeytocontinue...;

Console.ReadLine();

Console.WriteLine();

}while(myChoice!=〃Q〃&&myChoice!="q〃);//Keepgoing

untiltheuserwantstoquit

说明

1.清单4-2演示了〃do〃循环的例子。〃do〃循环的格式是:

do{＜语句＞}while（〈布尔表达式＞）;其中的语句可以

是任何合法的C#语句，布尔表达式同以前的规定一样，其返

同值要么为true,要么为false。

2.如果你打算输出清单4-2中的信息或者菜单，之后再读取

用户的输入，那么就使用〃do〃格式的循环而不要使用〃whil

e〃格式的循环语句。因为在本例中，布尔表达式的值是在

循环结束处进行计算的，〃do〃循环可以保证：循环体中的

语句至少执行一次。与此相对应的是：〃while〃循环一开始

时，计算布尔表达式的值，〃while”循环不能保证循环体中

的语句能够至少执行一次。

3.让我们来回顾一下清单4-2中的内容。

在Main。方法中，我们定义了变量“myChoice〃为字符串类

型。之后，输出一些信息到控制台，即输出一个可让用户进

行选择的菜单。我们必须要得到用户的输入，即Console.R

eadLine()方法所返回的值，该值存放在myChoice变量中。

我们必须先得到用户的输入，之后再处理。要完成这件事，

一个有效的方法是就使用“switch〃语句。注意到：为了获

得同样的功能，我们既匹配了小写字母，也匹配了大写字母。

另外一点是：我们使用了"default:〃case,这是个良好的

编程作风。

3.清单4-3.For循环：Forloop,cs

usingSystem;

classForloop{

publicstaticvoidMain(){

for(inti=0;i<20;i++){

if(i==10)

break;

if(i%2==0)

continue;

Console.Write(z，{0}”,i);

Console.WriteLine();

说明

1.清单4-3演示了〃for〃循环的用法。

当你能够精确地知道循环的次数时，For循环语句就派上

了用场。本程序同清单4-1中〃while〃循环程序的运行结果

一样。〃for〃循环中，括号中内容由三个由分号隔开的部

分：〃（〈初始化表）；〈布尔表达式＞；＜post-loop动作表》）

〃组成

2.初始化表是个由逗号隔开的表达式，在〃for〃循环的整个

周期中，这些表达式仅仅计算一次。计算是在一开始进行的,

并且在循环语句的执行之前进行。正如在清单4-3所见，通

常初始化表是先初始化一个作为计数器的整型变量。

3.一旦进行初始化后，〃for〃循环就进入第二部分：布尔

表达式的计算。这里的布尔表达式可以写得很复杂，但是

结果只能是true或者falseo布尔表达式通常用来验证计数

器变量的状态。

4.一旦布尔表达式的值为true时，就会执行〃for”循环大

括号中的语句。通常情况下，这些语句从左大括号开始，不

中断地一直执行到右大括号。但在清单4-3中，有几个例外,

几个〃if〃语句改变了程序的流程。

第一个〃if〃语句检查〃i〃是否等于10,这里使用了〃break”

语句，可在此处跳出循环，转入块后面的第一条语句

的执行。

第二条〃if〃语句使用了求余运算符，看看〃i〃是否能够被2

整除，如果余数等于0,就执行"continue〃语句。控制将跳

过循环体中余下的语句，转入下一轮新的循环。你需要在块

中正确地组织好语句，一旦满足有关条件，就执行相应的语

句。

5.一旦程序流程遇到continue语句，或者遇到块的结尾处

的右括号，就转入"for”循环括号中的第三项：post-loop

动作表，该表由逗号隔开，在〃for〃块中的语句都执行完毕

之后，就执行该动作表中的动作。清单4-3中的post-lo

op动作表中的动作很典型：计数器加lo一旦动作表执行完

毕，流程就转到对布尔表达式值进行判别。循环将继续进行

下去，直到布尔表达式的值为true。当布尔表达式的值为f

alse,控制流程就转到〃for〃块之后的第一条语句。

4.清单4-4.TheForEach循环:ForEachloop.cs

usingSystem;

classForEachloop{

publicstaticvoidMain(){

string[]names={"Cheryl”,〃Joe〃，“Robert"};

foreach(stringpersoninnames){

Console.WriteLine(，z{0}”,person);

说明

1.“foreach〃循环列举出集合中所有的元素。

清单4-4所使用的数组类型，就是这样的一个集合。（在

“System.Collections”也可以由其他的数据类型作集合。）.

在Main。方法中，我们所做的第一件事是：定义由四个字符

串组成的数组nameso

2.“foreach〃括号中的表达式是由关键字in隔开的两个项组

成。in右边的项是集合名，in左边的项是变量名，用来存

放该集合中的每个元素。

该循环的运行过程如下：每一次循环时，从集合中取出一个

新的元素值，放到只读变量中去，括号中的整个表达式返回

值为true,“foreach〃块中的语句就能够执行。一旦集合中

的元素都已经被访问到，整个表达式的值为false,控制流

程就转入到〃foreach”块后面的第一条可执行语句。

3.在清单4-4的例子中，我们使用了字符串变量person用来

存放names数组的每个元素，并且使用Console.WriteLine()

方法输出person变量的值。

小结

到现在为止，你已经了解了“while”,〃do〃，“for〃和

〃foreach〃循环语句的用法。最后你也学习了如何设置有关

条件，来改变循环体块中的语句的流程。

C#教程第五课:方法

作者：未知阅读人次：70564文章来源：赢政天

下发布时间：2004-9-13网友评论（"5）条

本节课向你介绍C#的方法，其目的是：

1.了解方法的结构格式

2.了解静态和实例方法之间的区别

3.学会实例对象的使用

4.学会如何调用实例化的对象

5.学会方法的四种参数类型的使用

6.学会使用“this〃引用

以往，对于每个程序来说，所有的工作都在Main。方法中实

现。这对于功能简单的程序是合适的，因为仅仅用来学习一

些概念。有个更好的方法来组织你的程序，那就是使用方法。

方法是很有用的，因为方法可以让你在不同的单元中分开设

计你的逻辑模块。

方法的结构格式如下：

属性修饰符返回值类型方法名（参数）｛语句｝

我们将在后面的课程中，讨论属性和修饰符。方法的返回值

可以是任何一种C#的数据类型，该返回值可以赋给变量，以

便在程序的后面部分使用。方法名是唯一，可以被程序调用。

为使得你的代码变得更容易理解和记忆，方法的取名可以同

所要进行的操作联系起来。你可以传递数据给方法，也可以

从方法中返回数据。它们由大括号包围起来。大括号中的语

句实现了方法的功能。

1.清单5-1.—1K简单的方法：OneMethod.cs

usingSystem;

classOneMethod{

publicstaticvoidMain(){

stringmyChoice;

OneMethodom=newOneMethod();

do{

myChoice=om.getChoice();

//Makeadecisionbasedontheuser'schoice

switch(myChoice){

caseA:

〃〃

casea:

Console.WriteLine(''Youwishtoaddanaddress.z，);

break;

case〃Dn〃:

cased:

Console.WriteLine(''Youwishtodeleteanaddress.;

break;

case〃〃M〃:

〃〃

casem:

Console.WriteLine(''Youwishtomodifyanaddress.，z);

break;

caseV:

〃〃

casev:

Console.WriteLine(Z/Youwishtoviewtheaddresslist.〃);

break;

case〃八Q〃:

case〃q〃:

Console.WriteLine("Bye.〃);

break;

default:

，z，，

Console.WriteLine({0}isnotavalidchoice)myChoice);

)

//Pausetoallowtheusertoseetheresults

Console.Write(''Pressanykeytocontinue...，z)；

Console.ReadLine();

Console.WriteLine();

}while(myChoice!="Q"&&myChoice!=〃q〃);//Keepgoing

untiltheuserwantstoquit

)

stringgetChoice(){

stringmyChoice;

//PrintAMenu

Console.WriteLine(''MyAddressBook\n〃)；

Console.WriteLine(Z/A-AddNewAddress");

Console.WriteLine(，/D-DeleteAddress");

Console.WriteLine(Z，M-ModifyAddress");

Console.WriteLine(，ZV-ViewAddresses");

Console.WriteLine(，ZQ-Quit\n〃)；

Console.WriteLine(''Choice(A,D,M,V,orQ):〃)；

//Retrievetheuser'schoice

myChoice=Console.ReadLineO;

returnmyChoice;

说明

1.清单5-1中的程序类似于第四课中的DoLoop程序。

区别在于：前一课中的程序打印出菜单内容，并在Main。

方法中接受用户的输入，而本课中，该功能用一个名为get

Choice。的方法实现，该方法的返回值类型是个字符串类

型。在main方法中，在switch语句中用到了该串。方法〃g

etChoice〃实现了调用时所完成的工作。方法名后面的括号

内是空的，因为调用getChoiceO方法时，不需要传递任何

数据。

2.在方法块中，我们首先定义了变量〃myChoice〃。

虽然它与Main。方法中的〃myChoice〃变量同名同类型，但

它们是不同的两个变量，因为局部变量仅仅在其定义的块内

可见。换句话说，getChoice()方法中的"myChoice”同Ma

in()方法中的〃myChoice〃变量没有丝毫联系。getChoiceO

方法打印出一个菜单到控制台，并读取用户的输入。〃retur

n〃语句把〃myChoice〃变量值返回给Main。方法中的调用者

getChoiceO0注意：“return”语句返回类型同该方法中定

义的返回值类型相同，本例中，该返回值是个字符串。

3.在Main。方法中，在使用getChoice()之前，实例化了一

个新的"OneMethod”对象。

这是因为：我们没有指明一个〃静态〃修饰符。(注意：MainO

函数带有〃静态〃修饰符)，getChoice()就成为一个实例的方

法。实例方法和静态方法的区别是：前者可以创建多个类

的实例，每个实例有自己的单独的getChoiceO方法。而一

旦方法是静态的，就不存在方法的实例，你只能调用该静态

方法的一个实现。

所以，正如前面所讲的，因为getChoiceO并不是静态的，

所以，我们必须实例化一个新对象来使用它。这是通过定义

“OneMethodom=newOneMethod()〃来进行的。在等号的左

边,是对象引用〃。m〃，其类型是OneMethod。〃onT是个对象

的引用，这点很重要，〃om〃并不是对象自身，它是个引用0

neMethod类型对象的变量。在等号的右边，把新创建的On

eMethod对象赋给引用〃om〃。关键字〃new〃是个在堆上创建

对象的新实例的C#运算符。此处完成的工作是：在堆上创

建一个新的OneMethod实例，并把它赋给om引用。一旦有

了om引用的OneMethod对象实例，就可以通过om引用来对

实例进行处理。

方法，域和其他类成员可以通过〃.〃(点)运算符进行访问，

标识和操纵。一旦需要调用方法getChoiceO,就通过om引

用，并使用点运算符“om.getChoiceO〃来进行。getChoice

0块中的语句执行完毕之后即返回。为了捕捉到getChoic

e()的返回值，我们使用了赋值运算符〃:〃。返回串放到了M

ain()函数的局部变量myChoice中，从那里，程序的其余部

分按照前面课程中介绍的方式正常执行。

2.清单5~2.方法参数：MethodParams.cs

usingSystem;

classAddress{

publicstringname;

publicstringaddress;

)

classMethodParams{

publicstaticvoidMain(){

stringmyChoice;

MethodParamsmp=newMethodParams();

do{

//showmenuandgetinputfromuser

myChoice=mp.getChoice();

//Makeadecisionbasedontheuser'schoice

mp.makeDecision(myChoice);

//Pausetoallowtheusertoseetheresults

Console.Write(^Pressanykeytocontinue...;

Console.ReadLine();

Console.WriteLine();

}while(myChoice!=〃Q〃&&myChoice!="q〃)；//Keepgoing

untiltheuserwantstoquit

)

//showmenuandgetuser，schoice

stringgetChoice(){

stringmyChoice;

//PrintAMenu

Console.WriteLine(，zMyAddressBook\n〃)；

Console.WriteLine(，ZA-AddNewAddress");

Console.WriteLine(Z，D-DeleteAddress");

Console.WriteLine(，ZM-ModifyAddress");

Console.WriteLine(Z，V-ViewAddresses");

Cons