# C# 中的流控制

> 原文： [https://zetcode.com/lang/csharp/flowcontrol/](https://zetcode.com/lang/csharp/flowcontrol/)

在 C# 教程的这一部分中，将讨论流控制。 我们定义了几个关键字，这些关键字使我们能够控制 C# 程序的流程。

在 C# 语言中，有几个关键字可用于更改程序的流程。 当程序运行时，语句从源文件的顶部到底部执行。 逐一。 可以通过特定的关键字更改此流程。 语句可以执行多次。 一些语句称为条件语句。 仅在满足特定条件时才执行它们。

## C# `if`语句

`if`语句具有以下一般形式：

```cs
if (expression)
{
    statement;
}

```

`if`关键字用于检查表达式是否为真。 如果为`true`，则执行一条语句。 该语句可以是单个语句或复合语句。 复合语句由该块包围的多个语句组成。 块是用大括号括起来的代码。

`Program.cs`

```cs
using System;

namespace IfStatement
{
    class Program
    {
        static void Main(string[] args)
        {
            var r = new Random();
            int n = r.Next(-5, 5);

            Console.WriteLine(n);

            if (n > 0)
            {
                Console.WriteLine("The n variable is positive");
            }
        }
    }
}

```

生成一个随机数。 如果数字大于零，我们将向终端打印一条消息。

```cs
var r = new Random();
int n = r.Next(-5, 5);

```

这两行生成 -5, 5 之间的随机整数。

```cs
if (n > 0)
{
    Console.WriteLine("The n variable is positive");
}

```

使用`if`关键字，我们检查生成的数字是否大于零。 `if`关键字后跟一对圆括号。 在方括号内，我们放置一个表达式。 该表达式产生布尔值。 如果布尔值是`true`，则执行两个大括号括起来的块。 在我们的例子中，字符串“`n`变量为正”被打印到终端上。 如果随机值为负，则不执行任何操作。 如果我们只有一个表达式，则大括号是可选的。

```cs
$ dotnet run
-3
$ dotnet run
-4
$ dotnet run
-1
$ dotnet run
1
The n variable is positive

```

满足条件后，消息将写入控制台。

## C# `else`语句

我们可以使用`else`关键字来创建一个简单的分支。 如果`if`关键字后方括号内的表达式的值为假，则将自动执行`else`关键字后方的语句。

`Program.cs`

```cs
using System;

namespace IfElse
{
    class Program
    {
        static void Main(string[] args)
        {
            var r = new Random();
            int n = r.Next(-5, 5);

            Console.WriteLine(n);

            if (n > 0)
            {
                Console.WriteLine("The number is positive");

            } else
            {
                Console.WriteLine("The number is negative");
            }
        }
    }
}

```

要么执行`if`关键字之后的块，要么执行`else`关键字之后的块。

```cs
if (n > 0)
{
    Console.WriteLine("The number is positive");

} else
{
    Console.WriteLine("The number is negative");
}

```

`else`关键字紧随`if`块的右大括号。 它有自己的块，用大括号括起来。

```cs
$ dotnet run
-3
The number is negative
$ dotnet run
-1
The number is negative
$ dotnet run
2
The number is positive

```

我们执行该程序三次。

## C# `else if`

我们可以使用`else if`关键字创建多个分支。 仅当不满足先前条件时，`else if`关键字才会测试其他条件。 请注意，我们可以在测试中使用多个`else if`关键字。

`Program.cs`

```cs
using System;

namespace MultipleBranches
{
    class Program
    {
        static void Main(string[] args)
        {
            var r = new Random();
            int n = r.Next(-5, 5);

            Console.WriteLine(n);

            if (n < 0)
            {
               Console.WriteLine("The n variable is negative");

            } else if (n == 0)
            {
              Console.WriteLine("The n variable is zero");

            } else
            {
              Console.WriteLine("The n variable is positive");
            }
        }
    }
}

```

以前的程序有一个小问题。 负值设为零。 以下程序将解决此问题。

```cs
if (n < 0)
{
    Console.WriteLine("The n variable is negative");

} else if (n == 0)
{
    Console.WriteLine("The n variable is zero");

} else
{
    Console.WriteLine("The n variable is positive");
}

```

如果第一个条件的计算结果为`true`，例如输入的值小于零，将执行第一个程序段，并跳过其余两个程序段。 如果不满足第一个条件，则检查`if else`关键字之后的第二个条件。 如果第二个条件的值为真，则执行第二个块。 如果不是，则执行`else`关键字之后的第三个程序段。 如果不满足先前的条件，则始终执行`else`块。

```cs
$ dotnet run
-1
The n variable is negative
$ dotnet run
4
The n variable is positive
$ dotnet run
1
The n variable is positive
$ dotnet run
0
The n variable is zero

```

我们执行该程序三次。 0 被正确处理。

## C# `switch`语句

`switch`语句是选择控制流语句。 它允许变量或表达式的值通过多路分支控制程序执行的流程。 与使用`if` / `else if` / `else`语句的组合相比，它以更简单的方式创建多个分支。

我们有一个变量或一个表达式。 `switch`关键字用于根据值列表测试变量或表达式中的值。 值列表用`case`关键字显示。 如果值匹配，则执行`case`之后的语句。 有一个可选的`default`语句。 如果找不到其他匹配项，则执行该命令。

从 C# 7.0 开始，匹配表达式可以是任何非`null`表达式。

`switch`语句非常复杂。

### 选择星期几

在下面的示例中，我们使用`switch`语句选择星期几。

`Program.cs`

```cs
using System;

namespace SwitchDayOfWeek
{
    class Program
    {
        static void Main(string[] args)
        {
            var dayOfWeek = DateTime.Now.DayOfWeek;

            switch (dayOfWeek)
            {
                case DayOfWeek.Sunday:
                    Console.WriteLine("dies Solis");
                    break;

                case DayOfWeek.Monday:
                    Console.WriteLine("dies Lunae");
                    break;

                case DayOfWeek.Tuesday:
                    Console.WriteLine("dies Martis");
                    break;

                case DayOfWeek.Wednesday:
                    Console.WriteLine("dies Mercurii");
                    break;

                case DayOfWeek.Thursday:
                    Console.WriteLine("dies Jovis");
                    break;

                case DayOfWeek.Friday:
                    Console.WriteLine("dies Veneris");
                    break;

                case DayOfWeek.Saturday:
                    Console.WriteLine("dies Saturni");
                    break;
            }
        }
    }
}

```

该示例确定星期几并打印其等效的拉丁语。

```cs
switch (dayOfWeek)
{
    ...
}

```

在圆括号中，`switch`关键字从要测试的表达式中获取一个值。 `switch`关键字的主体放在一对或大括号内。 在体内，我们可以放置多个`case`选项。 每个选项都以`break`关键字结尾。

```cs
case DayOfWeek.Sunday:
    Console.WriteLine("dies Solis");
    break;

```

使用`case`语句，我们测试匹配表达式的值。 如果它等于`DayOfWeek.Sunday`，则打印拉丁语`dies Solis`。

```cs
$ dotnet run
dies Solis

```

该程序在周日运行。

### 选择区域

要求用户输入域名。 读取域名并将其存储在变量中。 该变量使用`switch`关键字针对选项列表进行测试。

`Program.cs`

```cs
using System;

namespace SwitchStatement
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Write("Enter a domain name: ");

            string domain = Console.ReadLine();

            domain = domain.Trim().ToLower();

            switch (domain)
            {
                case "us":
                    Console.WriteLine("United States");
                break;

                case "de":
                    Console.WriteLine("Germany");
                break;

                case "sk":
                    Console.WriteLine("Slovakia");
                break;

                case "hu":
                    Console.WriteLine("Hungary");
                break;

                default:
                    Console.WriteLine("Unknown");
                break;
            }
        }
    }
}

```

在我们的程序中，我们有一个`domain`变量。 我们从命令行读取变量的值。 我们使用`case`语句测试变量的值。 有几种选择。 例如，如果该值等于“ us”，则将“ United States”字符串打印到控制台。

```cs
string domain = Console.ReadLine();

```

从控制台读取用户输入。

```cs
domain = domain.Trim().ToLower();

```

`Trim()`方法从潜在的前导和尾随空白中剥离变量。 `ToLower()`将字符转换为小写。 现在，“ us”，“ US”，“ us”是美国域名的可行选项。

```cs
case "us":
    Console.WriteLine("United States");
break;

```

在这种情况下，我们测试域变量是否等于`"us"`字符串。 如果为`true`，则将消息打印到控制台。 该选项以`break`关键字结束。 如果成功求值了其中一个选项，则`break`关键字将终止`switch`块。

```cs
default:
    Console.WriteLine("Unknown");
break;

```

`default`关键字是可选的。 如果没有求值`case`选项，则执行`default`部分。

```cs
$ dotnet run
Enter a domain name: us
United States

$ dotnet run
Enter a domain name: HU
Hungary

$ dotnet run
Enter a domain name: pl
Unknown

```

我们执行该程序几次。

### 使用`when`语句

`case`语句可与`when`语句一起使用以指定其他条件。

`Program.cs`

```cs
using System;

namespace SwitchWhen
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Write("Enter your age: ");

            var input = Console.ReadLine();

            var age = Int32.Parse(input.Trim());

            switch (age)
            {
                case var myAge when myAge < 0:
                    Console.WriteLine("Age cannot be a negative value");
                break;

                case var myAge when myAge > 130:
                    Console.WriteLine("This is an unlikely high age");
                break;

                default:
                    Console.WriteLine("The entered age is {0}", age);
                break;
            }
        }
    }
}

```

在程序中，要求用户输入他的年龄。

```cs
case var myAge when myAge < 0:
    Console.WriteLine("Age cannot be a negative value");
break;

```

借助`when`表达式，我们测试输入的值是否小于 0。使用​​`var`关键字，我们创建一个临时的`myAge`变量。

### 使用枚举作为匹配表达式

对于匹配的表达式，我们可以使用任何类型。 在下面的示例中，我们使用枚举。

`Program.cs`

```cs
using System;

namespace SwitchEnum
{
    enum Color { Red, Green, Blue, Brown, Yellow, Pink, Orange }

    class Program
    {
        static void Main(string[] args)
        {
            var color = (Color) (new Random()).Next(0, 7);

            switch (color)
            {
                case Color.Red:
                    Console.WriteLine("The color is red");
                    break;

                case Color.Green:
                    Console.WriteLine("The color is green");
                    break;

                case Color.Blue:
                    Console.WriteLine("The color is blue");
                    break;

                case Color.Brown:
                    Console.WriteLine("The color is brown");
                    break;

                case Color.Yellow:
                    Console.WriteLine("The color is yellow");
                    break;

                case Color.Pink:
                    Console.WriteLine("The color is pink");
                    break;

                case Color.Orange:
                    Console.WriteLine("The color is orange");
                    break;

                default:
                    Console.WriteLine("The color is unknown.");
                    break;
            }
        }
    }
}

```

该示例随机生成颜色枚举。 `swith`语句确定生成哪个颜色值。

```cs
$ dotnet run
The color is orange

$ dotnet run
The color is blue

$ dotnet run
The color is brown

```

我们运行程序。

## `switch`表达式

`switch`表达式使`switch`语句的语法更加简洁。 它们是在 C# 8.0 中引入的。

`Program.cs`

```cs
using System;

namespace SwitchExpressions
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Write("Enter a domain name: ");

            string domain = Console.ReadLine();

            domain = domain.Trim().ToLower();

            string result = domain switch
            {
                "us" => "United States",
                "de" => "Germany",
                "sk" => "Slovakia",
                "hu" => "Hungary",

                _ => "Unknown"
            };

            Console.WriteLine(result);
        }
    }
}

```

该变量位于`switch`关键字之前。 `case`和`:`元素替换为`=>`。 `default`案例被`_`丢弃替换。 主体是表达式，而不是语句。

## C# `while`语句

`while`语句是一个控制流语句，它允许根据给定的布尔条件重复执行代码。

这是`while`循环的一般形式：

```cs
while (expression)
{
    statement;
}

```

`while`关键字在大括号括起来的块内执行语句。 每次将表达式求值为`true`时都会执行这些语句。

`Program.cs`

```cs
using System;

namespace WhileStatement
{
    class Program
    {
        static void Main(string[] args)
        {
            int i = 0;
            int sum = 0;

            while (i < 10)
            {
                i++;
                sum += i;
            }

            Console.WriteLine(sum);
        }
    }
}

```

在代码示例中，我们从一系列数字计算值的总和。

`while`循环分为三个部分。 初始化，测试和更新。 语句的每次执行都称为循环。

```cs
int i = 0;

```

我们启动`i`变量。 它用作计数器。

```cs
while (i < 10)
{
   ...
}

```

`while`关键字后的圆括号内的表达式是第二阶段，即测试。 执行主体中的语句，直到表达式的计算结果为`false`。

```cs
i++;

```

这是`while`循环的最后一个第三阶段，即更新。 我们增加计数器。 请注意，对`while`循环的不正确处理可能会导致循环不断。

### `do while`语句

可以至少运行一次该语句。 即使不满足条件。 为此，我们可以使用`do while`关键字。

`Program.cs`

```cs
using System;

namespace DoWhile
{
    class Program
    {
        static void Main(string[] args)
        {
            int count = 0;

            do {
                Console.WriteLine(count);
            } while (count != 0);
        }
    }
}

```

首先执行该块，然后求值真值表达式。 在我们的情况下，条件不满足，`do while`语句终止。

## C# 循环语句

如果在启动循环之前知道周期数，则可以使用`for`语句。 在此构造中，我们声明一个计数器变量，该变量在每次循环重复期间会自动增加或减少值。

## 简单的循环

`for`循环分为三个阶段：初始化，条件和代码块执行以及递增。

`Program.cs`

```cs
using System;

namespace ForStatement
{
    class Program
    {
        static void Main(string[] args)
        {
            for (int i=0; i<10; i++)
            {
                Console.WriteLine(i);
            }
        }
    }
}

```

在此示例中，我们将数字`0..9`打印到控制台。

```cs
for (int i=0; i<9; i++)
{
    Console.WriteLine(i);
}

```

分为三个阶段。 在第一阶段，我们将计数器`i`初始化为零。 此阶段仅完成一次。 接下来是条件。 如果满足条件，则执行`for`块中的语句。 在第三阶段，计数器增加。 现在，我们重复 2、3 个阶段，直到不满足条件并保留`for`循环为止。 在我们的情况下，当计数器`i`等于 10 时，`for`循环停止执行。

## `for`循环数组遍历

`for`循环可用于遍历数组。 从数组的`Length`属性，我们知道数组的大小。

`Program.cs`

```cs
using System;

namespace ForStatement2
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] planets = { "Mercury", "Venus", "Earth",
                "Mars", "Jupiter", "Saturn", "Uranus", "Pluto" };

            for (int i = 0; i < planets.Length; i++)
            {
                Console.WriteLine(planets[i]);
            }

            Console.WriteLine("In reverse:");

            for (int i = planets.Length - 1; i >= 0; i--)
            {
                Console.WriteLine(planets[i]);
            }
        }
    }
}

```

我们有一个数组，用于保存太阳系中行星的名称。 使用两个`for`循环，我们按升序和降序打印值。

```cs
for (int i = 0; i < planets.Length; i++)
{
    Console.WriteLine(planets[i]);
}

```

通过从零开始的索引访问数组。 第一项的索引为 0。因此，`i`变量被初始化为零。 条件检查`i`变量是否小于数组的长度。 在最后阶段，`i`变量增加。

```cs
for (int i = planets.Length - 1; i >= 0; i--)
{
    Console.WriteLine(planets[i]);
}

```

此`for`循环以相反顺序打印数组的元素。 `i`计数器被初始化为数组大小。 由于索引基于零，因此最后一个元素的索引数组大小为 1。 该条件确保计数器大于或等于零。 （数组索引不能为负数）。 在第三步中，`i`计数器递减 1。

## `for`循环中的更多表达式

可以在`for`循环的初始化和迭代阶段中放置更多表达式。

`Program.cs`

```cs
using System;

namespace ForStatement3
{
    class Program
    {
        static void Main(string[] args)
        {
            var r = new Random();
            var values = new int[10];

            int sum = 0;
            int num = 0;

            for (int i = 0; i < 10; i++, sum += num)
            {
                num = r.Next(10);
                values[i] = num;
            }

            Console.WriteLine(string.Join(",", values));
            Console.WriteLine("The sum of the values is {0}", sum);
        }
    }
}

```

在我们的示例中，我们创建了一个十个随机数的数组。 计算这些数字的总和。

```cs
for (int i = 0; i < 10; i++, sum += num)
{
    num = r.Next(10);
    values[i] = num;
}

```

在`for`循环的第三部分中，我们有两个用逗号分隔的表达式。 `i`计数器增加，并且当前编号添加到`sum`变量中。

```cs
Console.WriteLine(string.Join(",", values));

```

使用`System.String`类的`Join()`方法，一次打印出数组的所有值。 它们将以逗号分隔。

```cs
$ dotnet run
9,3,1,7,9,8,5,6,3,3
The sum of the values is 54

```

We run the program.

### 嵌套循环

`For`语句可以嵌套； 即一个`for`语句可以放在另一个`for`语句中。 嵌套`for`循环的所有循环都针对外部`for`循环的每个循环执行。

`Program.cs`

```cs
using System;

namespace NestedForLoops
{
    class Program
    {
        static void Main(string[] args)
        {
            var a1 = new string[] { "A", "B", "C" };
            var a2 = new string[] { "A", "B", "C" };

            for (int i=0; i<a1.Length; i++)
            {
                for (int j=0; j<a2.Length; j++)
                {
                    Console.WriteLine(a1[i] + a2[j]);
                }
            }
        }
    }
}

```

在此示例中，我们创建了两个数组的笛卡尔乘积。

```cs
var a1 = new string[] { "A", "B", "C" };
var a2 = new string[] { "A", "B", "C" };

```

我们有两个数组。 每个数组都有树字母。 凯氏积是当一个数组中的每个元素与另一数组中的所有元素配对时。 为此，我们使用嵌套的`for`循环。

```cs
for (int i=0; i<a1.Length; i++)
{
    for (int j=0; j<a2.Length; j++)
    {
        Console.WriteLine(a1[i] + a2[j]);
    }
}

```

在另一个父 for 循环中有一个嵌套的 for 循环。 嵌套的 for 循环在父 for 循环的每个循环中完全执行。

```cs
$ dotnet run
AA
AB
AC
BA
BB
BC
CA
CB
CC

```

这是输出。

## C# `foreach`语句

`foreach`构造简化了遍历数据集合的过程。 它没有明确的计数器。 `foreach`语句一个接一个地遍历数组或集合，并将当前值复制到构造中定义的变量中。

`Program.cs`

```cs
using System;

namespace ForeachStatement
{
    class Program
    {
        static void Main(string[] args)
        {
            string[] planets = { "Mercury", "Venus",
                "Earth", "Mars", "Jupiter", "Saturn",
                "Uranus", "Neptune" };

            foreach (string planet in planets)
            {
                Console.WriteLine(planet);
            }
        }
    }
}

```

在此示例中，我们使用`foreach`语句遍历一系列行星。

```cs
foreach (string planet in planets)
{
    Console.WriteLine(planet);
}

```

`foreach`语句的用法很简单。 `planets`是我们迭代通过的数组。 `planet`是一个临时变量，具有数组中的当前值。 `foreach`语句遍历所有行星并将它们打印到控制台。

```cs
$ dotnet run
Mercury
Venus
Earth
Mars
Jupiter
Saturn
Uranus
Neptune

```

运行程序将给出此输出。

## C# `break`语句

`break`语句可用于终止由`while`，`for`或`switch`语句定义的块。

`Program.cs`

```cs
using System;

namespace BreakStatement
{
    class Program
    {
        static void Main(string[] args)
        {
            var random = new Random();

            while (true)
            {
                int num = random.Next(1, 30);
                Console.Write("{0} ", num);

                if (num == 22)
                {
                    break;
                }
            }

            Console.Write('\n');
        }
    }
}

```

我们定义了一个无限的`while`循环。 我们使用`break`语句退出此循环。 我们从 1 到 30 中选择一个随机值。我们打印该值。 如果该值等于 22，则结束无穷的`while`循环。

```cs
$ dotnet run
18 3 21 26 12 27 23 25 2 21 15 4 18 12 24 13 7 19 10 26 5 22

```

我们可能会得到这样的东西。

## C# `continue`语句

`continue`语句用于跳过循环的一部分，并继续循环的下一个迭代。 它可以与`for`和`while`语句结合使用。

在下面的示例中，我们将打印一个数字列表，这些数字不能除以 2 而没有余数。

`Program.cs`

```cs
using System;

namespace ContinueStatement
{
    class Program
    {
        static void Main(string[] args)
        {
            int num = 0;

            while (num < 1000)
            {
                num++;

                if ((num % 2) == 0)
                {
                    continue;
                }

                Console.Write("{0} ", num);
            }

            Console.Write('\n');
        }
    }
}

```

我们使用`while`循环遍历数字`1..999`。

```cs
if ((num % 2) == 0)
{
    continue;
}

```

如果表达式`num % 2`返回 0，则可以将所讨论的数字除以 2。执行`continue`语句，并跳过循环的其余部分。 在我们的例子中，循环的最后一条语句将被跳过，并且数字不会输出到控制台。 下一个迭代开始。

在 C# 教程的这一部分中，我们介绍了 C# 控件流结构。