C#學習筆記

 

 1  Ａ．类 :

  2  ●  类与类的使用 :

   3  class A{

  4  public int wheels; // 公有成员

  5  protected float weight; // 保护成员

  6  }

  7  class B{

  8  void F{

  9  A v1=new A(); // 创选类Ａ的实例

  10  v1.wheels=10; // 调用类Ａ的公有成员成功

 11  v1.weight=1.0; // 错，因为此变量为保护成员

 12  }

 13  } 

 14  ●  类的继承 :

 15  类 B 从类 A 中继承

  16  class A{}

 17  class B:A{}

  18  

 19  

 20  Ｂ．静态成员和非静态成员 :

 21  一般说来，静态成员属于类所有的，非静态成员则属于类的实例 -- 对象

 22  （非静态成员在类的每个实例中都占有一个存储（或者说具有一个副本） ,

 23  而静态方法是类所共享的，无法判断当前的非静态属于哪个类的实例 .

 24  引用静态与非静态成员：

  25  int a; // 非静态成员

 26  static int b; // 静态成员

 27  void F(){ // 非静态方法Ｆ

 28  a=1; // 正确，等价于 this.x=1

 29  b=1; // 正确，等价于 Test.y=1

 30  }

 31  static void G(){

 32  a=1; // 错误，不能访问 this.x

 33  b=1; // 正确，等价于 Test.y=1

 34  }

 35  static void  Main (){

 36  Test t=new Test();

  37  t.a=1; // 正确

 38  t.b=1; // 错误，不能在类的实例中访问静态成员

 39  Test.a=1; // 错误，不能在类问非静态成员

 40  Test.y=1; // 正确

 41  }

 42  ●  在同一类的引用

 43  非  访  非 = 直接（可用 this.X ）  静  访  静 = 直

 44  非  访  静 = Test.a  静访非 = 创造实例 =t.a

  45  Test t= newTest(); 创造实例后用 qf.F() 访问 < /FONT>< /FONT> 

 46  

 47  Ｃ． this  保留字在各种结构中的含义 :  实例＝类的结构

  48  　　　  １． ( 类的构造函数 ) 值类型，对构造的对象本身的引用

 49  　　　  ２． ( 类的方法 ) 值类型，对调用该方法的对象的引用

 50  ３． ( 结构的构造函数 ) 变量类型，对构造的结构的引用

 51  ４． ( 结构的方法 ) 变量类型，对方法的结构的引用 

 52  

 53  Ｄ．构造函数析构函数  ( 作用用于执行类的实例的初始化 )

 54  ●  通常与类名相同

 55  ●  不声明反回类型

 56  ●  一般是 public 类型，如是 private 表明类不能被实例化，这通常用于只含有静态成员的类

 57  ●  不要做对类的实例进行初始化以外的事情，也不要尝试显式地调用构造函数

  58  intx=0,y=0,count; // 不带参数的

 59  public A(){

 60  count=0;

 61  }

 62  public A(int vx.int vy){ // 带参数的

 63  x=vx;

 64  y=vy;

 65  } 

 66  

 67  Ｅ．方法

 68  ●  不能与类中的成员名相同

  69  ●  用 abstract 和 extern 修饰方法的执行有一个简单的分号

 70  ●  执行部份通过 return 语句得到返回值 ,return 后不跟任何值，反回的是 void 型

  71  ●  （非静态成员在类的每个实例中都占有一个存储（或者说具有一个副本） ,

 72  而静态方法是类所共享的，无法判断当前的非静态属于哪个类的实例 . 

 73  ●  值参数，给值做一份拷贝

 74  ●  引用型参数 ref

 75  ●  输出参数 out

 76  ●  数组型参数 params （否则提示重载） 

  77  

 78   

 79  

 80  static int max(intx,int y){

 81  if(x>y)

 82  return x; 

 83  else

 84  return y;

 85  }

 86  static void  Main (){

  87  Console.WriteLine(" １０与８那个大 :{0}",max(10,8));

 88  }

 89  

 90  

 91  Ｆ．属性

 92  ●  在Ｃ＃中不直接操作类的数据内容，而是通过访问器进行访问．借助于 get 和 set 对属性的值进行读写

 93  ●  只有 set ，只能设置不能读出

 94  ●  只有 get ，只读不能改写

 95  ●  同时具有 set 和 get ，读写都是允许的．

 96  ●  除使用 abstract 修饰抽象属性，每个访问器的执行体中只有分号 ";", 其它所有属性的 get 访问器都昌通

 97  过 return 来读取属性的值， set 访问器都通过 value 来设置属性的值．

  98  

 99  public class File

100  {

101  private string s_filename;

102  public string Filename{

103  get{ // 读

104  return s_filename;

105  }

106  set{ // 写 

107  if(s_filename!=value){

108  s_filename=value; // 过通 value 设置属性

109  }

110  }

111  }

112  }

113  public class Test

114  {

115  public static void  Main (){

116  File f=new File();

117  f.Filename="myfile.txt";

118  string s=f.Filename;

119  }

120  }

121  

122  

123  Ｇ．接口 ( interface ) 默认为 public 修饰

124  下面的例子定义了一个名为 IControl 的接口，接口中包含一个成员方法 Paint

125  接口 ITextBox 和 IListBox 都从接口 IControl 中继承，承者也就继承了接口 IControl 的 Paint 方法 :

126  using System;

127  interface IControl { void Paint(); }

128  interface ITextBox:IControl { void SetText(string text); }

129  interface IListBox:IControl { void SetItems(string[]items); }

130  interface IComboBox:ITextBox,IListBox{}

131  

132  

133  ★  第十七章　文件操作

134  Ａ．入输出操作的类型

135  １．支持字节的读写操作  System.IO.Stream  包括

136  ●  读操作 Reading 

137  ●  写操作 Writing

138  ●  搜索操作 Seeking ，有些流不支持以上的所有操作，如网络流就不支持搜索操作

139  ２． BinaryReader 和 BinaryWriter 支持从字符串或原始数据到各种流之间的读写操作

140  ３． File 和 Directory 类的基类都是抽象类 FileSystemEntry

141  ● File 对文件的基本操作，包括创建＼拷贝＼移动＼删除和打开一个文件

142  ● Directory 类执行常见的各种目录操作，如创建＼移动＼游戏目录及其子目录

143  ● 

144  ● 

145  

146   

147  

148   

149  

150  类的方法默认为受保护修饰

151  

152   

153  

154   

155  

156  Main() 函数的参数只有两种参数形式：无参数和 string  数组表示的命令行参数，即 static  void  Main() 或 static  void  Main( string []args)  ，后者接受命令行参数。 一个 C# 程序中只能有一个 Main() 函数入口点。其他形式的参数不具有入口点语义， C# 不推荐通过其他参数形式重载 Main() 函数，这会引起编译警告 .

157  Main() 函数返回值只能为 void( 无类型 ) 或 int( 整数类型 ) 。其他形式的返回值不具有入口点语义。

158  

159   

160  

161  a=new  代理 1( 类 1. 方法 1)  // 把类的一个方法赋给 a

162  a(); // 输出  类 1  中一个方法的值

163  ------------ 类修饰符 -------------

164  public // 公有成员，不限制对该类的访问

165  protected // 保护成员，只能从所在类和所在类派生的子类进行访问

166  internal // 内部成员，只有其所在类才能访问

167  private // 私有成员，只有对包 .Net 中的应用程序或库才能访问

168  abstract // 抽象类，不允许建立类的实例

169  sealed // 密封类，不允许被继承

170  ------------- 方法修饰符 ----------

171  new

172  public

173  protected

174  internal

175  private

176  static

177  virtual // 虚方法

178  sealed

179  override // 派生类中声明虚方法

180  abstract

181  extern

182  ---------------------------------

183  

184  

185  一、数据类型

186  

187  1. 整数类型

188  短字节型（ sbyte ）、字节型（ byte ）、短整型（ short ）、无符号短整型（ ushort ）、

189  整型（ int ）、无符号整型（ uint ）、长整型（ long ）、 

190  

191  2. 布尔类型

192  ' 真 ' 或 ' 假 '  用 true 和 false 表示 

193  

194  3. 实数类型

195  浮点类型 :  单精度（ float ）和双精度（ double ）

196  十进制类型（ decimal ）  // 定义十进制变量并赋值时 , 用 m 下标表明它是十进制类型 . 如省略了 m 下标 ,

197  // 在被赋值前 , 它将被编译器当作双精度处理。如： decimal d_value=1.0m;

198  4. 字符类型

199  char c='A'; // 字符类型采用了国际 gb2312 字符集标准 . 一个 gb2312 的标准字符长度为 16 位 .

200  

201  5. 结构类型

202  struct // 程序设计中经常要把一组相关的信息放在一起 . 一系列相关的变量组织成为单一实体的过程，

203  // 称为生成结构的过程 . 这个单一实体的类型我们就叫做结构类型 , 每一个变量称为结构的成员。

204  // 结构类型采用 struct 来声明 . 下面代码定义一个通讯录记录结构 ( 包括姓名、电话和地址 ) 的定义。

205  　　  Struct PhoneBook{

206  　　  public  string  name;

207  　　  public  string  phone;

208  　　  public  string  address;

209  　　  }

210  　　  PhoneBook p1;

211  //p1 就是一个通讯录（ PhoneBook ）结构类型的变量 . 声明中的 public 表示对结构类型成员的访问权限

212  // 访问结构成员可通过结构变量名加上访问符 "." 号，后跟成员的名称  赋值给成员如： p1.name= "tom";</FONT>< /FONT>

213  

214  6. 枚举类型

215  枚举（ enum ）实际上是为一组在逻辑上密不可分的整数值提供便于记忆的符号。下面的程序代码声明了一个代表星期的枚举类型的变量。

216  　　  Enum WeekDay{

217  　　  Sunday ， Monday ， Tuesday ， Wednesday ， Friday ， Saturday

218  　　  };

219  　　  WeekDay day;

220  　　  注意：枚举类型的变量在某一时刻只能取枚举中某一个元素的值。如， day 这个表示 “ 星期 ” 的枚举的变量，它的值要么是 Sunday ，要么是 Monday 或其他的星期元素，但它在一个时刻只能代表具体的某一天，不能既是星期二，又是星期三。

221  　　  Day=Tuseday;

222  　　  按照系统默认，枚举中的每个元素都是整型（ int ），且第一个元素删去的值为 0 ，它后面的每一个连续的元素的值按加 1 递增。在枚举中，也可以给元素直接赋值。下面的程序代码把星期一的值设为 1 ，其后的元素的值分别为 2 ， 3……

223  　　  enum  WeekDay{

224  　　  Sunday=1 ， Monday ， Tuesday ， Wednesday ， Friday ， Saturday

225  　　  };

226  　　  为枚举类型的元素所赋值的值的类型限于 long 、 int 、 short 和 byte 等整数类型。

227  

228  

229  二、引用类型

230  引用的含义是该类型的变量不直接存储所包含的值，而是指向它所要存储的值。

231  即引用类型存储实际数据的引用值的地址。  C# 中的引用类型有四种：  类  代表  数组  接口 

232  

233  1.  类是面向对象编程的基本单位，是一种包含数据成员、函数成员和嵌套类型的数据结构 . 类和结构最主要的区别在于：类是引用类型 , 而结构是值类型 . 类支持继承机制，通过继承，派生类可以扩展基类的数据成员和函数成员，进而达到代码重用和设计重用的目的。下面介绍两个经常用到的类：

234  　　  object 类：它是所有其他类型的基类， C# 中的所有类型都直接或是间接地从 object 类中继承。因此，对一个 object 的变量可以赋予任何类型的值。

235  　　  Int x=25;

236  　　  object  obj1;

237  　　  obj1=x;

238  　　  object  obj2='A';

239  　　  对 object 类型的变量声明采用 object 关键字，这个关键字是在 .NET 平台中为我们提供的预定义的名字空间 System 中定义的，是类 System.Object 的别名。 

240  

241  

242  String 类：专门用于对字符串的操作。同样，这个类也是在 .NET 平台中为我们提供的预定义的名字空间 System 中定义的，是类 System.String 的别名。

243  　　  字符串在实际中应用非常的广泛，在类的定义中封装了许多内部的操作，我们只要简单地加以利用就可以了。可以用加号 “+” 合并两个字符串，采用下标从字符串中获取字符等。

244  　　  String String1="Welcome";

245  　　  string  String2="Welcome"+"everyone";  ///  连接字符

246  　　  char  c=String1[0];  ///  把变量 String1 的第一个字符赋给 c

247  　　 boolb=(String1==String2);  ///  执行布而运算 , 两值相等赋值 True , 不等赋值 False

248  

249  

250  2. 代表

251  　　  在 C# 中取消了 C 和 C++ 中的指针的这个概念。而代表实际上相当于是 C# 中的函数指针原型，与指针不同的是，代表在 C# 中是类型安全的 . 在声明代表时，只需要指定代表指向的原型的类型，它不能有返回值，也不能带有输出类型的参数。如我们可以声明一个指向 int 类型函数原型的代表：

252  　　  delegate  int  MyDelegate();

253  　　  如果我们声明了自己的一个代表，那么它就是对系统定义的类 System.deldgate 的一个扩展。

254  

255  

256  3. 数组

257  　　  在进行批量处理数据的时候，我们要用到数组。数组是一组类型相同的有序数据。数组按照数组名、数据元素的类型和维数来进行描述。 C# 中提供 Ststem.Array 类是所有数组类型的基类。

258  　　  数组的声明格式为：

259  　　  non-array-type ［ dim-separators ］  array-instance name;

260  　　  比如我们声明一个整数数组：

261  　　  int ［］ arr;

262  　　  在定义数组时，可以预先指定数组元素的个数，这时在 “ ［］ ” 中定义数组的元素个数，它的个数可以通过数组名加圆点加 “Length” 获得。而在使用数组时，可以在 “ ［］ ” 中加入下标来取得对应的数组元素。 C# 中的数组元素的下标是从 0 开始的，以后递增。

263  　　  在 C# 中数组可以是一维的也可以是多维的，同样也支持矩阵和参差不齐的数组。其中一维数组最为普遍，用得也最多。

264  　　  Class Tese

265  　　  {

266  　　  static  void  Main （） {  // 可动态生成数组的长度

267  　　  string ［］  a1;  // 一维数组 string

268  　　  string ［］  a2;  // 二维数组 string

269  　　  string ［］  a3;  // 三维数组 string

270  　　  }

271  　　  } 

272  

273  4. 接口

274  　　  接口定义了一个协议（ conrtact ）。一个类或结构要实现接口就必须坚持这种协议。接口可以包括方法、属性、索引和事件作为成员。下面的程序代码说明了一个接口，它包含一个索引、一个事件 E 、一个方法 F 和一个属性 P 。

275  　　  Interface Iexampie

276  　　  {

277  　　  string  this ［ int  index ］ { get ;  set ;} ＼

278  　　  event  EventHandler E;

279  　　  void  F （ int  value ） ;

280  　　  string  P{ get ;  set ;}

281  　　  }

282  

283  

284  三、变量与常量

285  Variable // 使用变量的一条重要的原则是：变量必须先定义后使用

286  变量的类型

287  　　  在 C# 中，我们把变量分为七种：静态变量、非静态变量、局部变量、数组元素、值参数、引用参数和输出参数等。

288  　　  静态变量：带有 “ static ” 修饰符声明的变量称为静态变量。一旦静态变量所属的类被装载，该类程序结束后变量的值被采放。静态变量就是该变量类型的默认值。静态变量最好是在定义时便赋值。如 static a =10;

289  　　  非静态变量：不带有 “ static ” 修饰符声明的变量称其为实例变量。如 int a; 类中的非静态变量，一旦一个类的新的实例被创建，直到该实例不再被应用从而所在空间被释放为止，该非静态变量将一直存在。同样鉴于定义赋值检查，一个类的非静态变量也应该是在初始化的时候赋值。

290  　　  数组元素：数组元素也是变量的一种，该变量随该数组实例的存在而存在。每一个数组元素的初始值是该数组元素类型的默认值。同样地，鉴于定义赋值检查，数组元素最好是在初始化的时候被赋值。

291  　　  局部变量：局部变量是指在一个独立的程序块中，一个 for 语句、 switch 语句或者 using 语句中声明的变量，它只在该范围内有效。当程序运行到这个范围内时，该变量即开始生效，程序离开时变量失效。与其他几种变量类型不同的是，局部变量不会自动被初始化，所以也就是没有默认值。在进行赋值检查时，局部变量被认为没有被赋值。

292  　　  在局部变量的有效范围内，在变量的定义以前就使用是不合法的。如下面的代码：

293  　　  for （ int  I=0;I<10;I++ ） {

294  　　  int  num=a;  // 这是非法的，因为局部变量 a 还没有被定义

295  　　  int  a;

296  　　  int  b=a;

297  　　  }

298  　　  有关值参数、引用参数和输出参数在这里我们不作讨论，有兴趣的读者可以参看相关的书藉。 

299  

300  常量声明的格式如下：

301  　　  attributes constant-modifiers  const  type constant-declarators;

302  　　  其中：常量修饰符 constant-modifiers 可以是： new 、 public 、 protected 、 internal 、 private 。

303  　　  常量的类型 type 必须是下面中的一种：

304  　　  sbyle 、 byte 、 short 、 ushort 、 int 、 uint 、 ulong 、 char 、 float 、 double 、 decimal 、 bool 、 string 或是引用类型（ reference-type ）。

305  　　  常量表达式 constant-declarators 表示常量的名字。

306  　　  如： public  const  double  X=1.0 ， Y=2.0 ， Z=3.0;

307  

308  四、表达式

309  1. 操作符的分类

310  　　  表达式由操作数和操作符组成。表达式的操作符指出了对操作数的操作。比如操作符有 + 、 — 、 / ；操作数可以是文字、域、当前变量或表达式。

311  依照操作符作用的操作数的个数来分， C# 中有一元操作符：作用于一个操作数，包括前缀操作符和后缀操作符；二元操作符：作用于两个操作数，使用时在操作数中插入操作符；三元操作符：只有一个操作符 “?:” 。作用于三个操作数，使用时在操作数中间插入操作符。

312  　　  下面分别给出使用操作符的例子：

313  　　 intx=5 ， y=10 ， z;

314  　　  x++;  // 后缀一元操作符

315  　　  --x ；  // 前缀一元操作符

316  　　  z=x+y;  // 二元操作符

317  　　  y= （ X>10?0:1 ） ;  // 三元操作符

318  　　  2. 操作符的优先级

319  　　  当一个表达式包含多样操作符时，操作符的优先级控制着单个操作符求值的顺序。例如，表达式 x+y*z 按照 x+ （ y*z ）求值，因为 “*” 操作符比 “+” 操作符有更高的优先级。下表给出了所以操作符从高到底的优先级顺序。

320  　　  （ ^60090201h^ ） < br> 　　当一个操作数出现在两个有相同优先级的操作符之间时，操作符按照出现的顺序由左至右执行。除了赋值的操作符，所有的二进制操作符都是按照从左向右的顺序执行。如 x+y+z 按（ x+y ） +z 进行。 <br> 　　赋值操作符和条件操作符（ ?: ）按照从右向左的顺序执行。如 x=y=z 按照 x= （ y=z ）进行。

321  　　  建议：在写表达式时，如果无法确定操作符的有效顺序，则尽量采用括号来保证运算的顺序，这样也使得程序一目了然，而且自己在编程时能够思路清晰。

322  

323  

324  五、流程控制

325  1. 条件语句

326  当程序中需要进行两个或两个以上的选择时，可以根据条件判断来选择将要执行的一组语句。 C# 提供的选择语句有 if 语句和 switch 语句。

327  　　  （ 1 ） if 语句

328  　　  if 语句是最常用的选择语句，它根据布尔表达式的值来判断是否执行后面的内嵌语句。其格式为：

329  　　  if （ boolean-expression ） embedded-statement 或

330  　　  if （ boolean-expression ） embedded-statement

331  　　  else  embedded-statement

332  　　  当布表达式的值为真时，则执行 if 后面的内嵌语句 embedded-statement 。为假时则程序继续执行。如果有 else 语句时，则执行 else 后面的内嵌语句，否则继续执行下一条语句。

333  　　  If  （ x- int （ x ） >0.5

334  　　  {

335  　　  I= int （ x ） +1 ；

336  　　  }

337  　　  else

338  　　  {

339  　　  I= int （ x ）

340  　　  }

341  　　  如果 if 或者 else 之后的嵌套语句只包含一条执行语句，则嵌套部分的大括号可以省略。如果包含了两条以上的执行语句，对嵌套部分一定要加上大括号。

342  　　  如果程序的逻辑判断关系比较复杂，通常会采用条件判断嵌套语句。 If 语句可以嵌套使用，即是在判断之中又有判断。具体的形式如下：

343  　　  if （ boolean-expression ）

344  　　  {

345  　　  if （ boolean-expression ）

346  　　  {……} ；

347  　　  else

348  　　  {……};

349  　　  ……

350  　　  }

351  　　  else

352  　　  {

353  　　  if （ boolean-expression ）

354  　　  {……};

355  　　  else

356  　　  {……}

357  　　  ……

358  　　  }

359  　　  此时应注意，每一条 else 与离它最近且没有其他 else 与之对应的 if 相搭配。

360  　　  （ 2 ） Switch 语句

361  　　  if 语句每次判断只能实现两条分支，如果要实现多种选择的功能，那么可以采用 Switch 语句。 Switch 语句根据一个控制表达式的值选择一个内嵌语句分支来执行。它的一般格式为：

362  　　  switch （ controlling-expression ）

363  　　  {

364  　　  case  constant-expression;

365  　　  embedded-statements

366  　　  default ;

367  　　  embedded-statements

368  　　  }

369  　　  Switch 语句的控制类型，即其中控制表达式（ controlling-expression ）的数据类型可以是 sbyle 、 byte 、 short 、 short 、 uint 、 long 、 ulong 、 char 、 string 或是枚举类型（ rnum-type ）。每个 case 标签中的常量表达式（ constant-expression ）必须属于或能隐式转换成控制类型。如果有两个或两个以上 case 标签中的常量表达式值相同，编译时将报错。 Switch 语句中最多只能有一个 default 标签。

370  　　  下面的程序代码说明 Swtich 语句按所提供参数的数字执行不同的语句。

371  　　  using  system;

372  　　  class  Test

373  　　  {

374  　　  static  void  Main  （ string ［］  args ）  {

375  　　  switch  （ args.Length ）  {

376  　　  case  0;

377  　　  Console.WriteLine  （ "No arguments were provided" ） ;

378  　　  break ;

379  　　  case  1;

380  　　  Console.WriteLine  （ "One arguments was provided" ） ;

381  　　  break ;

382  　　  default ;

383  　　  Console.WriteLine  （ "{0} arguments were provided" ） ;

384  　　  break ;

385  　　  }

386  　　  }

387  　　  }

388  　　  2. 循环语句

389  　　  循环语句可以实现一个程序模块的重复执行，它对于我们简化程序，更好地组织算法有着重要的意义。 C# 提供了四种循环语句： While 语句、 do -while 语句、 for 语句、 foreach 语句。

390  　　  （ 1 ） While 语句

391  　　  While 语句有条件地将内嵌语句执行 0 遍或若干遍。其格式为：

392  　　  while  （ boolean-expression ）  embedded-statement

393  　　  其执行的顺序是：

394  　　  首先计算表达式 boolean-expression 的值；当布尔表达式的值为真时，执行语句 embedded-statement 一遍，程序转至第 1 步；当布尔表达式的值为假时， while 循环结束。

395  　　  （ 2 ） do -while 语句

396  　　  do -while 语句与 while 语句不同的是，它将内嵌语句执行一次（至少一次）或若干次。其格式为：

397  　　  do  embedded-statement  while （ boolean-expression ）

398  　　  其执行的顺序是：

399  　　  首先执行内嵌语句 embedded-statement 一遍；当布尔表达式的值为真时则回到第 1 步，为假时则终止 do 循环。

400  　　  在 do-while 循环语句中同样允许用 break 语句和 continue 语句实现与 while 语句中相同的功能。

401  　　  （ 3 ） for 语句

402  　　  for 语句是 C# 中使用频率最高的循环语句。在事先知道循环次数的情况下，使用 for 语句是比较方便的。其格式为：

403  　　  for （ inttializer ， condinton;iterator ） embedded-statement

404  　　  其中 inttializer 、 condinton 、 iterator 三项是可选项。 Inttializer 为循环控制变量做初始化，循环控制变量可以有一个或多个（用逗号隔开）； condinton 为循环控制条件，也可以有一个或多个语句； iterator 按规律改变控制变量的值。

405  　　  其执行的顺序是：

406  　　  首先按照书写顺序将 inttializer 部分（如果有）执行一遍，为循环控制变量赋初值；然后测试 condinton （如果有）中的条件是否满足；若没有 condinton 项或条件满足，则执行内嵌语句一遍，按 iterator 改变循环控制变量的值，回到第 2 步执行；若条件不满足，则 for 循环终止。

407  　　  下面的程序代码说明用一个 for 语句写出整数 1 ～ 10 。

408  　　  Using System;

409  　　  class  Test

410  　　  {

411  　　  static  void  Main （） {

412  　　  for  （ int  I=0; I<10; I++ ）

413  　　  Console.WriteLine （ I ） ;

414  　　  }

415  　　  }

416  　　  （ 4 ） foreach 语句

417  　　  foreach 语句是在 C# 中新引入的。 它表示收集一个集合中的各元素，并针对各个元素执行内嵌语句。其格式为：

418  　　  foreach （ type identifier  in  expression ） embedded-statement

419  　　  其中类型（ type ）和标识符（ identifier ）用来声明循环变量，表达式（ expression ）对应集合。每执行一次内嵌语句，循环变量就依次取集合中的一个元素代入其中。在这里，循环变量只是一个只读型局部变量，如果试图改变它的值或将它作为一个 ref 或 out 类型的参数传递时，都将引发编译出错。

420  　　  Foreach 语句中的 expression 必须是集合类型，如果该集合的元素类型与循环变量类型不一样，则必须有一个显示定义的从集合中的元素类型到循环变量元素类型的显示转换。

421  　　  下面的程序代码说明用一个 foreach 语句来循环显示列表中的元素。

422  　　  Using System;

423  　　  using  System.Collections;

424  　　  class  Tese

425  　　  {

426  　　  static  void  WriteList （ Arraylist list ） {

427  　　  foreach （ object  o  in  list ）

428  　　  Console.WriteLine （ o ） ;

429  　　  }

430  　　  static  void  Main （） {

431  　　  ArrayList list= new  ArrayList （） ;

432  　　  for （ int  I=0; I<10; I++ ）

433  　　  list.Add （ I ） ;

434  　　  WriteList （ list ） ;

435  　　  }

436  　　  }

437  　　  3. 转子语句

438  　　  （ 1 ） break 语句和 continue 语句

439  　　  break 语句用来退出最近的 switch 、 while 、 do 、 for 、 foreach 语句的循环，而 continue 语句用来开始一个新的 while 、 do 、 for 和 foreach 语句的循环。

440  　　  （ 2 ）标签声明和 goto 声明

441  　　  标签声明可以交替声明， goto 声明可以把控制传送到标签声明。

442  　　  （ 3 ） return 语句

443  　　  返回对语句中的成员控制。无表达式的 return 语句只能在无返回值的成员中应用。带表达式的 return 语句只能在返回表达式的函数成员中运用。

444  　　  （ 4 ） throw 语句与 try 语句

445  　　  throw 语句用来抛出异常。 Try 语句提供一个在程序块执行过程中捕获异常的机制。此外， try 语句还提供当 try 语句脱离控制时总是要执行的代码块。

446  　　  （五）异常处理

447  　　  程序中对异常的处理能使你的程序更加强壮。现在的许多程序设计语言都增加了异常处理的能力， C# 也不例外。

448  　　  1. 异常处理语句

449  　　  C# 中的异常处理语句有三种形式： try - catch  捕捉异常、 try - finally  清除异常、 try - catch - finally  处理所有异常。

450  　　  下面的一段代码处理溢出异常：

451  　　  try {

452  　　  for （ ;n<=max;n++ ）

453  　　  sum*=n;

454  　　  }

455  　　  catch （ OverfolwException oe ）

456  　　  {

457  　　  Console.WriteLine （ “ 溢出 “ ） ;

458  　　  return ;

459  　　  }

460  　　  2. 清除异常

461  　　  try - finally  结构将清除异常。看下面的代码：

462  　　  try {

463  　　  for （ ;n<=max;n++ ）

464  　　  sum*=n;

465  　　  }

466  　　  finally

467  　　  {

468  　　  Console.WriteLine （ “ 溢出 “ ） ;

469  　　  return ;

470  　　  }

471  　　  上面的代码中 finally  子句中的代码在任何情况下总会被执行，即使没有异常发生。

472  　　  3. 处理所有异常

473  　　  try - catch - finally  处理所有的异常。如下面的代码：

474  　　  try {

475  　　  for （ ;n<=max;n++ ）

476  　　  sum*=n;

477  　　  }

478  　　  catch （ OverfolwException oe ）

479  　　  {

480  　　  Console.WriteLine （ “ 溢出 “ ） ;

481  　　  return ;

482  　　  }

483  　　  catch （ Exception e ）

484  　　  {

485  　　  // 捕捉所有异常

486  　　  }

487  　　  finally

488  　　  {

489  　　  }

490  　　  4. 抛出异常

491  　　  程序中我们可以先抛出异常，然后进行捕捉。

492  　　  抛出异常的语法如下：

493  　　  throw  new  Exception （）