1 using System;
 2 public class TestDoWhile
 3 {
 4     public static void Main ()
 5     {
 6         int x = 0;
 7         do
 8         {
 9             Console.WriteLine(x);
10             x++;
11         }
12         while (x < 5);
13     }
14 }
输出：0 1 2 3 4 

2.4  While

　　当 while 语句中的判断条件为 true 时，循环体将一直循环执行。

　　语法：

while (expression)

{

   statement

}

while 语句和 do-while 语句不同，do-while 是先执行循环体再判断条件，而 while 是先判断条件。如果条件为 true，则执行循环体，否则将跳过循环体，执行 while 块后面的代码。因此，while 语句中的循环体可能执行 0 次或多次。

　　在 while 循环体中，可以使用 break、goto、reture 或 throw 语句跳出循环。如果要跳转到下一次循环，可在循环体中使用 continue 语句。

3. 跳转语句

　跳转语句用于从程序的一个地方把执行控制转移到另一个地方，每一条跳转语句的应用都会增加程序执行流程的分支。

　　C#语言中可使用以下4种跳转语句：

　　· break

　　· continue

　　· goto

     · return

3.1  break 语句

　　break 语句用于中止当前执行的循环或它所在的 switch 语句，把控制交给循环或 switch 结构后面的语句。

　　示例：

　　在此例中，条件语句包含一个应该从 1 计数到 100 的计数器；但 break 语句在计数达到 4 后终止循环。

 1 using System;
 2 class BreakTest
 3 {
 4     static void Main()
 5     {
 6         for (int i = 1; i <= 100; i++)
 7         {
 8             if (i == 5)
 9             {
10                 break;
11             }
12             Console.WriteLine(i);
13         }
14     }
15 }

输出：

1

2

3

4

3.2  continue 语句

　　在循环体中使用 continue 语句将结束当前的循环，而进入下一次的循环。

　　示例：在此示例中，计数器最初是从 1 到 10 进行计数，但通过将 continue 语句与表达式 (i < 9) 一起使用，跳过了 continue 与 for 循环体末尾之间的语句。

 1 using System;
 2 class ContinueTest
 3 {
 4     static void Main()
 5     {
 6         for (int i = 1; i <= 10; i++)
 7         {
 8             if (i < 9)
 9             {
10                 continue;
11             }
12             Console.WriteLine(i);
13         }
14     }
15 }

输出：

9

10

3.3  goto 语句

　　goto 语句将程序控制直接交给标记的语句。

3.4  return 语句

　　return 语句终止所在方法的执行，并将程序的控制返回给调用它的方法。它还可以返回一个可选值。如果方法为 void 类型，可以省略 return 语句。

　　return语句的形式如下：

　　　　return [expression];

　　其中：

　　expression 表示方法的返回值。当方法类型为 void 时不能使用 expression 参数。

4.1  checked 语句 

　　checked 关键字用于对整型算术运算和转换显式启用溢出检查。

　　默认情况下，如果表达式产生的值超出了目标类型的范围，则常数表达式将导致编译时错误，而非常数表达式在运行时计算并将引发异常。不过，如果通过编译器选项或环境配置在全局范围内取消了溢出检查，则可以使用 checked 关键字来启用此项功能。

示例：此示例演示如何对非常数表达式使用 checked。在运行时会报告溢出。 

 1 using System;
 2 class OverFlowTest
 3 {
 4     static short x = 32767;   // short类型的最大值
 5     static short y = 32767;
 6     // 对表达式使用 checked
 7     static int CheckedMethod()
 8     {
 9         int z = 0;
10         try
11         {
12             z = checked((short)(x + y));
13         }
14         catch (System.OverflowException e)
15         {
16             Console.WriteLine(e.ToString());
17         }
18         return z;
19     }
20     static void Main()
21     {
22         Console.WriteLine("Checked output value is: {0}",
23                      CheckedMethod());
24     }
25 }

示例输出：

System.OverflowException: Arithmetic operation resulted in an overflow.

   at OverFlowTest.CheckedMethod()

Checked output value is: 0

4.2  unchecked 语句 

　　unchecked 关键字用于取消整型算术运算和转换的溢出检查。

　　在非检查情况下，如果表达式产生目标类型范围之外的值，则结果被截断。例如：

1 unchecked
2 {
3     int val = 2147483647 * 2;
4 }

　　因为上面的计算在 unchecked 块中执行，所以结果对于整数来说太大这一事实被忽略，并且 val 被赋予值 -2。默认情况下，启用溢出检测，这与使用 checked 具有相同的效果。

　　在上面的示例中，如果省略 unchecked，将产生编译错误，因为表达式使用常数，结果在编译时是已知的。unchecked 关键字还取消对非常数表达式的溢出检测，这是为了避免在运行时导致 OverflowException。

　　unchecked 关键字还可以用作运算符，如下所示：

1 public int UncheckedAdd(int a, int b)
2 {
3     return unchecked(a + b);
4 }

　　示例：此示例通过在常数表达式中使用 unchecked，显示如何使用 unchecked 语句。

 1 using System;
 2 class TestClass
 3 {
 4     const int x = 2147483647;   // Max int
 5     const int y = 2;
 6     static void Main()
 7     {
 8         int z;
 9         unchecked
10         {
11             z = x * y;
12         }
13         Console.WriteLine("Unchecked output value: {0}", z);
14     }
15 }

输出：

Unchecked output value: -2

5.  非保护和固定

　　C# 中的语句可以在保护和非保护环境中运行，默认状态为保护环境。使用带指针的代码要求运行在非保护环境中。

　　关键字 unsafe：指定非保护环境。

　　使用了指向变量的指针，该变量就不能在内存中移动位置。这时，可使用fixed语句“固定”住这个变量。

　　关键字 fixed：防止变量重新定位。

6.  锁定语句

　　lock 关键字将语句块标记为临界区，方法是获取给定对象的互斥锁，执行语句，然后释放该锁。

7. 异常处理语句 

 try - catch - finally

try里面是执行代码,其中的代码"可能"产生异常.
catch是对产生异常后的处理代码,可以抛出异常,也可以显示异常,也可以弹出某中提示,总之catch里是任何代码都行,如果你知道这钟异常产生的原因,可以打印此原因,也可以对此原因进行相应的处理,同时可以为多个catch,每个catch(异常类型) 用多个catch来捕获多种异常,也可以用所有异常的父类来捕获(这样就不用写多个catchl了).
假如try中产生了异常,那么try从产生异常开始到try结束的这段代码将不会执行,转而去执行catch.
finally是try执行完后执行(没发生异常)或者在catch后执行(发生了异常),也就是说finally无论怎么样,都会执行.