分支 3个月前

三元运算符

一元运算符有一个操作数，二元运算符有两个操作数，所以三元运算符有 3 个操作数。其语法如下：

copy
<test> ? <resultIfTrue> : <resultIfFalse>

  其中，计算 <test> 可得到一个布尔值，运算符的结果根据这个值来确定是 <resultIfTrue>，还是 <resultIfFalse>。

  使用三元运算符可以测试 int 变量 myInteger 的值：

copy
string resultString = (myInteger < 10) ? "Less than 10" : "Greater than or equal to 10";

  三元运算符的结果是两个字符串中的一个，这两个字符串都可以赋给 resultString。把哪个字符串给 resultString，取决于 myInteger 的值与 10 的比较。如果 myInteger 的值小于 10，就把第一个字符串赋给 resultString；如果 myInteger 的值大于或等于 10，救把第二个字符串赋给 resultString。例如，如果 myInteger 的值是 4，则 resultString 的值就是字符串 "Less than 10"。

  这个运算符比较适用于这样的简单赋值语句，但不适用于根据比较结果执行大量代码的情形。此时应使用 if 语句。

if 语句

  if 语句的功能比较多，是有效的决策方式。与 ? : 语句不同的是，if 语句没有结果（所以不在赋值语句中使用它），使用该语句是为了根据条件执行其他语句。

  if 语句最简单的语法如下：

copy
if (<test>)
  <code executed if <test> is true>;

  先执行 <test>（其计算结果必须是一个布尔值，这样代码才能编译），如果 <test> 的计算结果是 true，就执行该语句之后的代码。这段代码执行完毕后，或者因为 <test> 的计算结果是 false，而没有执行这段代码，将继续执行后面的代码行。

  也可将 else 语句和 if 语句合并使用，指定其他代码。如果 <test> 的计算结果是 false，就执行 else 语句：

copy
if (<test>)
<code executed if <test> is true>;
else
<code executed if <test> is false>;

  可使用成对的花括号将这两段代码放在多个代码行上：

copy
if (<test>)
{
    <code executed if <test> is true>;
}
else
{
    <code executed if <test> is false>;
}

  例如，重新编写上一节使用三元运算符的代码：

copy
string resultString = (myInteger < 10) ? "Less than 10"
                       : "Greater than or equal to 10";

  因为 if 语句的结果不能赋给一个变量，所以要单独将值赋给变量：

copy
string resultString;
if(myInteger < 10)
    resultString = "Less than 10";
else
    resultString = "Greater than or equal to 10";

  这样的代码尽管比较冗长，但与三元运算符相比，更便于阅读和理解，也更加灵活。 下面的示例演示了 if 语句的用法。 把下列代码添加到 Program.cs 中：

copy
static void Main(string[] args)
{
    string comparison;
    Console.WriteLine("Enter a number");
    double var1 = Convert.ToDouble(Console.ReadLine());
    Console.WriteLine("Enter anther number");
    double var2 = Convert.ToDouble(Console.ReadLine());
    if(var1 < var2)
        comparison = "less than"; 
    else
    {
        if(var1 == var2)
            comparison = "equal to";
        else
            comparison = "greater than";
        
    }
    Console.WriteLine("The first number is {0} the second number.", comparison);
    Console.ReadKey();
}

示例的说明 我们已经很熟悉了代码的第一部分，它从用户输入中得到两个 double 值：

copy
string comparison;
Console.WriteLine("Enter a number");
double var1 = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("Enter anther number:");
double var2 = Convert.ToDouble(Console.ReadLine());

接着根据 var1 和 var2 的值，将一个字符串赋给 string 变量 comparison。首先看看 var1 是否小于 var2：

copy
if(var1 < var2)
    comparison = "less than";

如果不是，则 var1 大于或等于 var2。在第一个比较操作的 else 部分，需要嵌套第二个比较：

copy
else
{
    if(var1 == var2)
        comparison = "equal to";
    // 只有在 `var1` 大于 `var2` 时，才执行第二个比较操作中的 `else` 部分：
    else
        comparison = "greater than";
}

这里使用的嵌套只是进行这些比较的一种方式，还可以编写如下代码：

copy
if(var1 < var2)
    comparison = "less than";
if(var1 == var2)
    comparison = "equal to";
if(var1 > var2)
    comparison = "greater than";

  这个方式的缺点在于无论 var1 和 var2 的值是什么，都要执行3个比较操作。在第一种方式中，如果 var1 < var2 是 true，就只执行一个比较，否则就要执行两个比较操作（还执行了 var1 == var2 比较操作），这样将使执行的代码行比较少。在本例中性能上的差异较小，但在较重视速度的应用程序中，性能的差异就很明显了。

使用 if 语句判断更多条件

在上面的示例中，检查了涉及 var1 的值的3个条件，包括了这个变量所有可能的值。有时要检查特定的值，例如，var1 是否等于 1、2、3或4等。使用上面那样的代码会得到很多烦人的嵌套代码：

copy
if(var1 == 1)
{
    // Do something.
}
else
{
    if(var1 == 2)
    {
        // Do something else.
    }
    else
    {
        if(var1 == 3 || var1 == 4)
        {
            // Do something else.
        }
        else
        {
            // Do something else.
        }
    }

}

警告 ⚠️：常会错误地将诸如 if(var1 == 3 || var1 == 4) 的条件写为 if(var1 == 3 || 4)。由于运算符具有优先级，因此首先执行 == 运算符，接着用 || 运算符处理布尔和数值操作数，就会出现错误。

  这些情况下，就要使用稍有不同的缩进模式，缩短 else 代码块（即在 else 块的后面使用一行代码，而不是一个代码块），这样就得到 else if 语句结构。

copy
if (var1 == 1)        
{            
    // Do something.        
}        
else if(var1 == 2)        
{            
    // Do something else.         
}        
else if(var1 == 3 || var1 == 4)        
{            
    // Do something else.        
}        
else        
{            
    // Do something else.        
}

  这些 else if 语句实际上是两个独立语句，它们的功能与上述代码相同，但更便于阅读。像这样进行多个比较的操作，应考虑使用另一种分支结构：**switch 语句**。

switch 语句

  switch 语句非常类似于 if 语句，因为它也是根据测试的值来有条件地执行代码。但是，switch 语句可以一次将测试变量与多个值进行比较，而不是仅测试一个条件。这种测试仅限于离散的值，而不是像 “大于X”这样的子句，所以它的用法有点不同，但它仍是一种强大的技术。

switch 语句的基本结构如下：

copy
switch(<testVar>)
{
    case <comparisonVal1>:
    <code to execute if <testVar> == <comparisonVal1> >
    break;
    case <comparisonVal2>:
     <code to execute if <testVar> == <comparisonVal2> >
    break;
    ...
    case <comparisonValN>:
    <code to execute if <testVar> == <comparisonValN> >
    break;
    default:
    <code to execute if <testVar> != comparisonVals>
    break;
}

  <testVar> 中的值与每个 <comparisonValX> 值（在 case 语句中指定）进行比较，如果有一个匹配，就执行为该匹配提供的语句。如果没有匹配，但有 default 语句，就执行 default 部分中的代码。

  执行完每个部分中的代码后，还需有另一个语句 break。在执行完一个 case 块后，再执行第二个 case 语句是非法的。

  在此，C#与C++是有区别的，在C++中，可以在运行完一个 case 语句后，运行另一个 case 语句。

  在这里的 break 语句将中断 switch 语句的执行，而执行该结构后面的语句。

  在C#代码中，还有其他方法可以防止程序流程从一个 case 语句转到下一个 case 语句。可以使用 return 语句，中断当前函数的运行，而不是仅中断 switch 结构的执行（详见第6章）。也可以使用 goto 语句（如前所述），因为 case 语句实际上是在C#代码中定义的标签。例如：

copy
switch(<testVar>)
{
    case <comparisonVal1>:
    <code to execute if <testVar> == <comparisonVal1> >
    goto case<comparisonVal2>;
    case <comparisonVal2>:
    <code to execute if <testVar> == <comparisonVal2> >
    break;
    ...
}

  一个 case 语句处理完后，不能自由进入下一个 case 语句，但这个规则有一个例外。如果把多个 case 语句放在一起（堆叠它们），其后加一个代码块，实际上是一次检查多个条件。如果满足这些条件中的任何一个，就会执行代码，例如：

copy
switch(<testVar>)
{
    case <comparisonVal1>:
    case <comparisonVal2>:
        <code to execute if <testVar> == <comparisonVal1> or
                            <testVar> == <comparisonVal2> >
        break;
    ...      
}

  注意 ⚠️，这些条件也适用于 default 语句。default 语句不一定要放在比较操作列表的最后，还可以把它和 case 语句放在一起。用 break、goto 或 return 添加一个断点，可确保在任何情况下，该结构都有一个有效的执行路径。

  每个 <comparisonValX> 都必须是一个常数值。一种方法是提供字面值，例如：

copy
switch(myInteger)
{
    case 1:
        <code to execute if myInteger == 1>
        break;
    case -1:
        <code to execute if myInteger == -1>
        break;
    default:
        <code to execute if myInteger != comparisons>
        break;
}

  另一种方式是使用常量。常量与其他变量一样，但有一个重要区别：它们包含的值是固定不变的。一旦给常量指定一个值，该常量在代码执行的过程中，其值一直不变。在这里使用常量是很方便的，因为它们通常更便于阅读，使得在进行比较时，看不到要比较的实际值。

  声明常量需要指定变量类型和关键字 const，同时必须给它们赋值，例如：

copy
const int intTwo = 2;

  这行代码是有效的，但如果编写如下代码：

copy
const int intTwo;
intTwo = 2; ❌

  就会产生一个编译错误。如果在最初的赋值之后，试图通过任何方式改变常量的值，也会产生编译错误。

在下面的示例中，将使用 switch 语句，根据用户为测试字符串输入的值，将不同字符串写到控制台上。 把以下代码添加到 Program.cs 中：

copy
static void Main(string[] args)
{
    const string myName = ""karli;
    const string sexyName = "angelina";
    const string sillyName = "ploppy";
    string name;
    Console.WriteLine("What is your name?");
    name = Console.ReadLine();
    switch(name.ToLower())
    {
        case myName:
            Console.WriteLine("You have the same name as me!");
            break;
        case sexyName:
            Console.WriteLine("My, what a sexy name you have!");
            break;
        case sillyName:
            Console.WriteLine("That's a very silly name");
            break;
    }
    Console.WriteLine("Hello {0}!", name);
    Console.ReadKey();
}

示例的说明   这段代码建立了 3 个常量字符串，接受用户输入的一个字符串，再根据输入的字符串把文本写到控制台上。这里，字符串是用户输入的姓名。

  在比较输入的姓名（在变量 name 中）和常量值时，首先要用

name.ToLower() 把输入的姓名转换为小写。name.ToLower() 是一个标准命令，可用于处理所有的字符串变量，在不能确定用户输入的内容时，使用它是很方便的。使用这个技术，字符串 Karli、kArLi、karli 等就会与测试字符串 karli 匹配了。  switch 语句尝试将输入的字符串与定义的常量值进行匹配，如果成功，就会用一条个性化的消息问候用户。如果不匹配，则只简单地问候用户。  switch 语句对 case 语句的数量上没有限制，所以可以扩展这段代码，使其包含自己能想到的每个姓名，但这需要耗费一些时间。