您的位置:时时app平台注册网站 > 编程知识 > C#幼功之流程序调控制语句精解【时时app平台注册

C#幼功之流程序调控制语句精解【时时app平台注册

2019-11-21 02:23

continue语句:终止当前循环,重新开始一个新的循环。

        <如果<testVar>等于<comparisonValN>时执行的语句>

  expression 表示对象集合或数组表达式。集合元素的类型必须可以转换成 identifier 的类型。

 

3.4  return 语句

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

二、条件语句
条件语句可以根据条件是否满足或者根据表达式的值控制代码的执行分支。C#有两种控制控制代码分支的结构,分别是if语句和switch语句。
if语句
注意:if语句的条件可以是布尔变量,也可以是表达式,但如果是表达式,则表达式得到的结果必须是布尔值。
1、单选择if语句,即条件成立执行,语法如下:
if(条件)
{
    do;
}

3.1  break 语句

  else

三、循环语句
循环就是重复执行语句,循环结构可以实现一个程序模块的重复执行,它对我们简化程序、更好的组织算法有着重要的意义。
1、do循环
do循环的结构如下:
do
{
    语句或语句块;
}while (表达式);
do循环先执行语句或语句块,然后再判断表达式的值,如果表达式的值为true,则继续执行循环,直到表达式的值为false。注意:do循环刚执行的时候不管表达式的值为true或者是false它都要先执行一次语句或语句块,然后再来判断表达式的值。也就是说如果一开始表达式的值为false,它也会执行一次循环。do循环无论布尔表达式的值是true还是false,语句或语句块至少会执行一次。另外while语句后面必须使用分号(;)。

输出:

 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 }

return语句:跳出循环及其包含的函数。

{

 1 // Nested search loops
 2 
 3 using System;
 4 public class GotoTest1{   
 5     static void Main()
 6     {
 7         int x = 200, y = 4;
 8         int count = 0;
 9         string[,] array = new string[x, y];
10         // Initialize the array:
11         for (int i = 0; i < x; i  )
12             for (int j = 0; j < y; j  )
13                 array[i, j] = (  count).ToString();
14         // Read input:
15         Console.Write("Enter the number to search for: ");
16         // Input a string:
17         string myNumber = Console.ReadLine();
18         // Search:
19         for (int i = 0; i < x; i  )
20         {
21             for (int j = 0; j < y; j  )
22             {
23                 if (array[i, j].Equals(myNumber))
24                 {
25                     goto Found;
26                 }
27             }
28         }
29         Console.WriteLine("The number {0} was not found.", myNumber);
30         goto Finish;
31     Found:
32         Console.WriteLine("The number {0} is found.", myNumber);
33     Finish:
34         Console.WriteLine("End of search.");
35     }
36 }

5、无限循环
在代码编写错误或者故意进行设计时,可以定义永不终止的循环,即所谓的无限循环。示例:
while(true)
{
    语句或语句块;
}
无限循环语句也是有用的,而且可以使用break语句或者手工使用Windows任务管理器退出无限循环。

for ([initializers]; [expression]; [iterators])

  · unchecked   指定非检查。

4、foreach循环
foreach语句用于枚举一个集合的元素,并对该集合中的每一个元素执行一次嵌入语句。foreach循环的结构如下:
foreach(<类型> <迭代变量名> in <集合>)
{
    语句或语句块;
}
注意:迭代变量的类型必须与集合的类型相同。集合内元素的个数决定循环内程序段重复执行的次数,每次进入循环,会依次将集合元素内容指定给变量,当所有元素都读完后,就会跳出foreach循环。foreach循环对集合内元素进行只读访问,不能改变任何元素的值。foreach循环在循环的过程中不能对集合进行添加元素或者删除元素的操作。示例:

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

  · goto

            //将1到10打印到屏幕上
            for (int a =1 ; a <= 10; a  )
            {
                Console.WriteLine(a);
            }            
            Console.ReadKey();

  集合类型:

 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 }

C#程序的执行都是一行接一行、自上而下地进行,不遗漏任何代码。为了让程序能按照开发者所设计的流程进行执行,必然需要进行条件判断、循环和跳转等过程,这就需要实现流程控制。C#中的流程控制包含了条件语句、循环语句、跳转语句和异常处理四个方面。
一、跳转语句
break语句:终止并跳出循环体。

        <如果<testVar>等于<comparisonVal1>时执行的语句>

{

四、异常处理
C#中的异常处理也算一种流程控制,try…catch…finally语句用于异常的捕获和处理,具体语法如下:
try
{
    语句或语句块;
}
catch(<execptionType> e)
{
    语句或语句块;
}
finally
{
    语句或语句块;
}
try:包含抛出异常的代码。
catch:包含抛出异常时要执行的代码。catch块可以使用<execptionType>设置为只响应特定的异常类型,以便提供多个catch块。
finally:包含始终会执行的代码,如果没有产生异常,则在try块之后执行,如果处理了异常,就在catch块后执行。
try…catch…finally语句的执行顺序依次是:
1、try块在发生异常的地方中断程序的执行。
2、如果有catch块,就检查该块是否匹配已抛出的异常类型。如果没有catch块,就执行finally块(如果没有catch块,就一定要有finally块)。
3、如果有catch块,但它与已发生的异常类型不匹配,就检查是否有其他catch块。
4、如果有catch块匹配已发生的异常类型,就执行它包含的代码,再执行finally块(如果有)。
5、如果catch块都不匹配已发生的异常类型,就执行finally块(如果有)。
从try…catch…finally语句的执行顺序可以看出try…catch…finally语句有多种组合模式,这里就不详细讲解。

时时app平台注册网站 1

{

 

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

· foreach-in

            int a = 2;
            switch (a)
            {
                case 1:                         
                case 2:                              
                case 3:
                    Console.WriteLine("1或者2或者3");
                    break;
                default:
                    Console.WriteLine("4");
                    break;                

            }

  例如下面的 foreach 语句:

  type 表示 identifier 的类型。

2、ifelse语句,即条件成立执行A否则执行B,语法如下:
if(条件)
{
    do A;
}
else
{
    do B;
}
延伸:三元运算符?:也相当于一个ifelse语句,语法如下:<表达式> ? <resultIfTrue>  : <resultIfFalse>  其中计算表达式可得到一个布尔值,
运算符的结果根据这个值来确定是<resultIfTrue>,还是<resultIfFalse>。例:

}

Unchecked output value: -2

通常情况下switch语句中一个case语句处理完成后,不能自由的进入下一个case语句,但是这个规则有一个例外。如果把多个case语句放在一起,其后面加一个代码块,实际上是一次检查多个条件,如果满足这些条件中的任何一个,就会执行代码,例如:

It's 1, 2, or 3.

 

3、多选择if语句,即对多个条件进行判断,成立的执行,语法如下:
if(条件1)
{
    do A;
}
else if(条件2)
{
    do B;
}
else if(条件3)
{
    do C;
}
else
{
    do D;
}
其中else if语句的个数不受限制,但是如果else if语句的个数较多,则应该考虑另一种分支结构:switch语句。
注意:多选择if语句自上而下,只要有一个条件成立就不会去判断其它任何条件。

  int a,b,c;

        break;

以上程序中的foreach语句在输出集合strList中的第一元素并将其移除集合后进行下一次循环的时候会产生异常。

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

4.1  checked 语句 

2、while循环
while循环的结构如下:
while(表达式)
{
    语句或语句块;
}
while循环则是先判断表达式的值,然后再执行语句或语句块,直到表达式的值为false。如果循环刚开始表达式的值就为false,那么语句或语句块就不会被执行。

 try - catch - finally

  例如,下面的代码创建一个名为 numbers 的数组,并用 foreach 语句循环访问该数组:

goto语句:跳转到指定位置。
C#允许给代码行加上标签,这样就可以使用goto语句直接跳转到这些代码行上。goto语句的用法如下:
goto<labelName>;
标签用下述方式定义:
<labelName>:
goto语句有两个限制,不能跳转到像for循环这样的代码块中,也不能跳出类的范围,不能退出try…catch语句后面的finally块。
这里讲解goto语句只为了解其语法,当遇到时能知道代码的意思,本人不建议使用。

 

3

3、for循环
for循环的结构如下:
for(<初始化表达式>;<条件表达式>;<迭代表达式>)
{
    语句或语句块;
}
初始化表达式:可以在该位置定义一个变量并为其赋一个起始值,也可以使用for循环前面定义的变量,但是使用for循环前面定义的变量必须在该位置为其重新赋一个起始值。注意:在该位置定义一个变量并为其赋一个起始值,这种用法定义的变量的作用域仅在for循环语句中,也就是说for循环语句后面的代码就不能使用该变量;但是用for循环前面定义的变量这种用法定义的变量for循环语句后面的代码就也能使用该变量。
条件表达式:它是循环继续或者终止的条件。
迭代表达式:执行完语句或语句块后就执行迭代表达式,然后再执行条件表达式判断循环是否继续。
for循环示例:

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

unsafe static void FastCopy ( byte* ps, byte* pd, int count ) {...}

            int a = 8;
            string b = (a < 10) ? "小于10" : "大于10";

{

  statement 是需要循环执行的语句。

 

2.3  do - while

· while

switch语句
switch…case语句适合于从一组互斥的分支中选择一个执行分支。其形式是switch参数的后面跟一组case子句。如果switch参数中表达式的值等于某个case子句旁边的某个值,就执行该case子句中的代码。此时不需要使用花括号把语句组合到块中,只需使用break语句标记每段case代码的结尾即可。也可以在switch语句中包含一条default子句,如果表达式不等于任何case子句的值,就执行default子句的代码。其语法如下:
switch(表达式)
{
    case 1:
    Console.WriteLine("1");
    break;
    case 2:
    Console.WriteLine("2");
    break;
    case 3:
    Console.WriteLine("3");
    break;
    default:
    Console.WriteLine("4");
    break;  
}
注意:switch语句每个case语句后面的值必须与表达式所得到的值的类型相同,而且必须是常量,不能是变量;switch语句中所有case语句后面的值必须是互斥的,也就是说case后面的值不能存在两个相同的值,因为所有case语句后面的值必须是互斥的,所以case语句的排放顺序无关紧要,甚至可以把default语句放在最前面!但是为养成良好的编程习惯和代码有清晰的逻辑,我不建议这样写;switch语句中default语句只能存在一个,不能存在多个;通常情况下,每个case后面都必须有一个break语句,break语句作用是中断switch语句的执行,但C#中也可以使用其它中断语句来中断switch语句的执,如return语句、goto语句。使用break语句和return语句来中断是有区别的,break语句仅仅中断switch语句的执行,如果switch语句后面还有其它代码是可以继续执行的,但是return语句中断则会中断switch语句所在的方法,也就是说switch语句后面的代码将不会执行,switch语句所在的方法将直接返回。使用goto语句可以从一个case跳到另一个case中执行,如下面这段代码:

foreach (ItemType item in myCollection)

  · checked     指定检查。

            List<string> strList = new List<string>();
            for (int a =1 ; a <= 10; a  )
            {
                strList.Add(a.ToString());
            }

            foreach (string str in strList)
            {
                Console.WriteLine(str);
                strList.Remove(str);
            }
            Console.ReadKey();

  该语句提供一种简单、明了的方法来循环访问数组的元素。

3.1  break 语句

            int a = 1;
            switch (a)
            {
                case 1:
                    Console.WriteLine("1");
                    goto case 2;        
                case 2:
                    Console.WriteLine("2");
                    break;                
                case 3:
                    Console.WriteLine("3");
                    break;
                default:
                    Console.WriteLine("4");
                    break;                

            }

4.2  unchecked 语句 

  在非保护模式中,可以在堆栈上分配内存,这里的内存不受垃圾回收器的管理,因此可以不需要固定。

程序说明:程序执行完 case 1后会直接执行case 2。但是我们不建议这样做,这会导致很难察觉的逻辑错误。

  一个名为 Current 的属性。类型为 ItemType 或可以转换成 ItemType 的类型。它的属性访问器返回集合中的当前元素。

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

throw语句:抛出一个异常。

   statement

]( <如果对你有帮助,记得点一下推荐哦,有不明白的地方或写的不对的地方,请多交流>

{

4.  检查和未检查语句 

异常处理语句    throw、try-catch、try-finally

  expression 是bool类型的表达式,用来测试循环是否终止。

    case <comparisonVal1>:

(1) <testVar> 中的值与 case 语句中指定的每个 <comparisonValX> 值进行比较,如果有一个匹配,就执行为该匹配提供的语句。如果没有匹配,就执行 default 部分中的代码。执行完每个部分中的代码后,还须有一个 break 语句。在执行完一个 case 块后,再执行第二个 case 语句是非法的。

  其中:

  /checked 编译器选项使您可以为 checked 或 unchecked 关键字范围内的所有非显式整型算术语句指定检查或非检查情况。

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

C# 语言中提供了以下4种循环语句:

7. 异常处理语句 

for语句的一般形式:

    return [expression];

示例输出:

E.多重嵌套和多次if的情况,推荐使用下面的switch case语句

Current value of n is 5

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

  unsafe 可以用作方法、属性、构造函数(不是静态构造函数)的限定符。

   statement

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

时时app平台注册网站 2

 1 using System;
 2 class UnsafeTest
 3 {    
 4     // 非保护方法:使用 int 类型的指针。
 5     unsafe static void SquarePtrParam(int* p)
 6     {
 7         *p *= *p;
 8     }    
 9     unsafe static void Main()
10     {
11         int i = 5;
12         // 非保护方法:使用地址操作符(&):
13         SquarePtrParam(&i);
14         Console.WriteLine(i);
15     }
16 
17 }

说明: break 语句将中断 switch 语句的执行,而执行该结构后面的语句。还有另一种方法可以防止程序流程从一个 case 语句转到下一个 case 语句。可以使用 return 语句。也可以使用 goto 语句,因为 case 语句实际上是在 C# 代码中定义标签。如果把多个 case 语句放(堆叠)在一起,其后加一行代码,实际上是一次检查多个条件。如果满足这些条件中的任何一个,就会执行代码,例如:

7. 异常处理语句 

检查和未检查语句  checked、unchecked

  if(a==b)

1.1  if - else

输出:

C#流程控制语句中最常用的三个是 选择语句(即条件语句)、循环语句和异常处理语句。

输出:

5.  非保护和固定

示例:下例显示的是在 C# 中使用线程的简单示例。 

        <如果没有与<testVar>匹配的<comparisonValX>时执行的语句>

  如果在代码中声明了标签,但从未引用过它,编译时将出现警告信息。

2.2 foreach 

        break;

  必须包括一个名叫 GetEnumerator 的实例方法,该方法返回一个类型,比如 Enumerator。

输出:

     c ;

C.可以使用if else 嵌套

{

· for

switch 语句是通过将控制传递给其内部的一个 case 语句来处理多个选择的流程控制语句。

}

 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 

**[返回目录

foreach 语句为数组或对象集合中的每个元素执行一遍循环体。通常用来遍历某个集合,以获取所需信息,但不应用于更改集合内容以避免产生不可预知的副作用。

  goto identifier;

选择语句      if、else、switch、case

4

   statement

        break;

示例输出:

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

    staterment

  一个名叫 MoveNext 的方法。该方法用于增加计数器的值,如果集合中的元素个数小于计数器的值,该方法返回 true,否则返回 false。

1.2  switch - case

 1 // for loop
 2 using System;
 3 class ForLoopTest
 4 {
 5     static void Main()
 6     {
 7         for (int i = 1; i <= 5; i  )
 8         {
 9             Console.WriteLine(i);
10         }
11     }
12 }

Unchecked output value: -2

25 6

锁定语句      lock 

[.net 面向对象编程基础] (7) 基础中的基础——流程控制语句

}

     c--;

switch 语句的基本结构:

B.对于多个条件判断可以使用if (expression){}else if(expression){}else{}

循环语句      do、for、foreach、in、while

4

1

  · 如果 MyType 可以被公共访问,将出现 lock (typeof (MyType)) 问题。

  一个名叫 MoveNext 的方法。该方法用于增加计数器的值,如果集合中的元素个数小于计数器的值,该方法返回 true,否则返回 false。

// 使用 /unsafe 编译

  当对集合使用 foreach 语句时,该集合必须满足一定的条件。

在下面的示例中,方法 A() 以 double 值的形式返回变量 Area。

 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 }

 

跳转语句      break、continue、default、goto、return

for ([initializers]; [expression]; [iterators])

C.可以使用if else 嵌套

{

D.尽量避免使用多重嵌套和连续使用if

  示例:

2

}

A.如果if或else区块部分只有一行,可以省略{}区块符,例如:

switch (<testVar>)

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

流程控制语句中最常用的三个是 选择语句(即条件语句)、循环语句和异常处理语句

3

  · 接着,检查 expression。如果为 true,执行 statement,并重新计算循环计数器的值。如果为 false,则退出循环。

do

  identifier 表示集合元素的循环变量。

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

  其中:

时时app平台注册网站 3

Enter the number to search for: 44

    default:

}

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

输出:

  对于多维数组,使用嵌套的for循环可以更好地控制数组元素。

End of search.

 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 }

  示例:

4.1  checked 语句 

    staterment

for语句通常用来让一条语句或一个语句块执行一定的次数。

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

3. 跳转语句

  如果既未指定 checked 也未指定 unchecked,默认取决于外部因素,比如编译器选项。

  必须是 interface、class 或 struct。

 

输出:

    // 非保护环境:可以使用指针。

时时app平台注册网站 4

  unsafe 表示非保护环境,该上下文是任何涉及指针的操作所必需的。

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

  其中:

foreach (type identifier in expression)

  例如:

  例如,下面的代码创建一个名为 numbers 的数组,并用 foreach 语句循环访问该数组:

 输出:

B.对于多个条件判断可以使用if (expression){}else if(expression){}else{}

跳转语句      break、continue、default、goto、return

  return语句的形式如下:

  · 如果实例可以被公共访问,将出现 lock (this) 问题。

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

输出:

  语法:

{

if (expression){}else{},其中expression是一个布尔类型,true则执行第一区块,false则执行else部分,使用这个语句有几个要说明的地方:

 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 }

输出:

  · 整型间的显式数字转换。

4

It's 1, 2, or 3.

3.2  continue 语句

    case <comparisonVal2>:

Checked output value is: 0

  一个名为 Current 的属性。类型为 ItemType 或可以转换成 ItemType 的类型。它的属性访问器返回集合中的当前元素。

}

switch 语句是通过将控制传递给其内部的一个 case 语句来处理多个选择的流程控制语句。

do-while 结构先执行循体语句,然后判断 while 条件是否为 true。如果为 true,将循环执行;如果为 false,则退出循环。因此 do-while 循环结构中的语句至少要执行一次。

 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 }

myCollection 必须满足下面的要求。

switch 语句的基本结构:

 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 }

     c ;

System.OverflowException: Arithmetic operation resulted in an overflow.

  其中:

        break;

D.尽量避免使用多重嵌套和连续使用if

时时app平台注册网站 5

Please enter your selection: 2

    case <comparisonValN>:

   at OverFlowTest.CheckedMethod()

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

1.条件语句

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

  goto case constant-expression;

        <如果<testVar>等于<comparisonVal2>时执行的语句>

}

输出:

   statement

  示例:

do

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

  (1)  foreach在数组中的使用

(2)  foreach 在集合中的使用

  goto default;

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

foreach 语句为数组或对象集合中的每个元素执行一遍循环体。通常用来遍历某个集合,以获取所需信息,但不应用于更改集合内容以避免产生不可预知的副作用。

        break;

(2) break 语句将中断 switch 语句的执行,而执行该结构后面的语句。

    ……

 1 using System;
 2 class SwitchTest
 3 {
 4     static void Main()
 5     {
 6         int n = 2;
 7         switch(n)
 8         {
 9             case 1:
10             case 2:
11             case 3:
12                 Console.WriteLine("It's 1, 2, or 3.");
13                 break;
14         default:
15             Console.WriteLine("Not sure what it is.");
16             break;
17         }
18     }
19 }

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

}

}

2.1 for

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

System.OverflowException: Arithmetic operation resulted in an overflow.

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

  · 表达式对整型使用下列预定义操作符:

6.  锁定语句

(2)  foreach 在集合中的使用

2.1 for

  iterators 表示增大或减少循环计数器的值。

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

E.多重嵌套和多次if的情况,推荐使用下面的switch case语句

for语句的一般形式:

  · continue

时时app平台注册网站 6

The area is 78.54

时时app平台注册网站 7

============================================================================================== 

时时app平台注册网站 8

  while 语句后面的分号是必须的。

  · break

Current value of n is 3

{

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

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

1

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

  return语句的形式如下:

示例:下面示例中,只要变量 y 小于 5,do 循环语句就开始执行。

  最佳做法是定义 private 对象来锁定, 或 private shared 对象变量来保护所有实例所共有的数据。 

           int n = 2;
 7         switch(n)
 8         {
 9             case 1:
10             case 2:
11             case 3:
12                 Console.WriteLine("It's 1, 2, or 3.");
13                 break;
14         default:
15             Console.WriteLine("Not sure what it is.");
16             break;
17         }

 try - catch - finally

  类型 Enumerator(类或结构)必须包含:

 1 using System;
 2 class SwitchTest{   
 3     static void Main()
 4     {
 5         Console.WriteLine("Coffee sizes: 1=Small 2=Medium 3=Large");
 6         Console.Write("Please enter your selection: ");
 7         string s = Console.ReadLine();
 8         int n = int.Parse(s);
 9         int cost = 0;
10         switch (n)
11         {
12             case 1:
13                 cost  = 25;
14                 break;
15             case 2:
16                 cost  = 25;
17                 goto case 1;
18             case 3:
19                 cost  = 50;
20                 goto case 1;
21             default:
22                 Console.WriteLine("Invalid selection.");
23                 break;
24         }
25         if (cost != 0)
26         {
27             Console.WriteLine("Please insert {0} cents.", cost);
28         }
29         Console.WriteLine("Thank you for your business.");
30     }
31 }

switch (<testVar>)

输出:

     c--;

  · 返回上一步,继续执行。

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

  identifier 表示一个标签。

        break;

 

时时app平台注册网站 9

  集合类型:

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

3.3  goto 语句

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

    ...

 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 }

25

  else

锁定语句      lock 

  do 循环的结构如下:

3

1.条件语句

如果输入 44,则示例输出:

     · return

选择语句      if、else、switch、case

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

  必须是 interface、class 或 struct。

  · goto

  constant-expression 表示一个 switch-case 标签。

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

  goto 语句将程序控制直接交给标记的语句。有以下形式:

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

class Point
{
        public int x, y;
}
class FixedTest
{
        // Unsafe method: takes a pointer to an int.
        unsafe static void SquarePtrParam(int* p)
        {
            *p *= *p;
        }
        unsafe static void Main()
        {
            Point pt = new Point();
            pt.x = 5;
            pt.y = 6;
            // Pin pt in place:
            fixed (int* p = &pt.x)
            {
                SquarePtrParam(p);
            }
            // pt now unpinned
            Console.WriteLine("{0} {1}", pt.x, pt.y);
        }
}    
1 int[] numbers = { 4, 5, 6, 1, 2, 3, -2, -1, 0 };
2 foreach (int i in numbers)
3 {
4     System.Console.WriteLine(i);
5 }

  示例:

   at OverFlowTest.CheckedMethod()

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

(1)  foreach在数组中的使用

 1 using System;
 2 class WhileTest
 3 {
 4     static void Main()
 5     {
 6         int n = 1;
 7         while (n < 6)
 8         {
 9             Console.WriteLine("Current value of n is {0}", n);
10             n  ;
11         }
12     }
13 }

2.4  While

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

        break;

for语句通常用来让一条语句或一个语句块执行一定的次数。

  while 语句后面的分号是必须的。

 5.1  unsafe语句

非保护和固定语句  unsafe、fixed

1

2.循环语句

非保护和固定语句  unsafe、fixed

3.3  goto 语句

 

  · continue

0

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

unsafe static void FastCopy(byte[] src, byte[] dst, int count)

while (expression)

输出:

类别         关键字                      

4.2  unchecked 语句 

} while (expression);

{

9

  initializers 表示初始化循环计数器,如果有多个变量需要初始化,可用逗号隔开。

10

5.2  fixed 语句

    case <comparisonVal2>:

  其中:

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

2

语法:

检查和未检查语句  checked、unchecked

  do 语句重复执行括在 {} 里的一个语句或语句块,直到指定的表达式为 false 时为止。

  下列操作受溢出检查的影响:

  if(a==b)

  expression 为 bool 类型的表达式,或者是可以隐式转换成 bool 类型的表达式,也可以是重载 true 和 false 操作符的类型的表达式。用来测试循环是否终止。

    return [expression];

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

   lock 确保当一个线程位于代码的临界区时,另一个线程不进入临界区。如果其他线程试图进入锁定的代码,则它将一直等待(即被阻止),直到该对象被释放。 

如果输入了 2,示例输出:

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

(3)还有另一种方法可以防止程序流程从一个 case 语句转到下一个 case 语句。可以使用 return 语句。也可以使用 goto 语句,因为 case 语句实际上是在 C# 代码中定义标签。

  类型 Enumerator(类或结构)必须包含:

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

  staterment 表示需要循环执行的语句。

for (;;)

A.如果if或else区块部分只有一行,可以省略{}区块符,例如:

  必须包括一个名叫 GetEnumerator 的实例方法,该方法返回一个类型,比如 Enumerator。

unsafe

} while (expression);

}

  若要编译不安全代码,必须指定 /unsafe 编译器选项。无法通过公共语言运行库验证不安全代码。

3

        <如果没有与<testVar>匹配的<comparisonValX>时执行的语句>

  fixed 语句用来设置指向变量的指针,并在 statement 执行过程中固定变量的位置。如果不使用 fixed,指向已处理变量的指针就可能重新移动位置,该指针也就失去了作用。实际上,如果不使用 fixed 语句,C# 编译器是不允许设置指向已处理变量的指针的。

Current value of n is 4

  示例:下面示例中,只要变量 y 小于 5,do 循环语句就开始执行。

Current value is 1

  当对集合使用 foreach 语句时,该集合必须满足一定的条件。

2.3  do - while

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

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

2.2 for - in 

5.  非保护和固定

RunMe called

  statement 表示可执行的语句或语句块。

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

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

 1 // break and switch
 2 using System;
 3 class Switch
 4 {
 5     static void Main()
 6     {
 7         Console.Write("Enter your selection (1, 2, or 3): ");
 8         string s = Console.ReadLine();
 9         int n = Int32.Parse(s);
10         switch (n)
11         {
12             case 1:
13                 Console.WriteLine("Current value is {0}", 1);
14                 break;
15             case 2:
16                 Console.WriteLine("Current value is {0}", 2);
17                 break;
18             case 3:
19                 Console.WriteLine("Current value is {0}", 3);
20                 break;
21             default:
22                 Console.WriteLine("Sorry, invalid selection.");
23                 break;
24         }
25     }
26 }

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

1 int[] numbers = { 4, 5, 6, 1, 2, 3, -2, -1, 0 };
2 foreach (int i in numbers)
3 {
4     System.Console.WriteLine(i);
5 }

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

The number 44 is found.

Enter your selection (1, 2, or 3): 1

    // 非保护环境:可以使用指针。

  goto 语句的常用方法是在 switch 语句中,将控制转换传递到特定的 switch-case 标签或 default 标签。

   statement

2.循环语句

 1 using System;
 2 using System.Threading;
 3 class ThreadTest{      
 4    public void RunMe()
 5    {
 6          Console.WriteLine("RunMe called");
 7    }
 8     static void Main()
 9     {
10         ThreadTest b = new ThreadTest();
11         Thread t = new Thread(b.RunMe);
12         t.Start();
13     }
14 }

  type 表示未管辖的类型或 void。

  使用循环语句可以让程序多次执行相同的代码或代码块,这些代码或代码块称为循环体。对于任何一个循环体来说,都应该提供一个跳出循环的条件,不同的循环语句提供不同的条件。

{

{

      —   -(一元)       -   *   /

    case <comparisonValN>:

3.2  continue 语句

foreach (type identifier in expression)

}

  for 语句的所有表达式都是可选的;例如,下列语句用于写一个无限循环:

    case <comparisonVal1>:

 1 using System;
 2 class ReturnTest
 3 {
 4     static double CalculateArea(int r)
 5     {
 6         double area = r * r * Math.PI;
 7         return area;
 8     }
 9 
10     static void Main()
11     {
12         int radius = 5;
13         Console.WriteLine("The area is {0:0.00}",           
           CalculateArea(radius));
14     }
15 }

  通常,应避免锁定 public 类型,否则实例将超出代码的控制范围。常见的结构 lock (this)、lock (typeof (MyType)) 和 lock ("myLock") 违反此准则:

  例如下面的 foreach 语句:

        <如果<testVar>等于<comparisonVal2>时执行的语句>

 输出:

        break;

  fixed 语句只能用在 unsafe 环境中执行。

语句:是程序中的小指令,本节主要以流程控制语句为主要内容。

流程控制语句分类:

9

示例:

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

  示例:

6.  锁定语句

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

==============================================================================================

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

        <如果<testVar>等于<comparisonValN>时执行的语句>

5

  还可以使用不安全块从而能够使用该块内的不安全代码。例如:

本来没有这一节的内容,后来考虑到既然是一个系列文章,那么就尽可能写的详细一些,本节参考了网上朋友所写的例子,为的是让更多小伙伴学习,提高,加薪,如有版权问题,请邮件我,我第一时间处理。

输出:

  示例:

  fixed 语句的使用格式:

1.1  if - else

  C# 语句可以在检查和非检查情况下运行。在检查情况下,算术溢出将引发异常;在非检查情况下,算术溢出将被忽略,结果将被截断。

  ptr 表示指针名称。

Checked output value is: 0

  

Current value of n is 2

  · 首先初始化 initializers。

1 unchecked
2 {
3     int val = 2147483647 * 2;
4 }
1 Object thisLock = new Object();
2 lock (thisLock)
3 {
4     // 临界区代码
5 }

  非保护环境的范围包括从参数列表到方法的结尾,因此指针在以下参数列表中也可以使用:

(4) 一个 case 语句处理完后,不能自由进入下一个 case 语句,但有一个例外。如果把多个 case 语句放(堆叠)在一起,其后加一行代码,实际上是一次检查多个条件。如果满足这些条件中的任何一个,就会执行代码,例如:

2

3.4  return 语句

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

 

  示例:下面的示例演示了 goto 在 switch 语句中的使用。

        <如果<testVar>等于<comparisonVal1>时执行的语句>

异常处理语句    throw、try-catch、try-finally

循环语句      do、for、foreach、in、while

myCollection 必须满足下面的要求。

Coffee sizes: 1=Small 2=Medium 3=Large

Thank you for your business.

Sorry, invalid selection.

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

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

  do 语句重复执行括在 {} 里的一个语句或语句块,直到指定的表达式为 false 时为止。

10

  其中:

foreach (ItemType item in myCollection)

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

类别         关键字                      

  每个 <comparisonValX> 都必须是一个常量。一种方法是提供字面值,另一种方式是使用常量。在这里使用常量可读性更好。

 

  其执行流程为:

     · return

2.4  While

Please insert 50 cents.

  因为对 expression 的测试是在循环体执行之前,所以 for 语句可执行 0 次或多次。

  下面的示例演示了使用 goto 跳出嵌套循环。

  该语句提供一种简单、明了的方法来循环访问数组的元素。

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

  · break

  如果输入 4,则输出为:

  下面的示例演示break在switch语句中的用法。

 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 }

  expression 表示 bool 类型的表达式。用来测试循环是否终止。

语法:

  语法:

{

1.2  switch - case

if (expression){}else{},其中expression是一个布尔类型,true则执行第一区块,false则执行else部分,这个小伙伴们肯定是相当滴熟悉了

3. 跳转语句

    ……

  statement 是需要循环执行的语句。

while (expression)

  · 由于进程中使用同一字符串的任何其他代码将共享同一个锁,所以出现 lock(“myLock”) 问题。 

1

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

  do 循环的结构如下:

    default:

  statement 表示需要循环执行的语句。

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

   statement

Enter your selection (1, 2, or 3): 4

  int a,b,c;

2

· do-while 

输出:

  其中:

    fixed ( type* ptr = expr ) statement

  expr 表示隐式转换成 type* 的表达式。

  其中:

输入 1,则示例输出为:

  有时也在多层嵌套的循环体中使用 goto 语句跳出多层循环。

  对于数组或集合中的每个元素,循环体都将执行一次。遍历完所有的元素后,程序将退出 foreach 块,执行后面的语句。

  在第一种形式中,identifier 指定位于当前循环体中的标签,是一个与 goto 语句位于同一个循环体中的标签。

  对于多维数组,使用嵌套的for循环可以更好地控制数组元素。

  do-while 结构先执行循体语句,然后判断 while 条件是否为 true。如果为 true,将循环执行;如果为 false,则退出循环。因此 do-while 循环结构中的语句至少要执行一次。

使用这个语句有几个要说明的地方:

Current value of n is 1

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

本文由时时app平台注册网站发布于编程知识,转载请注明出处:C#幼功之流程序调控制语句精解【时时app平台注册

关键词: