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（） 
494