当前位置：极客教程 > C# > C# 教程 > C# 中的流控制

C# 中的流控制

C# 中的流控制，我们定义了几个关键字，这些关键字使我们能够控制 C# 程序的流程。

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

C# if语句

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

if (expression)
{
    statement;
}

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

Program.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");
            }
        }
    }
}

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

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

这两行生成< -5，5 >之间的随机整数。

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

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

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

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

C# else语句

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

Program.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关键字之后的块。

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

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

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

$ 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

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");
            }
        }
    }
}

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

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块。

$ 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 开始，match 表达式可以是任何非 null 表达式。

switch语句非常复杂。

选择星期几

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

Program.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;
            }
        }
    }
}

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

switch (dayOfWeek)
{
    ...
}

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

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

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

$ dotnet run
dies Solis

该程序在周日运行。

选择区域

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

Program.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”字符串打印到控制台。

string domain = Console.ReadLine();

从控制台读取用户输入。

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

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

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

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

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

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

$ 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

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;
            }
        }
    }
}

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

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

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

使用枚举作为匹配表达式

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

Program.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语句确定生成哪个颜色值。

$ dotnet run
The color is orange

$ dotnet run
The color is blue

$ dotnet run
The color is brown

我们运行程序。

switch表达式

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

Program.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和:元素替换为=&gt;。 default案例被_丢弃替换。 主体是表达式，而不是语句。

C# while语句

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

这是while循环的一般形式：

while (expression)
{
    statement;
}

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

Program.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循环分为三个部分。 初始化，测试和更新。 语句的每次执行都称为循环。

int i = 0;

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

while (i < 10)
{
   ...
}

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

i++;

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

do while语句

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

Program.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

using System;

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

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

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

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

for循环数组遍历

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

Program.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循环，我们按升序和降序打印值。

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

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

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

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

for循环中的更多表达式

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

Program.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);
        }
    }
}

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

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

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

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

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

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

嵌套循环

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

Program.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]);
                }
            }
        }
    }
}

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

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

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

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 循环的每个循环中完全执行。

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

这是输出。

C# foreach语句

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

Program.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语句遍历一系列行星。

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

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

$ dotnet run
Mercury
Venus
Earth
Mars
Jupiter
Saturn
Uranus
Neptune

运行程序将给出此输出。

C# break语句

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

Program.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 循环。

$ 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

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。

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

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

Python教程

Python 教程

Python 教程
Tkinter 教程

Tkinter 教程
Pandas 教程

Pandas 教程
NumPy 教程

NumPy 教程
Flask 教程

Flask 教程
Django 教程

Django 教程
PySpark 教程

PySpark 教程
wxPython 教程

wxPython 教程
SymPy 教程

SymPy 教程
Seaborn 教程

Seaborn 教程
SciPy 教程

SciPy 教程
RxPY 教程

RxPY 教程
Pycharm 教程

Pycharm 教程
Pygame 教程

Pygame 教程
PyGTK 教程

PyGTK 教程
PyQt 教程

PyQt 教程
PyQt5 教程

PyQt5 教程
PyTorch 教程

PyTorch 教程
Matplotlib 教程

Matplotlib 教程
Web2py 教程

Web2py 教程
BeautifulSoup 教程

BeautifulSoup 教程

Java教程

Java 教程

Java 教程

Web教程

HTML 教程

HTML 教程
CSS 教程

CSS 教程
CSS3 教程

CSS3 教程
jQuery 教程

jQuery 教程
Ajax 教程

Ajax 教程
AngularJS 教程

AngularJS 教程
TypeScript 教程

TypeScript 教程
WordPress 教程

WordPress 教程
Laravel 教程

Laravel 教程
Next.js 教程

Next.js 教程
PhantomJS 教程

PhantomJS 教程
Three.js 教程

Three.js 教程
Underscore.JS 教程

Underscore.JS 教程
WebGL 教程

WebGL 教程
WebRTC 教程

WebRTC 教程
VueJS 教程

VueJS 教程

数据库教程

SQL 教程

SQL 教程
MySQL 教程

MySQL 教程
MongoDB 教程

MongoDB 教程
PostgreSQL 教程

PostgreSQL 教程
SQLite 教程

SQLite 教程
Redis 教程

Redis 教程
MariaDB 教程

MariaDB 教程

图形图像教程

Vulkan 教程

Vulkan 教程
OpenCV 教程

OpenCV 教程

大数据教程

R语言 教程

R语言 教程

开发工具教程

Git 教程

Git 教程
VSCode 教程

VSCode 教程
Docker 教程

Docker 教程
Gerrit 教程

Gerrit 教程
Excel 教程

Excel 教程

计算机教程

Go语言 教程

Go语言 教程
C++ 教程

C++ 教程

C# 教程