Steven Blogs

第六章 控制语句

有一种语句，你在每种编程语言控制流程语句中都可以找到。在这一章中，我介绍了C#的控制语句，它们分为两个主要部分：

  • 选择语句
  • 循环语句

如果你是C或C++程序员，很多信息会让你感到似曾相似；但是，你必须知道它们还存在着一些差别。

6.1 选择语句

当运用选择语句时，你定义了一个控制语句，它的值控制了哪个语句被执行。在C#中用到两个选择语句：

  • if 语句
  • switch 语句

6.1.1 if 语句

最先且最常用到的语句是 if 语句。内含语句是否被执行取决于布尔表达式：

if (布尔表达式) 内含语句

当然，也可以有else分枝，当布尔表达式的值为假时，该分枝就被执行：

if (布尔表达式) 内含语句 else 内含语句

在执行某些语句之前就检查一个非零长字符串的例子：

if (0 != strTest.Length){ }

这是一个布尔表达式。（!=表示不等于。） 但是，如果你来自C或者C++，可能会习惯于编写象这样的代码：

if (strTest.Length){}

这在C#中不再工作，因为 if 语句仅允许布尔（bool） 数据类型的结果，而字符串的Length属性对象返回一个整形（integer）。编译器将出现以下错误信息：

error CS0029: Cannot implicitly convert type 'int' to 'bool'
（不能隐式地转换类型 'int' 为 'bool'。）

上边是你必须改变的习惯，而下边将不会再在 if 语句中出现赋值错误：

if (nMyValue = 5) ...

正确的代码应为

if (nMyValue == 5) ...

因为相等比较由==实行，就象在C和C++中一样。看以下有用的对比操作符（但并不是所有的数据类型都有效）：

  • == ——如果两个值相同，返回真。
  • != ——如果两个值不同，返回假。
  • <,<=, >, >= —— 如果满足了关系（小于、小于或等于、大于、大于或等于），返回真。

每个操作符是通过重载操作符被执行的，而且这种执行对数据类型有规定。如果你比较两个不同的类型，对于编译器，必须存在着一个隐式的转换，以便自动地创建必要的代码。但是，你可以执行一个显式的类型转换。

清单 6.1 中的代码演示了 if 语句的一些不同的使用场合，同时也演示了如何使用字符串数据类型。这个程序的主要思想是，确定传递给应用程序的第一个参数是否以大写字母、小写字母或者数字开始。

清单 6.1 确定字符的形态

using System;

class NestedIfApp
{
    public static int Main(string[] args)
    {
        if (args.Length != 1)
        {
            Console.WriteLine("Usage: one argument");
            return 1; // error level
        }

        char chLetter = args[0][0];

        if (chLetter >= 'A')
            if (chLetter <= 'Z')
            {
                Console.WriteLine("{0} is uppercase", chLetter);
                return 0;
            }
        
        chLetter = Char.FromString(args[0]);
        if (chLetter >= 'a' && chLetter <= 'z')
            Console.WriteLine("{0} is lowercase", chLetter);
        if (Char.IsDigit((chLetter = args[0][0])))
            Console.WriteLine("{0} is a digit", chLetter);
        return 0;
    }
}

始于第7行的第一个 if 语段检测参数数组是否只有一个字符串。如果不满足条件，程序就在屏幕上显示用法信息，并终止运行。

可以采取多种方法从一个字符串中提取出单个字符——既可象第13行那样利用字符索引，也可以使用Char类的静态 FromString 方法，它返回字符串的第一个字符。

第16～20行的 if 语句块使用一个嵌套 的if 语句块检查大写字母。用逻辑“与”操作符（&&）可以胜任小写字母的检测，而最后通过使用Char类的静态函数IsDigit，就可以完成对数字的检测。

除了“&&”操作符之外，还有另一个条件逻辑操作符，它就是代表“或”的“||”。两个逻辑操作符都 是“短路”式的。对于“&&”操作符，意味着如果条件“与”表达式的第一个结果返回一个假值，余下的条件“与”表达式就不会再被求值了。相对应，“||”操作符当第一个真条件满足时，它就“短路”了。

我想让大家理解的是，要减少计算时间，你应该把最有可能使求值“短路”的表达式放在前面。同样你应该清楚，计算 if 语句中的某些值会存在着替在的危险。

if (1 == 1 || (5 == (strLength=str.Length)))
{
    Console.WriteLine(strLength);
}

当然，这是一个极其夸张的例子，但它说明了这样的观点：第一条语句求值为真，那么第二条语句就不会被执行，它使变量strLength维持原值。给大家一个忠告：决不要在具有条件逻辑操作符的 if 语句中赋值。

6.1.2 switch 语句

和 if 语句相比，switch语句有一个控制表达式，而且内含语句按它们所关联的控制表达式的常量运行。

switch (控制表达式)
{
    case 常量表达式:
        内含语句
    default:
        内含语句
}

控制表达式所允许的数据类型 为： sbyte, byte, short, ushort, uint, long, ulong, char, string, 或者枚举类型。只要使其它不同数据类型能隐式转换成上述的任何类型，用它作为控制表达式也很不错。

switch 语句接以下顺序执行：

  1. 控制表达式求值
  2. 如果 case 标签后的常量表达式符合控制语句所求出的值，内含语句被执行。
  3. 如果没有常量表达式符合控制语句，在default 标签内的内含语句被执行。
  4. 如果没有一个符合case 标签，且没有default 标签，控制转向switch 语段的结束端。

在继续更详细地探讨switch语句之前，请看清单 6.2 ，它演示用 switch语句来显示一个月的天数（忽略跨年度）

清单 6.2 使用switch语句显示一个月的天数

using System;

class FallThrough
{
    public static void Main(string[] args)
    {
        if (args.Length != 1) return;

        int nMonth = Int32.Parse(args[0]);
        if (nMonth < 1 || nMonth > 12) return;
        int nDays = 0;

        switch (nMonth)
        {
            case 2: nDays = 28; break;
            case 4:
            case 6:
            case 9:
            case 11: nDays = 30; break;
            default: nDays = 31;
        }
        Console.WriteLine("{0} days in this month", nDays);
    }
}

switch 语段包含于第13~21行。对于C程序员，这看起来非常相似，因为它不使用break语句。因此，存在着一个更具生命力的重要差别。你必须加上一个break语句（或一个不同的跳转语句），因为编译器会提醒，不允许直达下一部分。

何谓直达？在C（和C++）中，忽略break并且按以下编写代码是完全合法的：

nVar = 1
switch (nVar)
{
    case 1:
        DoSomething();
    case 2:
        DoMore();
}

在这个例子中，在执行了第一个case语句的代码后，将直接执行到其它case标签的代码，直到一个break语句退出switch语段为止。尽管有时这是一个强大的功能，但它更经常地产生难于发现的缺陷。

可如果你想执行其它case标签的代码，那怎么办？ 有一种办法，它显示于清单6.3中。

清单 6.3　在swtich语句中使用 goto 标签　和 goto default

using System;

class SwitchApp
{
    public static void Main()
    {
        Random objRandom = new Random();
        double dRndNumber = objRandom.NextDouble();
        int nRndNumber = (int)(dRndNumber * 10.0);

        switch (nRndNumber)
        {
            case 1:
                //什么也不做
                break;
            case 2:
                goto case 3;
            case 3:
                Console.WriteLine("Handler for 2 and 3");
                break;
            case 4:
                goto default;
            // everything beyond a goto will be warned as
            // unreachable code
            default:
                Console.WriteLine("Random number {0}", nRndNumber);
        }
    }
}

在这个例子中，通过Random类产生用于控制表达式的值（第７～９行）。switch语段包含两个对switch语句有效的跳转语句。

  • goto case 　标签：跳转到所说明的标签
  • goto default: 跳转到 default　标签

有了这两个跳转语句，你可以创建同Ｃ一样的功能，但是，直达不再是自动的。你必须明确地请求它。

不再使用直达功能的更深的含义为：你可任意排列标签，如把default标签放在其它所有标签的前面。为了说明它，我创建了一个例子，故意不结束循环：

switch (nSomething)
{
    default:
    case 5:
        goto default;
}

我已经保留了其中一个switch 语句功能的讨论直至结束——事实上你可以使用字符串作为常量表达式。这对于VB程序员，可能听起来不象是什么大的新闻，但来自Ｃ或Ｃ++的程序员将会喜欢这个新功能。

现在，一个 switch 语句可以如以下所示检查字符串常量了。

string strTest = "Chris";
switch (strTest)
{
    case "Chris":
    Console.WriteLine("Hello Chris!");
    break;
}

6.2 循环语句

当你想重复执行某些语句或语段时，依据当前不同的任务，Ｃ＃提供４个不同的循环语句选择给你使用：

  • for 语句
  • foreach 语句
  • while 语句
  • do 语句

6.2.1 for 语句

当你预先知道一个内含语句应要执行多少次时，for 语句特别有用。当条件为真时，常规语法允许重复地执行内含语句（和循环表达式）：

for (初始化;条件;循环) 内含语句

请注意，初始化、条件和循环都是可选的。如果忽略了条件，你就可以产生一个死循环，要用到跳转语句（break 或goto）才能退出。

for (;;)
{
    break; // 由于某些原因
}

另外一个重点是，你可以同时加入多条由逗号隔开的语句到for循环的所有三个参数。例如，你可以初始化两个变量、拥有三个条件语句，并重复4个变量。

作为C或C++程序员，你必须了解仅有的一个变化：条件语句必须为布尔表达式，就象 if 语句一样。

清单6.4 包含使用 for 语句的一个例子。它显示了如何计算一个阶乘，比使用递归函数调用还要快。

清单 6.4 在for 循环里计算一个阶乘

using System;

class Factorial
{
    public static void Main(string[] args)
    {
        long nFactorial = 1;
        long nComputeTo = Int64.Parse(args[0]);

        long nCurDig = 1;
        for (nCurDig = 1; nCurDig <= nComputeTo; nCurDig++)
            nFactorial *= nCurDig;

        Console.WriteLine("{0}! is {1}", nComputeTo, nFactorial);
    }
}

尽管该例子过于拖沓，但它作为如何使用for语句的一个开端。首先，我本应在初始化内部声明变量nCurDig：

for (long nCurDig=1;nCurDig <= nComputeTo; nCurDig++) nFactorial *= nCurDig;

另一种忽略初始化的选择如下行，因为第10行在for语句的外部初始化了变量。（记住C#需要初始化变量）：

for (;nCurDig <= nComputeTo; nCurDig++) nFactorial *= nCurDig;

另一种改变是把++操作符移到内含语句中：

for ( ;nCurDig <= nComputeTo; ) nFactorial *= nCurDig++;

如果我也想摆脱条件语句，全部要做的是增加一条if语句，用break 语句中止循环：

for (;;)
{
    if (nCurDig > nComputeTo) break;
    nFactorial *= nCurDig++;
}

除了用于退出for语句的break语句外，你还可以用continue 跳过当前循环，并继续下一次循环。

for (;nCurDig <= nComputeTo;)
{
    if (5 == nCurDig) continue; // 这行跳过了余下的代码
    nFactorial *= nCurDig++;
}

6.2.2 foreach 语句

已经在Visual Basic 语言中存在了很久的一个功能是，通过使用For Each 语句收集枚举。C#通过foreach 语句，也有一个用来收集枚举的命令：

foreach(表达式中的类型标识符） 内含语句

循环变量由类型和标识符声明，且表达式与收集相对应。循环变量代表循环正在为之运行的收集元素。

你应该知道不能赋一个新值给循环变量，也不能把它当作ref 或out 参数。这样引用在内含语句中被执行的代码。

你如何说出某些类支持foreach 语句？ 简而言之，类必须支持具有 GetEnumerator()名字的方法，而且由其所返回的结构、类或者接口必须具有public 方法MoveNext() 和public 属性Current。如果你想知道更多，请阅读语言参考手册，它有很多关于这个话题的详细内容。

对于清单 6.5 中的例子，我恰好偶然选了一个类，实现了所有这些需要。我用它来列举被定义过的所有的环境变量。

清单 6.5 读所有的环境变量

using System;
using System.Collections;

class EnvironmentDumpApp
{
    public static void Main()
    {
        IDictionary envvars = Environment.GetEnvironmentVariables();
        Console.WriteLine("There are {0} environment variables declared", envvars.Keys.Count);
        foreach (String strKey in envvars.Keys)
        {
            Console.WriteLine("{0} = {1}", strKey, envvars[strKey].ToString());
        }
    }
}

对GetEnvironmentVariables的调用返回一个IDictionary类型接口，它是由.NET框架中的许多类实现了的字典接口。通过 IDictionary 接口，可以访问两个收集：Keys 和 Values。在这个例子里，我在foreach语句中使用Keys，接着查找基于当前key值的值（第12行）。

当使用foreach时，只要注意一个问题：当确定循环变量的类型时，应该格外小心。选择错误的类型并没有受到编译器的检测，但它会在运行时受检测，且会引发一个异常。

6.2.3 while 语句

当你想执行一个内含语句0次或更多次时，while语句正是你所盼望的：

while (条件) 内含语句

条件语句——它也是一个布尔表达式 ——控制内含语句被执行的次数。你可以使用 break 和continue语句来控制while语句中的执行语句，它的运行方式同在for语句中的完全相同。

为了举例while的用法，清单 6.6 说明如何使用一个 StreamReader类输出C#源文件到屏幕。

清单 6.6 显示一个文件的内容

using System;
using System.IO;

class WhileDemoApp
{
    public static void Main()
    {
        StreamReader sr = File.OpenText("whilesample.cs");
        String strLine = null;

        while (null != (strLine = sr.ReadLine()))
        {
            Console.WriteLine(strLine);
        }

        sr.Close();
    }
}

代码打开文件 whilesample.cs, 接着当ReadLine 方法返回一个不等于null的值时，就在屏幕上显示所读取的值。注意，我在while条件语句中用到一个赋值。如果有更多的用&&和||连接起来的条件语句，我不能保证它们是否会被执行，因为存在着“短路”的可能。

6.2.4 do 语句

C#最后可利用的循环语句是do语句。它与while语句十分相似，仅当经过最初的循环之后，条件才被验证。

do
{
    内含语句
}
while (条件);

do语句保证内含语句至少被执行过一次，而且只要条件求值等于真，它们继续被执行。通过使用break语句，你可以迫使运行退出 do 语块。如果你想跳过这一次循环，使用continue语句。

一个如何使用do语句的例子显示在清单 6.7中。它向用户请求一个或多个数字，并且当执行程序退出do循环后计算平均值。

清单 6.7 在do 循环中计算平均值

using System;

class ComputeAverageApp
{
    public static void Main()
    {
        ComputeAverageApp theApp = new ComputeAverageApp();
        theApp.Run();
    }

    public void Run()
    {
        double dValue = 0;
        double dSum = 0;
        int nNoOfValues = 0;
        char chContinue = 'y';
        string strInput;

        do
        {
            Console.Write("Enter a value: ");
            strInput = Console.ReadLine();
            dValue = Double.Parse(strInput);
            dSum += dValue;
            nNoOfValues++;
            Console.Write("Read another value?");

            strInput = Console.ReadLine();
            chContinue = Char.FromString(strInput);
        }
        while ('y' == chContinue);

        Console.WriteLine("The average is {0}", dSum / nNoOfValues);
    }
}

在这个例子里，我在静态 Main函数中实例化 ComputeAverageApp类型的一个对象。它同样接着调用实例的Run方法，该方法包含了计算平均值所有必要的功能。

do 循环跨越第19~31行。条件是这样设定的：分别回答各个问题 “y”，以决定是否要增加另一个值。输入任何其它字符会引起程序退出 do语块，且平均值被计算。

正如你可以从提到的例子看出，do语句和while语句差别不太大——仅有的差别就是条件在什么时候被求值。

6.3 小结

这章解释了如何使用C#中用到的各种选择和循环语句。 if 语句在应用程序中可能是最为常用的语句。当在布尔表达式中使用计算时，编译器会为你留意。但是，你一定要确保条件语句的短路不会阻止必要代码的运行。

switch 语句——尽管同样与C语言的相应部分相似——但也被改善了。直达不再被支持，而且你可以使用字符串标签，对于C程序员，这是一种新的用法。

在这一章的最后部分，我说明如何使用for、foreach、while和do语句。语句完成各种需要，包括执行固定次数的循环、列举收集元素和执行基于某些条件的任意次数的语句。

Contributors: FHL