Skip to content

3. C# 语言基础

3.1. 引言

我们先把 C# 当作一种传统的编程语言来对待。类将在下一章介绍。在程序中,有两个主要组成部分:

  • 数据;
  • 操作这些数据的指令。

我们通常力求把数据与指令分离:

Image

本章的所有示例都是 单文件应用程序:一个单独的 [.cs] 文件,没有项目文件([.csproj]),使用命令 [dotnet run basics-01.cs] 运行。该特性随 .NET 10 引入,已在上一章中介绍。示例位于课程代码的 [03-basics] 文件夹中。它们在法语区域设置(fr-FR)下运行,就像在法国的 Windows 机器上一样:实数使用小数逗号显示。

3.2. 最小程序

3.2.1. 顶级语句

程序 [basics-01.cs] 内容如下:

1
2
3
4
5
// 使用顶级语句(C# 9)编写的最小程序
// 语句直接写在文件中:没有类,也没有 Main 方法
Console.WriteLine("Hello world!");
// Console 类的完整名称是 System.Console
System.Console.WriteLine("Number of arguments received: " + args.Length);

结果:

1
2
3
> dotnet run basics-01.cs
Hello world!
Number of arguments received: 0

说明:

  • 程序既不包含类也不包含方法:语句直接写在文件中。这称为 顶级语句 (C# 9,2020 年)。一个程序文件中可以包含这类语句;
  • 第 3 行:[Console] 类的 [WriteLine] 方法在屏幕上输出一行;
  • 第 5 行:类 [Console] 属于 命名空间 [System]。它的完整名称是 [System.Console]。命名空间把相关的类型组织在一起,就像文件夹把文件组织在一起一样;
  • 第 5 行:程序有一个数组 [args] ,其中包含命令行参数。我们将在“主程序参数”一节中再讨论它。数组的元素个数为 [args.Length]。这里的 + 运算符把字符串和数字连接起来:数字会先被转换为字符串。

带两个命令行参数时([--] 之后的所有内容都会传递给程序):

1
2
3
> dotnet run basics-01.cs -- a0 a1
Hello world!
Number of arguments received: 2

3.2.2. 带有 Main 方法的经典形式

2008 年的课程(C# 3.0)没有涉及顶级语句。同样的程序当时是这样写的:[basics-02.cs]:

// 同一程序的经典写法(C# 8 之前只有这一种)
using System;

namespace Basics
{
    class Program
    {
        // Main 方法是程序的入口点
        static void Main(string[] args)
        {
            Console.WriteLine("Hello world!");
            System.Console.WriteLine("Number of arguments received: " + args.Length);
        }
    }
}

结果:

1
2
3
> dotnet run basics-02.cs
Hello world!
Number of arguments received: 0

说明:

  • 第 2 行:指令 [using] 导入命名空间 [System]。这样就可以写 [Console] 而不是 [System.Console];
  • 第 4 行:类被放在 [Basics] 命名空间中。从 C# 10 起,可以写成 [namespace Basics;] (文件范围的命名空间):整个文件都属于这个命名空间,不需要花括号,也不需要额外缩进。从现在起我们将使用这种形式;
  • 第 6 行:在 C# 中,所有代码都属于某个类。这里的类名为 [Program];
  • 第 9 行:静态方法 [Main] 是程序的 入口点:系统在启动时执行的就是这个方法。它的参数 [args],接收命令行参数。

这两个程序是等价的。当编译器遇到顶级语句时,会生成一个类和一个名为 [Main] 的方法来包含这些语句,同时还有参数 [string[] args]。因此,顶级语句只是标准语法的一种简写形式。它们很适合本章中的小程序;而当你想查看包含 [Main] 的类时,标准语法仍然有用。

3.2.3. 隐式 using 语句

程序 [basics-01.cs] 使用了类 [Console] ,却没有 [using System;] 指令。之所以可行,是因为 .NET SDK 会为每个控制台程序自动添加一个生成的文件,其中包含 [global using] 指令(C# 10),这些指令作用于程序中的所有文件。对于 [basics-01.cs],该文件的内容为:

1
2
3
4
5
6
7
8
// <auto-generated/>
global using System;
global using System.Collections.Generic;
global using System.IO;
global using System.Linq;
global using System.Net.Http;
global using System.Threading;
global using System.Threading.Tasks;

这些就是 隐式 using 语句:最常用的命名空间会被自动导入。不在此列表中的命名空间,例如 [System.Globalization],必须始终在文件顶部使用 [using] 指令导入。因此,在程序 [basics-02.cs] 中,指令 [using System;] 是多余的:我们保留它是为了展示 2008 年的写法。

3.3. C# 数据

C# 使用以下数据类型:

  • 整数;
  • 实数;
  • 十进制数;
  • 字符和字符串;
  • 布尔值;
  • 对象。

3.3.1. 预定义数据类型

C# 类型
.NET 类型
表示的数据
字面量后缀
编码
取值范围
[char]
[Char] (S)
字符
 
2 字节
Unicode 字符(UTF-16)
[string]
[String] (C)
字符串
  
对 Unicode 字符序列的引用
[int]
[Int32] (S)
整数
 
4 字节
[-2³¹, 2³¹-1] 或 [-2147483648, 2147483647]
[uint]
[UInt32] (S)
无符号整数
U
4 字节
[0, 2³²-1] 或 [0, 4294967295]
[long]
[Int64] (S)
整数
L
8 字节
[-2⁶³, 2⁶³-1] 或 [-9223372036854775808, 9223372036854775807]
[ulong]
[UInt64] (S)
无符号整数
UL
8 字节
[0, 2⁶⁴-1] 或 [0, 18446744073709551615]
[sbyte]
[SByte] (S)
整数
 
1 字节
[-2⁷, 2⁷-1] 或 [-128, 127]
[byte]
[Byte] (S)
无符号整数
 
1 字节
[0, 2⁸-1] 或 [0, 255]
[short]
[Int16] (S)
整数
 
2 字节
[-2¹⁵, 2¹⁵-1] 或 [-32768, 32767]
[ushort]
[UInt16] (S)
无符号整数
 
2 字节
[0, 2¹⁶-1] 或 [0, 65535]
[float]
[Single] (S)
实数
F
4 字节
绝对值为 [1,5 10⁻⁴⁵, 3,4 10³⁸],7 位有效数字
[double]
[Double] (S)
实数
D
8 字节
绝对值为 [5,0 10⁻³²⁴, 1,7 10³⁰⁸],15 到 16 位有效数字
[decimal]
[Decimal] (S)
十进制数
M
16 字节
绝对值为 [1,0 10⁻²⁸, 7,9 10²⁸],28 到 29 位有效数字
[bool]
[Boolean] (S)
布尔值
 
1 字节
[true]、[false]
[object]
[Object] (C)
对象引用
  
对任意类型对象的引用

上面列出了每种 C# 类型对应的 .NET 类型,如果该类型是结构则标记为 (S),如果是类则标记为 (C)。可以看到,32 位整数有两个可能的名称:[int] 和 [Int32]。类型 [int] 是 C# 关键字。[Int32] 是属于 [System] 命名空间的结构:它的完整名称是 [System.Int32]。类型 [int] 是 C# 的 别名 ,指向 .NET 结构 [System.Int32]。同样,C# 类型 [string] 是 .NET 类型 [System.String] 的别名。[System.String] 是类,而不是结构。这两个概念相似,但有如下根本区别:

  • 结构类型的变量直接包含它的值:这称为 值类型;
  • 类类型的变量包含对象的地址(即它的 引用);这称为 引用类型。

此外,还有两种不太常用的类型:

  • [nint] 和 [nuint] (C# 9)分别是有符号和无符号整数,其大小等于内存地址的大小:32 位系统上为 4 字节,64 位系统上为 8 字节。它们主要用于与本机代码交互;
  • [System.Half] (.NET 5)是一种 2 字节的低精度浮点数,用于图形计算和机器学习。它不是语言预定义的类型:它没有对应的 C# 关键字。

结构和类一样,是带有属性和方法的复杂类型。因此,我们可以这样写:

string? typeName = 3.GetType().FullName;

字面量 3 默认是 C# 的 [int] 类型,因此也是 .NET 的 [System.Int32] 类型。这个结构有一个方法 [GetType()] ,返回描述数据类型的对象。在该对象的属性中,[FullName] 是类型的完整名称。因此,字面量 3 是一个比乍看之下更复杂的对象。[string?] 中的问号稍后会解释。

程序 [basics-03.cs] 演示了这几点:

// 预定义类型:.NET 类型及其字节大小
int integer = 2;
float fl = 10.5F;
double d = -4.6;
string s = "test";
uint ui = 5;
long l = 1000;
ulong ul = 1001;
byte octet = 5;
sbyte so = -5;
short sh = -4;
ushort ush = 10;
decimal dec = 10.67M;
bool b = true;
char c = 'A';
// {0}、{1}、{2} 会被格式字符串之后的第 0、1、2 号参数替换
Console.WriteLine("Type of integer[{1}] : [{0},{2}]", integer.GetType().FullName, integer, sizeof(int));
Console.WriteLine("Type of fl[{1}] : [{0},{2}]", fl.GetType().FullName, fl, sizeof(float));
Console.WriteLine("Type of d[{1}] : [{0},{2}]", d.GetType().FullName, d, sizeof(double));
Console.WriteLine("Type of s[{1}] : [{0}]", s.GetType().FullName, s);
Console.WriteLine("Type of ui[{1}] : [{0},{2}]", ui.GetType().FullName, ui, sizeof(uint));
Console.WriteLine("Type of l[{1}] : [{0},{2}]", l.GetType().FullName, l, sizeof(long));
Console.WriteLine("Type of ul[{1}] : [{0},{2}]", ul.GetType().FullName, ul, sizeof(ulong));
Console.WriteLine("Type of octet[{1}] : [{0},{2}]", octet.GetType().FullName, octet, sizeof(byte));
Console.WriteLine("Type of so[{1}] : [{0},{2}]", so.GetType().FullName, so, sizeof(sbyte));
Console.WriteLine("Type of sh[{1}] : [{0},{2}]", sh.GetType().FullName, sh, sizeof(short));
Console.WriteLine("Type of ush[{1}] : [{0},{2}]", ush.GetType().FullName, ush, sizeof(ushort));
Console.WriteLine("Type of dec[{1}] : [{0},{2}]", dec.GetType().FullName, dec, sizeof(decimal));
Console.WriteLine("Type of b[{1}] : [{0},{2}]", b.GetType().FullName, b, sizeof(bool));
Console.WriteLine("Type of c[{1}] : [{0},{2}]", c.GetType().FullName, c, sizeof(char));
// 大小等于内存地址的整数(4 或 8 字节,取决于机器)
nint ni = 7;
Console.WriteLine("Type of ni[{1}] : [{0},{2}]", ni.GetType().FullName, ni, nint.Size);
// 2 字节实数(.NET 5)
Half h = (Half)1.5;
Console.WriteLine("Type of h[{1}] : [{0}]", h.GetType().FullName, h);
// 字面量 3 同样是一个对象
Console.WriteLine("Type of the literal 3 : " + 3.GetType().FullName);
// 极值
Console.WriteLine("int : [{0}, {1}]", int.MinValue, int.MaxValue);
Console.WriteLine("long : [{0}, {1}]", long.MinValue, long.MaxValue);
Console.WriteLine("decimal : [{0}, {1}]", decimal.MinValue, decimal.MaxValue);

结果:

> dotnet run basics-03.cs
Type of integer[2] : [System.Int32,4]
Type of fl[10,5] : [System.Single,4]
Type of d[-4,6] : [System.Double,8]
Type of s[test] : [System.String]
Type of ui[5] : [System.UInt32,4]
Type of l[1000] : [System.Int64,8]
Type of ul[1001] : [System.UInt64,8]
Type of octet[5] : [System.Byte,1]
Type of so[-5] : [System.SByte,1]
Type of sh[-4] : [System.Int16,2]
Type of ush[10] : [System.UInt16,2]
Type of dec[10,67] : [System.Decimal,16]
Type of b[True] : [System.Boolean,1]
Type of c[A] : [System.Char,2]
Type of ni[7] : [System.IntPtr,8]
Type of h[1,5] : [System.Half]
Type of the literal 3 : System.Int32
int : [-2147483648, 2147483647]
long : [-9223372036854775808, 9223372036854775807]
decimal : [-79228162514264337593543950335, 79228162514264337593543950335]

说明:

  • 第 2 行:声明一个初始化为 2 的整数 [integer] ;
  • 第 16 行:语句 [Console.WriteLine("... {0} ... {1} ...", param0, param1, ...)] 在屏幕上显示作为第一个参数指定的文本(即 格式),并把其中每个 {i} 替换为格式之后第 i 个参数的值。参数从 0 开始编号;
  • 第 17 行:变量 [v] 的类型通过 [v.GetType().FullName] 获得。预定义值类型 [T] 的字节大小通过 [sizeof(T)] 获得;
  • 第 20 行:由于类型 [string] 指向的是类而不是结构,因此不能使用运算符 [sizeof];
  • 第 33 行:[sizeof(nint)] 在普通代码中是不允许的,因为 [nint] 的大小只有在运行时才知道。属性 [nint.Size] 表明在当前使用的 64 位机器上它是 8 字节;
  • 第 35 行:不能写 [Half h = 1.5;]:从 [double] 到 [Half] 没有隐式转换。记法 [(Half)] 是 显式转换 (英文称为“cast”),我们稍后会讨论;
  • 第 40–42 行:数值类型的属性 [MinValue] 和 [MaxValue] 指明了它们取值范围的边界。

输出显示的是 .NET 类型名称,而不是 C# 别名。请注意浮点数使用的小数逗号:数字会根据系统的区域设置(此处为法语)转换为字符串。

3.3.2. 字面量数据的表示法

数据
字面量示例
[int] 整数(32 位)
145, -7, 0xFF(十六进制), 0b1010_1010(二进制)
整数 [long] (64 位),后缀 L
100000L, 1_000_000_000_000L
无符号整数,后缀 U 或 UL
4000000000U, 10UL
浮点数 [double]
134.789, -45E-18 (-45 × 10⁻¹⁸)
实数 [float],后缀 F
134.789F, -45E-18F
实数 [decimal],后缀 M
100000.50M
字符 [char]
'A', 'b', '\n', '\u00e9'
字符串 [string]
"today", "c:\\chap1", @"c:\chap1", $"{name} is {age} years old", """plain text"""
布尔值 [bool]
[true]、[false]
日期
[new DateTime(1954, 10, 13)] (年、月、日),表示 1954 年 10 月 13 日

在源代码中,无论系统的区域设置如何,浮点数始终使用小数点书写。自 C# 7 起,整数可以用二进制书写(以 [0b] 为前缀),数字组之间可以用 _ 字符分隔以提高可读性:[1_000_000] 就是整数一百万。

标准字符串字面量可以包含以 \ 字符开头的 转义序列 :"\n" 表示行结束字符,而不是 \ 和 n 这两个字符的序列,"\t" 表示制表符,"\"" 表示双引号,"\\" 表示 \ 字符本身。因此,要写 Windows 路径 c:\chap1\paragraph3,必须写成 "c:\\chap1\\paragraph3"。你也可以写成 @"c:\chap1\paragraph3":@"text" 语法表示文本按所写原样采用,不解释 \ 字符。这称为 逐字字符串。

C# 现在还提供另外两种字符串:

  • 插值字符串 (C# 6)$"...":花括号中的表达式会被求值,其值会被插入字符串。表达式后可以在冒号之后跟一个格式说明符:[$"{d1:F2}"] 以两位小数显示浮点数 [d1] 。这是构造字符串最易读的方式,从现在起我们将使用它来代替 {0}、{1}…… 这样的格式;
  • 原始字符串 (C# 11)"""...""":它以至少三个引号开头和结尾。它可以包含引号和未转义的 \ 字符,并且可以跨多行。结束引号之前的空格会从每一行中删除,因此文本可以与代码一起缩进。这对编写 JSON、SQL 或 HTML 非常有用。

程序 [basics-04.cs] 演示了这些不同的表示法:

// 字面量数据的写法
// 整数:十进制、十六进制(0x)、二进制(0b),分隔符 _
int i1 = 145, i2 = -7, i3 = 0xFF, i4 = 0b1010_1010;
long l1 = 100000L, l2 = 1_000_000_000_000L;
Console.WriteLine("integers : {0} {1} {2} {3} {4} {5}", i1, i2, i3, i4, l1, l2);
// 实数
double d1 = 134.789, d2 = -45E-18;
float f1 = 134.789F;
decimal m1 = 100000.50M;
Console.WriteLine("reals : {0} {1} {2} {3}", d1, d2, f1, m1);
// 字符和布尔值
char c1 = 'A', c2 = '\u00e9';
bool b1 = true;
Console.WriteLine("characters : {0} {1}, boolean : {2}", c1, c2, b1);
// 日期:(年,月,日)
DateTime birth = new DateTime(1954, 10, 13);
Console.WriteLine("date : {0}", birth.ToShortDateString());

// 经典字符串:\ 字符引入转义序列
string path1 = "c:\\chap1\\paragraph3";
// 逐字字符串:文本按原样处理
string path2 = @"c:\chap1\paragraph3";
Console.WriteLine(path1);
Console.WriteLine(path2);
Console.WriteLine("line 1\nline 2\t[tab]");

// 插值字符串:计算花括号之间的表达式
string name = "dupont";
int age = 23;
Console.WriteLine($"{name} is {age} years old, in 10 years he will be {age + 10}");
// 在 : 字符之后指定格式
Console.WriteLine($"d1={d1:F1}, i3 in hexadecimal={i3:X}, i4 in binary={i4:B8}, l2={l2:N0}");
Console.WriteLine($"date={birth:dddd d MMMM yyyy}");

// 原始字符串(C# 11):无需转义,也无需将引号写两遍
string json = """
    {
      "name": "dupont",
      "path": "c:\chap1"
    }
    """;
Console.WriteLine(json);
// 插值原始字符串:使用 $$ 时,表达式写在 {{ 和 }} 之间
string json2 = $$"""{ "name": "{{name}}", "age": {{age}} }""";
Console.WriteLine(json2);

结果:

> dotnet run basics-04.cs
integers : 145 -7 255 170 100000 1000000000000
reals : 134,789 -4,5E-17 134,789 100000,50
characters : A é, boolean : True
date : 13/10/1954
c:\chap1\paragraph3
c:\chap1\paragraph3
line 1
line 2    [tab]
dupont is 23 years old, in 10 years he will be 33
d1=134,8, i3 in hexadecimal=FF, i4 in binary=10101010, l2=1 000 000 000 000
date=mercredi 13 octobre 1954
{
  "name": "dupont",
  "path": "c:\chap1"
}
{ "name": "dupont", "age": 23 }

说明:

  • 第 3 行:[0xFF] 是 255,[0b1010_1010] 是 170;
  • 第 7 行:-45E-18 显示为 -4,5E-17:这是同一个值,经过了规范化;
  • 第 12 行:序列 \u00e9 表示十六进制编码为 00E9 的 Unicode 字符,即 é;
  • 第 16 行:一个日期。方法 [ToShortDateString] 以法语文化中使用的短格式显示它。对于不含时间的日期,.NET 6 新增了类型 [DateOnly];我们将在第 5 章再讨论它;
  • 第 20–22 行:两个字符串是相同的,如输出所示;
  • 第 30 行:一个插值字符串。表达式 [name]、[age]和 [age + 10] 会被求值,然后插入字符串;
  • 第 32 行:几种格式:F1(一位小数)、X(十六进制)、B8(8 位二进制,.NET 8)、N0(千位分隔符,无小数);
  • 第 33 行:一种自定义日期格式:星期几、日、用文字表示的月份、年;
  • 第 36–41 行:一个多行原始字符串。引号和 \ 字符按原样书写。结束引号之前的四个空格已从每一行中删除;
  • 第 44 行:一个插值原始字符串。使用两个 $ 字符时,表达式写在双花括号 {{ 和 }} 之间:JSON 中经常出现的单花括号则保持为普通文本。

3.3.3. 数据声明

3.3.3.1. 声明的作用

程序处理的数据由名称和类型来刻画。这些数据存储在内存中。程序编译时,编译器会为每个数据分配一个内存位置,由地址和大小来刻画。编译器根据程序员所做的声明来完成这项工作。此外,这些声明还使编译器能够检测编程错误。例如,如果 [x = x * 2;] 中的 [x] 是字符串,该操作就会被判定为无效。

3.3.3.2. 声明常量

声明常量的语法如下:

const type name = value;

例如:

const double VatRate = 0.2;

为什么要声明常量?

  • 如果给常量起一个有意义的名称,程序会更易读;
  • 如果需要更改“常量”,修改程序也更容易。例如,如果增值税率变为 0.25,唯一需要修改的就是定义其值的那条语句:[const double VatRate = 0.25;]。如果程序中直接使用了 0.2,就需要修改许多条语句。

常量的值必须在编译时已知:可以是数字、字符串、布尔值,或者能由其他常量计算出的表达式。按照约定,在 .NET 中,常量名以大写字母开头。

3.3.3.3. 变量声明

变量由名称标识,并与一种数据类型相关联。C# 区分大写字母和小写字母:变量 [END] and [end] 是不同的。

变量可以在声明时初始化。声明一个或多个变量的语法是:

type variable1 = value1, variable2 = value2, ...;

其中 [type] 是预定义类型或由程序员定义的类型。初始化是可选的;但是,C# 不允许使用尚未被赋值的局部变量。

你也可以用关键字 [var] 代替类型,从而省略变量的类型:

var variable1 = value1;

关键字 [var] 并不意味着变量没有确定的类型:它的类型就是赋给它的值的类型,由编译器确定。这里必须初始化,编译器才能推断出类型。当类型从值上显而易见时,我们使用 [var]。

程序 [basics-05.cs] 内容如下:

// 常量和变量
const double VatRate = 0.2;
const string Currency = "euros";
double priceExclTax = 100;
Console.WriteLine($"Price incl. tax : {priceExclTax * (1 + VatRate)} {Currency}");

// 显式指定类型的数据
int i = 2;
Console.WriteLine($"Type of int i=2 : {i.GetType().Name},{i.GetType().FullName}");
// 使用 var 隐式推断类型的数据
var j = 3;
Console.WriteLine($"Type of var j=3 : {j.GetType().Name},{j.GetType().FullName}");
var today = DateTime.Now;
Console.WriteLine($"Type of var today : {today.GetType().Name},{today.GetType().FullName}");
var x = 3.5;
var y = 3.5F;
var z = 10L;
var name = "dupont";
Console.WriteLine($"x : {x.GetType().Name}, y : {y.GetType().Name}, z : {z.GetType().Name}, name : {name.GetType().Name}");
// 在同一行声明多个变量
int a = 1, b, c = 3;
b = a + c;
Console.WriteLine($"a={a}, b={b}, c={c}");

结果:

1
2
3
4
5
6
7
> dotnet run basics-05.cs
Price incl. tax : 120 euros
Type of int i=2 : Int32,System.Int32
Type of var j=3 : Int32,System.Int32
Type of var today : DateTime,System.DateTime
x : Double, y : Single, z : Int64, name : String
a=1, b=4, c=3

说明:

  • 第 2–3 行:两个常量;
  • 第 8 行:一个显式指定类型的数据;
  • 第 9 行:[GetType().Name] 是类型的简短名称,[GetType().FullName] 是 它的完整名称;
  • 第 11 行:一个隐式指定类型的值。因为 3 是 [int] 类型,所以 [j] 将是 [int] 类型;
  • 第 13 行:因为 [DateTime.Now] (当前日期和时间)是 [DateTime] 类型,所以 [today] 将是 [DateTime] 类型;
  • 第 15–18 行:推断出的类型取决于字面量的写法:3.5 是 [double],3.5F 是 [float],而 10L 是 [long];
  • 第 21 行:在同一行中声明三个变量;只有 [a] 和 [c] 被初始化。[b] 在下一行被赋值。

用关键字 [var] 隐式指定类型的变量,之后不能再改变其类型。因此,在第 13 行之后,不能这样写:

today = "today";

因为 [today] 是 [DateTime] 类型。我们将在第 5 章结合 LINQ 看到,可以在表达式中“即时”创建一个类型:这就是匿名类型,程序员没有为它指定名称。如果要把匿名类型的数据赋给变量,声明该变量的唯一方法就是使用关键字 [var]。

3.3.4. 可为 null 的类型

值类型的变量(如 [int])始终包含一个值。有时需要能够表示值 不存在:比如未知的年龄、数据库中的空字段。类型 [int?] (C# 2)就是在类型 [int] 的基础上增加了值 [null],意为“没有值”。这称为 可为 null 的值类型。这一原理适用于所有值类型:[double?]、[bool?]、[DateTime?],等等。

引用类型的变量(如 [string])始终可以取值 [null]:这表示它没有引用任何对象。如果试图使用这类变量的成员(例如它的属性 [Length]),就会导致运行时错误([NullReferenceException]),这是 C# 中最常见的错误之一。从 C# 8 开始,编译器可以帮助预防这类错误:借助 可为 null 的引用类型——在使用 [dotnet new] 命令创建的项目和单文件应用程序中默认启用——

  • 类型 [string] 表示永远不会取值为 [null] 的字符串;
  • 类型 [string?] 表示可以为 [null] 的字符串。

编译器会跟踪变量的可能取值,并在存在使用值 [null] 的风险时发出警告:例如把 [null] 赋给 [string] 变量,或者对未经检测的 [Length] 变量 [string?] 使用它,等等。与 [int?] 不同,[string?] 不会在运行时创建新类型:它是面向编译器的指示。

从最初的示例开始,我们就会遇到这些类型,因为读取键盘输入的一行的方法 [Console.ReadLine()]返回的是 [string?]:当没有内容可读(输入流结束)时,它返回 [null] 。程序 [basics-06.cs] 内容如下:

// 可空类型
// 可空值类型(int?)除整数外还接受 null 值
int? age = null;
Console.WriteLine($"age.HasValue={age.HasValue}");
age = 23;
Console.WriteLine($"age.HasValue={age.HasValue}, age.Value={age.Value}");
// int? -> int:需要显式转换(如果 age 为 null 则抛出异常)
int n = (int)age;
Console.WriteLine($"n={n}");

// 可空引用类型(string?)接受 null 值
string? firstName = null;
Console.WriteLine($"firstName is null : {firstName == null}");
// string 类型(不带 ?)被假定永远不为 null
string name = "dupont";
Console.WriteLine($"name has {name.Length} characters");

// Console.ReadLine 返回 string?:如果输入流已耗尽则为 null
Console.Write("Type a line: ");
string? line = Console.ReadLine();
if (line == null)
{
    Console.WriteLine();
    Console.WriteLine("No line: the input stream is closed");
}
else
{
    // 这里编译器知道 line 不为 null
    Console.WriteLine($"You typed [{line}] : {line.Length} character(s)");
}

通过键盘输入文本时的结果:

1
2
3
4
5
6
7
8
> dotnet run basics-06.cs
age.HasValue=False
age.HasValue=True, age.Value=23
n=23
firstName is null : True
name has 6 characters
Type a line: hello
You typed [hello] : 5 character(s)

用户按下 Ctrl-D(在 Windows 上是 Ctrl-Z 再按 Enter)关闭输入流时的结果:

1
2
3
4
5
6
7
8
> dotnet run basics-06.cs
age.HasValue=False
age.HasValue=True, age.Value=23
n=23
firstName is null : True
name has 6 characters
Type a line: 
No line: the input stream is closed

说明:

  • 第 3 行:[age] 不包含值;
  • 第 4 行:[HasValue] 属性指示变量是否包含值;[Value] 属性提供该值;
  • 第 8 行:[int?] 不能直接赋给 [int] ,因为它可能等于 [null]。需要进行显式转换,如果 [age] 等于 [null],该转换会抛出异常。我们稍后将讨论更安全的 [??] 运算符;
  • 第 12 行:一个可能等于 [null] 的字符串;
  • 第 15 行:一个永远不等于 [null] 的字符串。写 [name = null;] 会触发编译器警告;
  • 第 20 行:[Console.ReadLine()] 的求值结果为 [string?]。将 [line] 声明为 [string] 类型会触发警告;
  • 第 21 行:检查值 [null];
  • 第 29 行:在 [else] 分支中,编译器知道 [line] 不等于 [null]:因此对 [line.Length] 的使用不会发出警告。

3.3.5. 数字与字符串之间的转换

转换
方法
number -> string
[number.ToString()] 或插值字符串 [$"{number}"]
string -> int
[int.Parse(str)] 或 [int.TryParse(str, out int number)]
string -> long
[long.Parse(str)] 或 [long.TryParse(str, out long number)]
string -> double
[double.Parse(str)] 或 [double.TryParse(str, out double number)]
string -> float
[float.Parse(str)] 或 [float.TryParse(str, out float number)]
string -> decimal
[decimal.Parse(str)] 或 [decimal.TryParse(str, out decimal number)]

如果字符串不表示有效的数字,将字符串转换为数字可能会失败。此时 [Parse] 方法会产生一个称为 异常的致命错误。可以用如下 [try / catch] 子句处理这个错误:

1
2
3
4
5
6
7
8
9
try
{
    call the function likely to throw the exception
}
catch (Exception e)
{
    handle the exception e
}
next statement

如果函数没有抛出异常,执行就继续到下一条语句;否则,执行进入 [catch] 子句的主体,然后再到下一条语句。我们将在专门讲解异常处理的一节中再讨论它。

[TryParse] 方法(.NET 2.0)可以避免异常:转换成功时它返回布尔值 [true] ,否则返回 [false] ,并把得到的数字存入使用关键字 [out] 传递的变量中。从 C# 7 起,这个变量可以在调用中直接声明:[int.TryParse(str, out var number)]。[out] 传递方式将在参数传递一节中解释。当预期可能出现错误的输入时(例如来自键盘的输入),[TryParse] 比 [Parse] 更可取:输入错误并不是异常情况。

程序 [basics-07.cs] 演示了数字与字符串之间转换的几种技术。函数 [Display] 在屏幕上显示其参数的值:

// 数字与字符串之间的转换
using System.Globalization;

// 数据
const int i = 10;
const long l = 100000;
const float f = 45.78F;
double d = -14.98;

// 数字 → 字符串
Display(i.ToString());
Display(l.ToString());
Display(f.ToString());
Display(d.ToString());

// 布尔值 → 字符串
const bool b = false;
Display(b.ToString());

// 字符串 → int
int i1 = int.Parse("10");
Display(i1.ToString());
try
{
    i1 = int.Parse("10.67");
    Display(i1.ToString());
}
catch (Exception e)
{
    Display("Error : " + e.Message);
}

// 字符串 → long
long l1 = long.Parse("100");
Display(l1.ToString());
try
{
    l1 = long.Parse("10.675");
    Display(l1.ToString());
}
catch (Exception e)
{
    Display("Error : " + e.Message);
}

// 字符串 → double
double d1 = double.Parse("100,87");
Display(d1.ToString());
try
{
    d1 = double.Parse("abcd");
    Display(d1.ToString());
}
catch (Exception e)
{
    Display("Error : " + e.Message);
}

// 字符串 → float
float f1 = float.Parse("100,87");
Display(f1.ToString());
try
{
    f1 = float.Parse("abcd");
    Display(f1.ToString());
}
catch (Exception e)
{
    Display("Error : " + e.Message);
}

// TryParse:返回 false 而不是抛出异常
if (int.TryParse("123", out int i2))
{
    Display($"TryParse(\"123\") succeeded : {i2}");
}
if (!int.TryParse("12x", out var i3))
{
    Display($"TryParse(\"12x\") failed, i3={i3}");
}

// 区域性:当前区域性的小数分隔符
Display($"Current culture : {CultureInfo.CurrentCulture.Name}");
try
{
    d1 = double.Parse("100.87");
    Display(d1.ToString());
}
catch (FormatException e)
{
    Display("Error : " + e.Message);
}
// 固定区域性使用小数点
double d2 = double.Parse("100.87", CultureInfo.InvariantCulture);
Display(d2.ToString());
Display(d2.ToString(CultureInfo.InvariantCulture));
if (double.TryParse("3.14", CultureInfo.InvariantCulture, out double pi))
{
    Display($"pi={pi}");
}

// 一个显示其参数的局部函数(见后文)
static void Display(string s)
{
    Console.WriteLine($"S={s}");
}

结果:

> dotnet run basics-07.cs
S=10
S=100000
S=45,78
S=-14,98
S=False
S=10
S=Error : The input string '10.67' was not in a correct format.
S=100
S=Error : The input string '10.675' was not in a correct format.
S=100,87
S=Error : The input string 'abcd' was not in a correct format.
S=100,87
S=Error : The input string 'abcd' was not in a correct format.
S=TryParse("123") succeeded : 123
S=TryParse("12x") failed, i3=0
S=Current culture : fr-FR
S=Error : The input string '100.87' was not in a correct format.
S=100,87
S=100.87
S=pi=3,14

说明:

  • 第 2 行:包含 [System.Globalization] 类 [CultureInfo] 的命名空间不在隐式 using 语句之列;
  • 第 5–8 行:要转换的数据;
  • 第 11–14 行:每个对象都有一个方法 [ToString()] ,可将其转换为字符串;
  • 第 25–30 行:处理 [int.Parse] 可能抛出的异常。[e.Message] 是与异常 [e] 相关联的错误消息。.NET 的异常消息是英文的:.NET 10 不提供法语翻译;
  • 第 47 行:字符串使用小数逗号,这符合系统的法语区域设置;
  • 第 73 行:[TryParse] 成功,并把 123 存入在调用中声明的变量 [i2];
  • 第 77 行:[TryParse] 失败并返回 [false];此时变量 [i3] 被赋值为 0;
  • 第 83 行:程序当前的区域设置是 fr-FR;
  • 第 86 行:在法语区域设置中,句点不是小数分隔符:转换失败;
  • 第 94 行:固定区域设置 [CultureInfo.InvariantCulture] 使用小数点,与机器无关。它用于在文件中或程序之间的交换中读写数字,这些场合不得依赖用户的语言;
  • 第 95–96 行:同一个数字按当前区域设置(100,87)和按固定区域设置(100.87)转换成字符串;
  • 第 97 行:[TryParse] 也接受区域设置;
  • 第 103–105 行:一个 本地函数。在使用顶级语句的程序中不能编写方法,因为没有类;取而代之的是编写本地函数,它们可以在定义之前被调用。我们将在“本地函数与元组”一节中讨论它们。

2008 年的课程指出,字符串形式的实数必须使用逗号:这只在法语文化中才成立。读取数字的程序必须始终知道这些数字是按哪种文化写成的。

3.3.6. 数据数组

C# 数组是一个对象,可以把相同类型的数据归入同一个标识符之下。它的声明方式如下:

Type[] array = new Type[n];

[n] 是数组可以包含的数据元素的个数。语法 [array[i]] 表示第 i 个数据元素,其中 i 属于区间 [0, n-1]。任何对数据项 [array[i]] 的引用,只要 i 不在区间 [0, n-1] 内,就会引发异常。数组创建时,每个元素都会被赋予其类型的默认值:数字为 0,布尔值为 [false] ,引用类型为 [null]。数组可以在声明的同时初始化:

int[] integers = new int[] { 0, 10, 20, 30 };

或者更简单地写成:

int[] integers = { 0, 10, 20, 30 };

或者,从 C# 12 起,使用 集合表达式:

int[] integers = [0, 10, 20, 30];

从现在起我们将使用最后这种形式。数组有一个属性 [Length],表示它包含的元素个数。

二维数组的声明方式如下:

Type[,] array = new Type[n, m];

其中 [n] 是行数,[m] 是列数。语法 [array[i, j]] 表示第 i 行的第 j 个元素。二维数组同样可以在声明的同时初始化:

double[,] reals = { { 0.5, 1.7 }, { 8.4, -6 } };

每个维度的元素个数通过方法 [GetLength(i)] 获得,其中 i=0 表示对应第一个索引的维度,i=1 表示对应第二个索引的维度,依此类推。维数通过属性 [Rank] 获得,元素总数则通过属性 [Length] 获得。

数组的数组(也称为 交错数组)的声明方式如下:

Type[][] array = new Type[n][];

上面的声明创建了一个包含 n 个元素的数组。每个元素 [array[i]],都是一个一维数组的引用。这些引用在上面的声明中并未初始化;它们的值为 [null]。与二维数组不同,每一行可以有不同的长度。

C# 8 引入了两种便捷的表示法:

  • 从末尾索引:[array[^1]] 是最后一个元素,[array[^2]] 是 倒数第二个元素,依此类推。[array[^1]] 等价于 [array[array.Length - 1]];
  • 范围:[array[1..3]] 是由索引 1 和 2 的元素组成的新数组。起始索引包含在内,结束索引不包含。边界可以省略:[array[2..]] 表示从索引 2 到末尾,而 [array[..^1]] 表示 从开头到倒数第二个元素(含)。

程序 [basics-08.cs] 综合运用了这几种数组:

// 数组
// 已初始化的一维数组
int[] integers = new int[] { 0, 10, 20, 30 };
for (int i = 0; i < integers.Length; i++)
{
    Console.WriteLine($"integers[{i}]={integers[i]}");
}

// 已初始化的二维数组
double[,] reals = { { 0.5, 1.7 }, { 8.4, -6 } };
for (int i = 0; i < reals.GetLength(0); i++)
{
    for (int j = 0; j < reals.GetLength(1); j++)
    {
        Console.WriteLine($"reals[{i},{j}]={reals[i, j]}");
    }
}
Console.WriteLine($"reals : Rank={reals.Rank}, Length={reals.Length}");

// 数组的数组(交错数组)
string[][] names = new string[3][];
for (int i = 0; i < names.Length; i++)
{
    names[i] = new string[i + 1];
}
// 初始化
for (int i = 0; i < names.Length; i++)
{
    for (int j = 0; j < names[i].Length; j++)
    {
        names[i][j] = "name" + i + j;
    }
}
// 显示
for (int i = 0; i < names.Length; i++)
{
    for (int j = 0; j < names[i].Length; j++)
    {
        Console.WriteLine($"names[{i}][{j}]={names[i][j]}");
    }
}

// 不带初始值创建的数组:元素为该类型的默认值
bool[] flags = new bool[3];
string?[] strings = new string?[2];
Console.WriteLine($"flags[0]={flags[0]}, strings[0] is null : {strings[0] == null}");

// 集合表达式(C# 12)
int[] values = [0, 10, 20, 30, 40];
// string.Join 用分隔符连接数组的元素
Console.WriteLine($"values=[{string.Join(", ", values)}]");
// 从末尾开始的索引(C# 8):^1 表示最后一个元素
Console.WriteLine($"values[^1]={values[^1]}, values[^2]={values[^2]}");
// 范围(C# 8):索引 1 和 2 处的元素(不包含结束边界)
int[] slice = values[1..3];
Console.WriteLine($"values[1..3]=[{string.Join(", ", slice)}]");
Console.WriteLine($"values[2..]=[{string.Join(", ", values[2..])}]");
Console.WriteLine($"values[..^1]=[{string.Join(", ", values[..^1])}]");
// 切片是副本:原数组不会被修改
slice[0] = 100;
Console.WriteLine($"slice[0]={slice[0]}, values[1]={values[1]}");

结果:

> dotnet run basics-08.cs
integers[0]=0
integers[1]=10
integers[2]=20
integers[3]=30
reals[0,0]=0,5
reals[0,1]=1,7
reals[1,0]=8,4
reals[1,1]=-6
reals : Rank=2, Length=4
names[0][0]=name00
names[1][0]=name10
names[1][1]=name11
names[2][0]=name20
names[2][1]=name21
names[2][2]=name22
flags[0]=False, strings[0] is null : True
values=[0, 10, 20, 30, 40]
values[^1]=40, values[^2]=30
values[1..3]=[10, 20]
values[2..]=[20, 30, 40]
values[..^1]=[0, 10, 20, 30]
slice[0]=100, values[1]=10

说明:

  • 第 3 行:初始化一个一维数组;
  • 第 4 行:[for] 循环遍历从 0 到 [integers.Length - 1] 的索引。[for] 循环将在下面介绍;
  • 第 10 行:一个二维数组(2 行 2 列);
  • 第 11–13 行:[GetLength(0)] 是行数,[GetLength(1)] 是 列数;
  • 第 21 行:一个包含 3 个元素的数组 [names] 。每个元素都是对 [string[]] 类型数组的引用,目前为 [null];
  • 第 24 行:数组 [names] 的 3 个元素被初始化。[names[i]] 现在引用一个包含 i+1 个字符串的数组;
  • 第 31 行:[names[i][j]] 是 [names[i]] 所引用的数组的第 j 个元素。由于 [names[i]] 是一个数组,因此 [names[i].Length] 就是它的元素个数。表达式 “name” + i + j 从左到右求值:“name” + i 得到一个字符串,再把 j 连接到它后面;
  • 第 44–45 行:不带初始值创建的数组。类型 [string?[]] 是元素可以为 [null] 的数组;
  • 第 49 行:一个集合表达式;
  • 第 51 行:方法 [string.Join] 使用数组的元素构造一个字符串,元素之间用作为第一个参数传入的字符串分隔;
  • 第 53 行:最后一个元素和倒数第二个元素;
  • 第 55 行:索引 1 和 2 处的元素;
  • 第 60–61 行:范围会创建一个副本:修改 [slice] 并不会修改 [values]。

3.4. C# 基本语句

有:

  • 由计算机执行的基本语句;
  • 控制程序流程的指令。

考察微型计算机及其外围设备的结构,基本指令就清晰了:

Image

  • 1:从键盘读取信息;
  • 2:处理信息;
  • 3:将信息写到屏幕上。

3.4.1. 写到屏幕

有多种向屏幕写入的指令:

1
2
3
Console.Out.WriteLine(expression);
Console.WriteLine(expression);
Console.Error.WriteLine(expression);

其中 [expression] 是任何可以转换为字符串以显示在屏幕上的数据。所有 C# 或 .NET 对象都有一个 [ToString()] 方法,用来完成这种转换。[Write] 方法的作用与 [WriteLine] 相同,只是不换行。

类 [System.Console] 提供对屏幕写入操作的访问([Write]、[WriteLine])。它有两个属性:[Out] 和 [Error],它们是 [TextWriter] 类型的写入流:

  • [Console.WriteLine()] 等价于 [Console.Out.WriteLine()] ,向 [Out] 流写入,该流通常与屏幕关联;
  • [Console.Error.WriteLine()] 向 [Error] 流写入,该流通常也与屏幕关联。

[Out] 流和 [Error] 流可以在运行时重定向到文件,我们稍后就会看到。

3.4.2. 读取通过键盘输入的数据

来自键盘的数据流由 [Console.In] 对象表示,其类型为 [TextReader]。这种类型的对象允许你使用 [ReadLine] 方法读取一行文本:

string? line = Console.In.ReadLine();

[Console] 类提供了一个方法 [ReadLine],它默认与 [In] 流关联。因此,你可以这样写:

string? line = Console.ReadLine();

在键盘上输入的行(不含行结束字符)存储在变量 [line] 中,随后程序可以对其进行处理。正如我们已经看到的,当输入流耗尽时,[ReadLine] 返回 [null] :这就是该变量是 [string?] 类型的原因。[In] 流可以像 [Out] 流和 [Error]流一样重定向到文件。

3.4.3. 输入/输出示例

程序 [basics-09.cs] 演示了键盘/屏幕的输入和输出操作:

// 键盘 / 屏幕输入输出

// 写入 Out 流
object obj = new object();
Console.Out.WriteLine(obj);

// 写入 Error 流
int i = 10;
Console.Error.WriteLine("i=" + i);
Console.Error.WriteLine("i={0}", i);

// 读取键盘输入的一行
Console.Write("Type a line: ");
string? line = Console.ReadLine();
Console.WriteLine($"line={line}");

结果:

1
2
3
4
5
6
> dotnet run basics-09.cs
System.Object
i=10
i=10
Type a line: here I am
line=here I am

说明:

  • 第 4 行:[obj] 是一个对象引用;
  • 第 5 行:[obj] 显示在屏幕上。调用方法 [obj.ToString()] 来获取要显示的文本;
  • 第 9 行:文本被写入 [Error] 流;
  • 第 10 行:同样的操作,但带有格式。第一个参数 "i={0}" 是显示格式;其他参数是要显示的表达式。{n} 元素是位置参数:运行时,{n} 会被替换为第 n 个表达式的值;
  • 第 13–14 行:显示一个不换行的提示,然后读取在键盘上输入的行;
  • 第 15 行:在插值字符串中,像 [null] 这样的值会产生空字符串:不会发出警告。

结果中:

  • 第 2 行:由代码第 5 行生成的输出。方法 *[obj.ToString()] 显示了变量 *[obj]* 的类型名称:*[System.Object]*。类型 [object] 是 .NET 类型 [System.Object]* 的 C# 别名;
  • 第 3–4 行:[Error] 流的两条输入在屏幕上的显示与 [Out] 流的相同。

3.4.4. 输入/输出重定向

Windows、Linux 和 macOS 都识别三个标准设备:

  • 标准输入设备,默认指键盘,编号为 0;
  • 标准输出设备,默认指屏幕,编号为 1;
  • 标准错误设备,默认设置为屏幕,编号为 2。

在 C# 中,写入流 [Console.Out] 写入设备 1,写入流 [Console.Error] 写入设备 2,读取流 [Console.In] 从设备 0 读取数据。

在命令窗口中运行程序时,可以指定被执行程序的 0、1 和 2 号设备分别是什么。在程序参数之后,可以把标准输入和输出设备重定向到文件:

重定向
含义
0<in.txt or <in.txt
标准输入流 0 号被重定向到文件 in.txt。因此在程序中,[Console.In] 流将从文件 in.txt 中读取数据
1>out.txt or >out.txt
将 1 号输出重定向到文件 out.txt。因此在程序中,[Console.Out] 流将把数据写入文件 out.txt
1>>out.txt 或 >>out.txt
与上面相同,但写入的数据会追加到 out.txt 文件的现有内容之后
2>err.txt
将 2 号输出重定向到文件 err.txt。因此在程序中,[Console.Error] 流将把数据写入文件 err.txt
2>>err.txt
与上面相同,但写入的数据会追加到文件 err.txt 的现有内容之后
1>out.txt 2>err.txt
1 号和 2 号设备都被重定向到文件

请注意,要把程序的输入/输出流重定向到文件,无需修改程序:0、1 和 2 号设备的性质由操作系统决定。请看下面的程序 [basics-10.cs]:

1
2
3
4
5
6
7
// 输入输出流的重定向
// 读取 In 流
string? data = Console.In.ReadLine();
// 写入 Out 流
Console.Out.WriteLine("writing to the Out stream : " + data);
// 写入 Error 流
Console.Error.WriteLine("writing to the Error stream : " + data);

2008 年的课程使用 Visual Studio 生成可执行文件,然后在 DOS 窗口中运行它。如今,只需使用命令 [dotnet run] 就够了:重定向会作用于被启动的程序。下面是在 Linux 终端(bash)中的一次会话:

> echo test > in.txt
> cat in.txt
test
> dotnet run basics-10.cs < in.txt > out.txt 2> err.txt
> cat out.txt
writing to the Out stream : test
> cat err.txt
writing to the Error stream : test
> dotnet run basics-10.cs < in.txt 2> err.txt
writing to the Out stream : test
> dotnet run basics-10.cs < in.txt > out.txt
writing to the Error stream : test

说明:

  • 第 1 行:字符串 "test" 被放入文件 in.txt;
  • 第 2 行:显示文件 in.txt 的内容以便验证;
  • 第 4 行:运行程序。[In] 流被重定向到文件 in.txt,[Out] 流被重定向到文件 out.txt,[Error] 流被重定向到文件 err.txt。执行时没有任何输出;
  • 第 5–6 行:文件 out.txt 的内容表明文件 in.txt 已被读取,并且向 [Out] 流的写入已被重定向到 out.txt;
  • 第 7–8 行:对文件 err.txt 做类似的验证;
  • 第 9–10 行:只有 [Error] 流被重定向:屏幕上只显示对 [Out] 流的写入操作;
  • 第 11–12 行:只有 [Out] 流被重定向:屏幕上只显示对 [Error] 流的写入操作。

很明显,[Out] 流和 [Error] 流并不写入同一个设备,因为它们可以被单独重定向。[Error] 流用于输出错误消息:这样你就可以把程序的输出重定向到文件,同时仍能在屏幕上看到它的错误消息。

运算符 >、>> 和 2> 在 Windows 命令提示符([cmd])、PowerShell 和 bash 中的写法相同。运算符 < 可被 [cmd] 和 bash 识别,但 PowerShell 不识别,它将该运算符保留以备将来使用:在 PowerShell 中,要通过管道(|)把文件发送到程序的标准输入。下面的命令仅作说明之用(本课程中并未执行过),它们在 Windows 上完成上面 bash 会话所做的事情:

rem Windows command prompt (cmd)
echo test>in.txt
dotnet run basics-10.cs <in.txt >out.txt 2>err.txt
type out.txt
type err.txt

# PowerShell
"test" > in.txt
Get-Content in.txt | dotnet run basics-10.cs > out.txt 2> err.txt
Get-Content out.txt
Get-Content err.txt

3.4.5. 将表达式的值赋给变量

这里我们关注的是操作 [variable = expression;]。表达式可以是算术、关系、布尔、字符串等类型的表达式。

3.4.5.1. 赋值操作的解释

操作 [variable = expression;] 本身就是一个表达式,其求值过程如下:

  • 对赋值号右侧求值:结果是一个值 V;
  • 将值 V 赋给变量;
  • 值 V 同时也是该赋值的值,此时把赋值视为一个表达式。

因此,操作 [V1 = V2 = expression] 是有效的。由于 = 运算符从右到左求值,我们得到 [V1 = (V2 = expression)]。表达式 [V2 = expression] 被求值,其值为 V。它的求值使 V 被赋给 V2。接着下一个 = 运算符被求值为 [V1 = V]。该表达式的值仍然是 V;它的求值使 V 被赋给 V1。因此,操作 [V1 = V2 = expression] 是一个表达式,其求值:

  • 使 [expression] 的值被赋给变量 V1 和 V2;
  • 返回 [expression] 的值。

这可以推广到形如 [V1 = V2 = ... = Vn = expression] 的表达式。

3.4.5.2. 算术表达式

算术表达式中使用的运算符如下:

运算符
作用
+
加法
-
减法
*
乘法
/
除法:如果至少有一个操作数是实数,则结果为精确的商。如果两个操作数都是整数,则结果为整数商。因此,5/2 等于 2,而 5.0/2 等于 2.5
%
除法的余数(取模),与操作数的性质无关。余数的符号与被除数相同:-5 % 2 等于 -1

有各种数学函数。下面是几个例子:

函数
作用
[double Sqrt(double x)]
平方根
[double Cos(double x)]、[Sin]、[Tan]
余弦、正弦、正切(角度以弧度为单位)
[double Pow(double x, double y)]
x 的 y 次幂
[double Exp(double x)]
指数
[double Log(double x)]、[Log10]、[Log2]
自然对数、常用对数、以 2 为底的对数
[Abs(x)]、[Max(x, y)]、[Min(x, y)]
绝对值、最大值、最小值(适用于所有数值类型)
[Floor(x)]、[Ceiling(x)]、[Truncate(x)]
向下取整、向上取整、截断
[Round(x)]、[Round(x, n)]
四舍五入到最接近的整数、保留 n 位小数
[Math.PI]、[Math.E]
常数 π 和 e

所有这些函数都定义在名为 Math 的 .NET 类中。使用它们时,必须加上定义它们的类的名称作为前缀。因此,应这样写:

double x, y = 4;
x = Math.Sqrt(y);

2008 年的课程在这里给出了 [Math] 类的完整定义:如今,可以在 .NET 的在线文档中找到它,地址为 learn.microsoft.com/dotnet/api/system.math。

程序 [basics-11.cs] 内容如下:

// 算术表达式
// 整数除法和实数除法
Console.WriteLine($"5 / 2 = {5 / 2}, 5.0 / 2 = {5.0 / 2}, 5 / 2.0 = {5 / 2.0}");
// 除法的余数(取模)
Console.WriteLine($"5 % 2 = {5 % 2}, -5 % 2 = {-5 % 2}, 5.5 % 2 = {5.5 % 2}");
// 实数除以零:不报错,结果为无穷大或 NaN(非数字)
double zero = 0;
Console.WriteLine($"1 / 0.0 = {1 / zero}, 0 / 0.0 = {0 / zero}");

// Math 类的一些函数
double x, y = 4;
x = Math.Sqrt(y);
Console.WriteLine($"Math.Sqrt(4) = {x}");
Console.WriteLine($"Math.Pow(2, 10) = {Math.Pow(2, 10)}");
Console.WriteLine($"Math.Abs(-3.5) = {Math.Abs(-3.5)}, Math.Max(3, 7) = {Math.Max(3, 7)}");
Console.WriteLine($"Math.PI = {Math.PI}, Math.Cos(Math.PI) = {Math.Cos(Math.PI)}");
Console.WriteLine($"Math.Exp(1) = {Math.Exp(1)}, Math.Log(Math.E) = {Math.Log(Math.E)}");
Console.WriteLine($"Math.Floor(-2.5) = {Math.Floor(-2.5)}, Math.Ceiling(-2.5) = {Math.Ceiling(-2.5)}, Math.Truncate(-2.5) = {Math.Truncate(-2.5)}");
// Math.Round 默认舍入到最接近的偶数
Console.WriteLine($"Math.Round(2.5) = {Math.Round(2.5)}, Math.Round(3.5) = {Math.Round(3.5)}");
Console.WriteLine($"Math.Round(2.5, MidpointRounding.AwayFromZero) = {Math.Round(2.5, MidpointRounding.AwayFromZero)}");
Console.WriteLine($"Math.Round(2.567, 2) = {Math.Round(2.567, 2)}");

// 优先级:* / % 先于 + -
Console.WriteLine($"2 + 3 * 4 = {2 + 3 * 4}, (2 + 3) * 4 = {(2 + 3) * 4}, 10 - 4 - 3 = {10 - 4 - 3}");

// 赋值是一个表达式:连续赋值
int v1, v2;
v1 = v2 = 7 * 6;
Console.WriteLine($"v1={v1}, v2={v2}");

结果:

> dotnet run basics-11.cs
5 / 2 = 2, 5.0 / 2 = 2,5, 5 / 2.0 = 2,5
5 % 2 = 1, -5 % 2 = -1, 5.5 % 2 = 1,5
1 / 0.0 = ∞, 0 / 0.0 = NaN
Math.Sqrt(4) = 2
Math.Pow(2, 10) = 1024
Math.Abs(-3.5) = 3,5, Math.Max(3, 7) = 7
Math.PI = 3,141592653589793, Math.Cos(Math.PI) = -1
Math.Exp(1) = 2,718281828459045, Math.Log(Math.E) = 1
Math.Floor(-2.5) = -3, Math.Ceiling(-2.5) = -2, Math.Truncate(-2.5) = -2
Math.Round(2.5) = 2, Math.Round(3.5) = 4
Math.Round(2.5, MidpointRounding.AwayFromZero) = 3
Math.Round(2.567, 2) = 2,57
2 + 3 * 4 = 14, (2 + 3) * 4 = 20, 10 - 4 - 3 = 3
v1=42, v2=42

说明:

  • 第 3 行:两个整数相除是整数除法;
  • 第 5 行:余数的符号与被除数相同;% 运算符也适用于实数;
  • 第 8 行:实数除以零不会导致错误;它返回无穷大(显示为 ∞),而 0/0 则返回特殊值 NaN(“Not a Number”,即非数字)。但是,整数 除以零会抛出 [DivideByZeroException] 异常;
  • 第 11–12 行:上面的例子;
  • 第 18 行:[Floor] 向下取整,[Ceiling] 向上取整,[Truncate] 向零取整;
  • 第 20 行:默认情况下,[Math.Round] 会把恰好位于中间的值舍入到最接近的 偶数(“银行家”舍入):2.5 变成 2,3.5 变成 4;
  • 第 21 行:若要使用学校里教的舍入方法(2.5 变成 3),请指定舍入模式;
  • 第 25 行:运算符优先级,如下所示;
  • 第 29 行:多重赋值。

3.4.5.3. 算术表达式求值时的运算顺序

算术表达式求值时的运算顺序如下(优先级从高到低):

[functions], [( )], [*, /, %], [+, -]

同一个块 [ ] 内的运算符具有相同的优先级。优先级相同时,从左到右求值:10 - 4 - 3 的值为 (10 - 4) - 3 = 3。

3.4.5.4. 关系表达式

运算符有:<、<=、==、!=、>、>=。它们的优先级为:

  • >, >=, <, <=;
  • ==, !=.

如果表达式为假,关系表达式的结果为布尔值 [false] ,否则为 [true] 。

1
2
3
bool end;
int x = 5;
end = x > 4;

比较两个字符

设 C1 和 C2 是两个字符。可以使用运算符 <、<=、==、!=、>、>= 来比较它们。此时比较的是它们的 Unicode 码,也就是数字。按照 Unicode 的顺序,有以下关系:

space < .. < '0' < '1' < .. < '9' < .. < 'A' < 'B' < .. < 'Z' < .. < 'a' < 'b' < .. < 'z' < .. < 'é'

比较两个字符串

逐个字符地比较它们。在两个字符之间遇到的第一个不相等之处,决定字符串之间同方向的不等关系。考虑比较字符串 "Cart" 和 "Cat":

1
2
3
4
5
"Cart"    "Cat"
---------------------
'C'   =   'C'
'a'   =   'a'
'r'   <   't'

最后这个不等式使我们可以得出 "Cart" < "Cat" 的结论。再考虑比较字符串 "Cat" 和 "Catkin"。它们在字符串 "Cat" 用尽之前都是相等的。这种情况下,先用尽的字符串被认定为“更小”。因此我们有关系 "Cat" < "Catkin"。

比较两个字符串的函数

你可以使用关系运算符 == 和 != 来测试两个字符串是否相等,也可以使用 [Equals] 方法,它属于 [System.String] 类。对于关系 <、<=、> 和 >=,这些运算符不适用于字符串:必须使用 [CompareTo] 方法(属于 [System.String] 类)或静态方法 [string.Compare]。它们返回一个整数:

  • 如果两个字符串相等,则为零;
  • 如果字符串 1 大于字符串 2,则为正数;
  • 如果字符串 1 小于字符串 2,则为负数。

这里有一个微妙之处:[CompareTo] 和 [string.Compare] 并不是简单地比较 Unicode 码。它们遵循当前 区域文化的排序规则,就像查词典一样:在法语中,“élan”排在“face”之前,尽管‘é’的码(233)大于‘f’的码(102)。要选择比较模式,[string.Compare] 和 [Equals] 接受一个 [StringComparison] 类型的参数:

  • [StringComparison.Ordinal]:逐个字符地比较 Unicode 码。这是最快的比较方式,应用于标识符、关键字和文件名;
  • [StringComparison.OrdinalIgnoreCase]:与上面相同,但忽略大小写;
  • [StringComparison.CurrentCulture] ([CompareTo] 的默认值):对面向用户的文本遵循标准的区域文化排序约定。

== 运算符和不带参数的 [Equals] 方法执行序数比较。

程序 [basics-12.cs] 内容如下:

// 关系表达式和字符串比较
int x = 5;
bool end = x > 4;
Console.WriteLine($"x > 4 : {end}, x == 5 : {x == 5}, x != 5 : {x != 5}");

// 字符比较:比较它们的 Unicode 码
Console.WriteLine($"'a' < 'b' : {'a' < 'b'}, 'Z' < 'a' : {'Z' < 'a'}, '9' < 'A' : {'9' < 'A'}");
Console.WriteLine($"codes : 'A'={(int)'A'}, 'a'={(int)'a'}, 'é'={(int)'é'}");

// 字符串比较
string string1 = "cat", string2 = "dog";
int n = string1.CompareTo(string2);
bool equal = string1.Equals(string2);
Console.WriteLine($"n={n}, equal={equal}");
Console.WriteLine($"\"dog\"==string1 : {"dog" == string1}, \"dog\"!=string2 : {"dog" != string2}");
Console.WriteLine($"\"Cat\".CompareTo(\"Catkin\") : {"Cat".CompareTo("Catkin")}");

// CompareTo 和 string.Compare 遵循当前区域性(fr-FR)的规则
Console.WriteLine($"\"élan\".CompareTo(\"face\") : {"élan".CompareTo("face")}");
Console.WriteLine($"string.Compare(\"Cat\", \"cat\") : {string.Compare("Cat", "cat")}");
// StringComparison.Ordinal:逐字符比较 Unicode 码
Console.WriteLine($"Ordinal(\"élan\", \"face\") : {string.Compare("élan", "face", StringComparison.Ordinal)}");
Console.WriteLine($"Ordinal(\"Cat\", \"cat\") : {string.Compare("Cat", "cat", StringComparison.Ordinal)}");
// 忽略大小写
Console.WriteLine($"OrdinalIgnoreCase(\"Cat\", \"cat\") : {string.Compare("Cat", "cat", StringComparison.OrdinalIgnoreCase)}");
Console.WriteLine($"\"Cat\".Equals(\"cat\") : {"Cat".Equals("cat")}");
Console.WriteLine($"\"Cat\".Equals(\"cat\", OrdinalIgnoreCase) : {"Cat".Equals("cat", StringComparison.OrdinalIgnoreCase)}");

结果:

> dotnet run basics-12.cs
x > 4 : True, x == 5 : True, x != 5 : False
'a' < 'b' : True, 'Z' < 'a' : True, '9' < 'A' : True
codes : 'A'=65, 'a'=97, 'é'=233
n=-1, equal=False
"dog"==string1 : False, "dog"!=string2 : False
"Cat".CompareTo("Catkin") : -1
"élan".CompareTo("face") : -1
string.Compare("Cat", "cat") : 1
Ordinal("élan", "face") : 131
Ordinal("Cat", "cat") : -32
OrdinalIgnoreCase("Cat", "cat") : 0
"Cat".Equals("cat") : False
"Cat".Equals("cat", OrdinalIgnoreCase) : True

说明:

  • 第 3 行:一个关系表达式;
  • 第 7 行:字符比较;
  • 第 8 行:字符的 [(int)] 转换返回它的 Unicode 码;
  • 第 12 行:变量 [n] 被赋予一个负整数,因为 "cat" < "dog";
  • 第 13 行:如果两个字符串相等,变量 [equal] 的值为 [true] ,否则为 [false] ;
  • 第 15 行:运算符 == 和 != 用于检查两个字符串是否相等。在字符串插值中,\" 表示一个引号;
  • 第 16 行:先用尽的字符串是较短的那个;
  • 第 19–20 行:基于法语约定的比较:“élan”排在“face”之前,而“Cat”排在“cat”之后(字母数量相同时,小写字母排在大写字母之前);
  • 第 22–23 行:序数比较:这里的结果是第一个不同字符的码之差:233 – 102 = 131 和 67 – 99 = –32;
  • 第 25–27 行:忽略大小写时,“Cat”和“cat”相等。

3.4.5.5. 布尔表达式

可以使用的运算符有与(&&)、或(||)和非(!)。布尔表达式的结果是布尔值。运算符优先级:

  • ! ;
  • && ;
  • ||.
double x = 3.5;
bool valid = x > 2 && x < 4;

关系运算符的优先级高于 && 和 || 运算符。这两个运算符只在必要时才对右侧操作数求值:在 [a && b] 中,如果 a 为假,则不对 b 求值;在 [a || b] 中,如果 a 为真,则不对 b 求值。这称为“短路求值”。因此,可以放心地写 [text != null && text.Length > 0]。

3.4.5.6. 按位运算

设 [i] 和 [j] 是两个整数:

运算
作用
i << n
将 i 向左移动 n 位。移入的位为零
i >> n
将 i 向右移动 n 位。如果 i 是有符号整数([sbyte]、[short]、[int]、[long]),则保留符号位
i >>> n
无符号右移(C# 11):移入的位为零,即使 i 是有符号数
i & j
对 i 和 j 执行按位逻辑与
i | j
对 i 和 j 执行按位逻辑或
~i
对 i 取反码(按位取反)
i ^ j
对 i 和 j 逐位执行异或运算

程序 [basics-13.cs] 内容如下:

// 位操作
short i = 100, j = -13;
ushort k = 0xF123;
Console.WriteLine("i=0x{0:x4}, j=0x{1:x4}, k=0x{2:x4}", i, j, k);
Console.WriteLine("i<<4=0x{0:x4}, i>>4=0x{1:x4}, k>>4=0x{2:x4}", i << 4, i >> 4, k >> 4);
Console.WriteLine("i&j=0x{0:x4}, i|j=0x{1:x4}, i^j=0x{2:x4}, ~i=0x{3:x4}",
    (short)(i & j), (short)(i | j), (short)(i ^ j), (short)~i);
Console.WriteLine("j<<2=0x{0:x4}, j>>2=0x{1:x4}", (short)(j << 2), (short)(j >> 2));
// 相同的值的二进制形式(B 格式,.NET 8)
Console.WriteLine($"i={i:B16}, j={j:B16}, i&j={(short)(i & j):B16}");
// 无符号右移 >>>(C# 11):移入的位为 0
int m = -16;
Console.WriteLine($"m={m:B32}, m>>2={m >> 2:B32}, m>>>2={m >>> 2:B32}");

结果:

1
2
3
4
5
6
7
> dotnet run basics-13.cs
i=0x0064, j=0xfff3, k=0xf123
i<<4=0x0640, i>>4=0x0006, k>>4=0x0f12
i&j=0x0060, i|j=0xfff7, i^j=0xff97, ~i=0xff9b
j<<2=0xffcc, j>>2=0xfffc
i=0000000001100100, j=1111111111110011, i&j=0000000001100000
m=11111111111111111111111111110000, m>>2=11111111111111111111111111111100, m>>>2=00111111111111111111111111111100

说明:

  • 第 4 行:格式 {0:x4} 以十六进制(x)、4 位数字(4)显示 0 号参数;
  • 第 7 行:对 [short] 的位进行运算得到的是 [int];需要将其转换回 [short] 才能显示 4 位十六进制数字。如果不转换,~i 会显示为 8 位数字(ffffff9b);
  • 第 10 行:格式 B16 显示 16 位二进制整数。我们逐位检验 i 和 j 的逻辑与;
  • 第 13 行:[>>] 移位保留了 m 的符号位(m 为负数);[>>>] 移位则用零填充。

3.4.5.7. 运算符的组合

[a = a + b] 可以写成 [a += b];[a = a - b] 可以写成 [a -= b]。运算符 /、%、*、<<、>>、>>>、&、|、^ 同样如此。因此,[a = a / 2;] 可以写成 [a /= 2;]。

3.4.5.8. 自增和自减运算符

记法 [variable++] 表示 [variable = variable + 1] 或 [variable += 1]。记法 [variable--] 表示 [variable = variable - 1] 或 [variable -= 1]。在表达式中使用时,这些运算符有两种形式:

  • [i++] (后缀):表达式的值是自增 之前 i 的值;
  • [++i] (前缀):表达式的值是自增 之后 i 的值。

3.4.5.9. 三元运算符 ?:

表达式 [expr_cond ? expr1 : expr2] 的求值过程如下:

  • 先对表达式 [expr_cond] 求值。它是一个布尔表达式;
  • 如果为真,则表达式的值就是 [expr1] 的值,且不对 [expr2] 求值;
  • 如果为假,则情况相反:表达式的值是 [expr2] 的值,且不对 [expr1] 求值。

如果 j > 4,操作 [i = (j > 4 ? j + 1 : j - 1);] 会把 j+1 赋给变量 i,否则赋 j-1。这等同于写成 [if (j > 4) i = j + 1; else i = j - 1;],但更简洁。

3.4.5.10. 运算符 ??、??= 和 ?.

这些运算符使处理值 [null] 变得更容易:

  • [a ?? b] (C# 2)在 a 不等于 [null] 时取值为 a,否则取值为 b。它用于提供备用值:[string name = Console.ReadLine() ?? "";]。结果不再可为 null;
  • [a ??= b] (C# 8)仅当 a 等于 [null] 时才把 b 赋给 a;
  • [a?.Member] (C# 6)在 a 为 [null] 时为 [null],否则为 [a.Member]。因此,当 [text?.Length] 中的 [text] 等于 [null] 时不会导致错误;结果的类型为 [int?]。

程序 [basics-14.cs] 综合运用了这些不同的运算符:

// 其他运算符
// 布尔表达式
double x = 3.5;
bool valid = x > 2 && x < 4;
Console.WriteLine($"valid={valid}, !valid={!valid}, valid || x > 10 : {valid || x > 10}");

// 复合运算符
int a = 10;
a += 5;
Console.Write($"a += 5 : {a}");
a *= 2;
Console.Write($", a *= 2 : {a}");
a /= 4;
Console.Write($", a /= 4 : {a}");
a %= 4;
Console.Write($", a %= 4 : {a}");
a <<= 2;
Console.WriteLine($", a <<= 2 : {a}");

// 自增和自减
int i = 5;
int j = i++;    // j 接收 i 的旧值,然后 i 自增
int k = ++i;    // i 先自增,然后 k 接收 i 的新值
Console.WriteLine($"i={i}, j={j}, k={k}");
i--;
Console.WriteLine($"i={i}");

// 三元运算符
int n = 5;
int p = n > 4 ? n + 1 : n - 1;
string parity = n % 2 == 0 ? "even" : "odd";
Console.WriteLine($"p={p}, {n} is {parity}");

// ?? 运算符:左操作数为 null 时的替代值
string? input = null;
string name = input ?? "unknown";
int? age = null;
int displayedAge = age ?? -1;
Console.WriteLine($"name={name}, displayedAge={displayedAge}");
// ??= 运算符:仅当变量为 null 时才赋值
string? title = null;
title ??= "Untitled";
title ??= "Other title";
Console.WriteLine($"title={title}");
// ?. 运算符:仅当对象不为 null 时才访问成员
string? text = null;
int? length = text?.Length;
Console.WriteLine($"length={length?.ToString() ?? "null"}");
text = "hello";
Console.WriteLine($"length={text?.Length}");

结果:

> dotnet run basics-14.cs
valid=True, !valid=False, valid || x > 10 : True
a += 5 : 15, a *= 2 : 30, a /= 4 : 7, a %= 4 : 3, a <<= 2 : 12
i=7, j=5, k=7
i=6
p=6, 5 is odd
name=unknown, displayedAge=-1
title=Untitled
length=null
length=5

说明:

  • 第 4 行:一个布尔表达式;
  • 第 9–17 行:组合运算符:10+5=15,15*2=30,30/4=7(整数除法),7%4=3,3<<2=12;
  • 第 22 行:[j] 被赋值为 5,然后 [i] 被设为 6;
  • 第 23 行:[i] 变为 7,然后 [k] 得到 7;
  • 第 30–31 行:两个三元运算符;
  • 第 36 行:[input] 等于 [null]:[name] 得到 "unknown"。[name] 的类型是 [string],而不是 [string?];
  • 第 38 行:?? 运算符使你可以把 [int?] 转换为 [int] ,而没有抛出异常的风险;
  • 第 42–43 行:第一次赋值发生,是因为 [title] 等于 [null];第二次赋值不会发生;
  • 第 47 行:[text] 等于 [null],因此 [length] 也是如此;
  • 第 48 行:这些运算符被组合使用:如果 [length] 等于 [null],则显示字符串 "null"。

3.4.5.11. 运算符的一般优先级

下表按优先级从高到低列出了运算符:

运算符
结合性
[x.y] [x?.y] [f(x)] [a[i]] [x++] [x--] [new] [typeof] [checked] [nameof]
lr
[+x] [-x] [!x] [~x] [++x] [--x] [^x] [(T)x] (类型转换)
rl
[x..y] (范围)
lr
[switch] (switch 表达式)
lr
[*] [/] [%]
lr
[+] [-]
lr
[<<] [>>] [>>>]
lr
[<] [<=] [>] [>=] [is] [as]
lr
[==] [!=]
lr
[&]
lr
[^]
lr
[|]
lr
[&&]
lr
[||]
lr
[??]
rl
[? :] (三元)
rl
[=] [+=] [-=] [??=] 等等,[=>]
rl

lr 表示当运算符优先级相同时,按从左到右的顺序结合:当表达式包含优先级相同的运算符时,最左边的运算符先求值。rl 表示从右到左结合。如有疑问,请毫不犹豫地使用括号:括号也会使表达式更易读。

3.4.5.12. 类型转换

在表达式中,可以临时改变一个值的表示形式。这称为“类型转换”(type casting)。在表达式中改变值的类型的语法如下:

(type) value

此时该值采用指定的类型。这会导致值的表示形式发生变化。我们区分:

  • 隐式转换,当不会造成任何信息丢失时由编译器自动执行:从 [int] 到 [long],从 [int] 到 [double],从 [char] 到 [int],等等。从 [long] 到 [double] 的转换也是隐式的,尽管超过 2⁵³ 时可能会损失精度;
  • 显式转换,可能造成信息丢失,必须由程序员使用 (type) 记法显式提出:从 [double] 到 [int] (小数部分丢失),从 [long] 到 [int] (最高有效位丢失),等等。

默认情况下,整数计算或整数转换中的溢出不会被报告:结果只是错误的。而关键字 [checked],会使溢出触发 [OverflowException] 异常。它可以作用于一个表达式 [checked(expression)],或者一个指令块 [checked { ... }]。

程序 [basics-15.cs] 内容如下:

// 类型转换
int i = 3, j = 4;
float f1 = i / j;
float f2 = (float)i / j;
Console.WriteLine($"f1={f1}, f2={f2}");

// 隐式转换:不丢失信息
long l = i;
double d = l;
Console.WriteLine($"l={l}, d={d}");

// 显式转换(强制转换):可能丢失信息
double real = 3.99;
int truncated = (int)real;
int rounded = (int)Math.Round(real);
Console.WriteLine($"(int)3.99={truncated}, (int)Math.Round(3.99)={rounded}");
long large = 3_000_000_000;
int overflowed = (int)large;
Console.WriteLine($"(int)3000000000={overflowed}");

// 字符和整数
char c = (char)65;
int code = 'é';
Console.WriteLine($"(char)65={c}, code of 'é'={code}");

// 溢出:默认情况下静默发生
int max = int.MaxValue;
int next = max + 1;
Console.WriteLine($"int.MaxValue + 1 = {next}");
// checked:溢出会引发异常
try
{
    int verified = checked(max + 1);
    Console.WriteLine($"verified={verified}");
}
catch (OverflowException e)
{
    Console.WriteLine($"checked(max + 1) : {e.GetType().Name} - {e.Message}");
}
try
{
    checked
    {
        int conversion = (int)large;
        Console.WriteLine($"conversion={conversion}");
    }
}
catch (OverflowException e)
{
    Console.WriteLine($"checked((int)large) : {e.GetType().Name} - {e.Message}");
}

结果:

1
2
3
4
5
6
7
8
9
> dotnet run basics-15.cs
f1=0, f2=0,75
l=3, d=3
(int)3.99=3, (int)Math.Round(3.99)=4
(int)3000000000=-1294967296
(char)65=A, code of 'é'=233
int.MaxValue + 1 = -2147483648
checked(max + 1) : OverflowException - Arithmetic operation resulted in an overflow.
checked((int)large) : OverflowException - Arithmetic operation resulted in an overflow.

说明:

  • 第 3 行:[f1] 的值为 0。除法 3/4 是整数除法,因为两个操作数都是 [int] 类型;其结果 0 随后被转换为 [float];
  • 第 4 行:[(float)i] 是 [i] 转换为 [float] 后的值。现在我们得到的是 [float] 类型的实数与 [int] 类型的整数之间的除法:[j] 的值也被转换为 [float],然后两个实数相除。[f2] 的值为 0.75。在运算 [(float)i] 中,[i] 是一个被编码为 精确的 4 字节数的值,而 [(float)i] 是同一个值被编码为近似的 4 字节实数。这种转码只在计算期间发生:变量 [i] 始终保持其类型 [int];
  • 第 8–9 行:隐式转换;
  • 第 14 行:把浮点数转换为整数会截去小数部分;
  • 第 15 行:要进行四舍五入,我们使用 [Math.Round],它得到一个 [double],然后再进行转换;
  • 第 18 行:30 亿放不进 [int]:只保留最低的 32 位,结果不再有意义;
  • 第 22–23 行:字符与 Unicode 码之间的转换;第二个是隐式的;
  • 第 28 行:容量溢出没有被察觉:得到的是最小的可能的 [int] 值;
  • 第 33 行:使用 [checked] 时,溢出会触发 [OverflowException] 异常;
  • 第 42–45 行:一个 [checked] 块:将 [large] 转换为 [int] 同样会抛出异常。

如果溢出发生在仅由常量构成的表达式中,例如 [int.MaxValue + 1],编译器会检测到并拒绝该程序。

3.5. 程序流程控制语句

3.5.1. 停止

[Exit] 方法(属于 [Environment] 类)可以停止程序的执行:

Environment.Exit(int status);

[Exit] 会终止当前进程,并将控制权交还给调用进程,通常是命令解释器。[status] 的值,即返回码,可供命令解释器使用。按照约定,0 表示程序成功完成,其他任何值都表示出错。在 Windows 上,返回码可在命令提示符的 [%ERRORLEVEL%] 变量中以及 PowerShell 的 [$LASTEXITCODE] 变量中获得;在 Linux 和 macOS 上,则可在 shell 的 [$?] 变量中获得。因此:

Environment.Exit(0);

将以返回码 0 终止程序。在顶级语句中,[return] 语句同样会终止程序(返回码为 0),除非它位于某个函数内部。

程序 [basics-16.cs] 通过参数接收其返回码:

// 以退出码终止程序
Console.WriteLine("Start of the program");
// 退出码作为参数传递(参见程序参数一节)
if (args.Length == 0 || !int.TryParse(args[0], out int code))
{
    Console.Error.WriteLine("Syntax : dotnet run basics-16.cs -- exit_code");
    Environment.Exit(1);
    return;
}
Console.WriteLine($"Stopping with exit code {code}");
Environment.Exit(code);
Console.WriteLine("This line is never executed");

在 bash 终端中的结果:

> dotnet run basics-16.cs -- 3
Start of the program
Stopping with exit code 3
> echo $?
3
> dotnet run basics-16.cs
Start of the program
Syntax : dotnet run basics-16.cs -- exit_code
> echo $?
1

说明:

  • 第 4 行:我们检查是否传入了参数,以及该参数是否为整数。程序的参数将在后面介绍;
  • 第 7 行:如果不是,程序以返回码 1 终止;
  • 第 8 行:这条指令永远不会被执行,但编译器并不知道 [Environment.Exit] 永远不会返回控制权。如果没有它,编译器会认为下一行可能在 [code] 变量未初始化的情况下被执行,从而拒绝该程序;
  • 第 11 行:以作为参数传入的返回码终止。下一行不会被执行;
  • 第 4–9 行:命令 [echo $?] 显示最后一个执行的程序的返回码:先是 3,然后是 1。

3.5.2. 简单判断结构

1
2
3
4
5
6
7
8
if (condition)
{
    actions_condition_true;
}
else
{
    actions_condition_false;
}

注意:

  • 条件用圆括号括起来;
  • 每个动作以分号结尾;
  • 花括号后面不跟分号;
  • 只有当动作多于一个时才必须使用花括号;不过,即使只有一个动作,也常常加上花括号,以提高可读性,并避免在添加动作时出错;
  • [else] 子句可以省略;
  • 没有 [then] 关键字。

该结构在算法中的等价形式是 if...then...else 结构:

1
2
3
4
if condition
    then actions_condition_true
    else actions_condition_false
endif

示例:

if (x > 0) { nx = nx + 1; sx = sx + x; } else dx = dx - x;

选择结构可以嵌套。这有时会导致程序 [basics-17.cs] 所展示的问题:

// 简单选择结构 if
int n = 5;
// else 总是属于最近的 if
if (n > 1)
    if (n > 6)
        Console.WriteLine(">6");
    else
        Console.WriteLine("<=6");

// 使用花括号时,else 属于第一个 if
int n2 = 0;
if (n2 > 1)
{
    if (n2 > 6)
    {
        Console.WriteLine(">6");
    }
}
else
{
    Console.WriteLine("<=1");
}

// 一系列选择:else if
int grade = 13;
string honours;
if (grade < 10)
{
    honours = "failed";
}
else if (grade < 12)
{
    honours = "pass";
}
else if (grade < 14)
{
    honours = "fairly good";
}
else
{
    honours = "good";
}
Console.WriteLine($"grade={grade}, honours={honours}");

结果:

1
2
3
4
> dotnet run basics-17.cs
<=6
<=1
grade=13, honours=fairly good

说明:

  • 第 4–8 行:第 7 行的 [else] 属于哪个 [if] ?规则是:[else] 总是属于最近的 [if],即 [if (n > 6)](第 5 行)。代码缩进对编译器没有影响,这里的缩进是为了说明这一点而选定的;
  • 第 12–21 行:这里我们想把 [else] 放在 [if (n2 > 1)] 旁边,而不是把 [else] 放在 [if (n2 > 6)] 旁边。由于上述规则,我们必须用花括号把 [if (n2 > 1) { ... }] 括起来;
  • 第 27–41 行:一系列互斥的选择通过连续的 [else if] 来编写。条件按顺序测试;第一个为真的条件决定要执行的动作。

3.5.3. 分支结构

3.5.3.1. switch 语句

语法如下:

switch (expression)
{
    case v1:
        actions1;
        break;
    case v2:
        actions2;
        break;
    ...
    default:
        actions_otherwise;
        break;
}

注意:

  • [switch] 中控制表达式的值可以是整数、字符、字符串、枚举值等;
  • 控制表达式用圆括号括起来;
  • [default] 子句可以没有;
  • 值 vi 是表达式的可能取值。如果表达式的值为 vi,则执行子句 [case vi] 之后的动作;
  • 语句 [break] 用于退出分支结构;
  • 与某个值 vi 关联的每个语句块都必须以跳转语句结束([break]、[return]、[throw] 等);否则编译器会报错。不过,多个 [case] 子句可以紧挨着出现而中间没有任何指令:在这种情况下,它们共享相同的动作。

算法中的示例:

depending on the value of choice
    case 0
        end of the module
    case 1
        execute module M1
    case 2
        execute module M2
    otherwise
        error <- true
endcase

3.5.3.2. switch 表达式

很多时候,分支结构仅用于选择一个值。C# 8 为此引入了 switch 表达式:

1
2
3
4
5
6
7
result = expression switch
{
    pattern1 => value1,
    pattern2 => value2,
    ...
    _ => value_otherwise
};

表达式依次与各个模式进行比较;与第一个匹配的模式相关联的值就是结果。模式 \_ 匹配所有值:它充当通配符。模式可以是:

  • 常量:[0]、["saturday"];
  • 关系模式(C# 9):[< 0]、[>= 18];
  • 使用 [and]、[or] 和 [not] 组合的模式(C# 9):[> 0 and <= 10]、["saturday" or "sunday"]。

这些相同的模式也可用于运算符 [is]:[day is "saturday" or "sunday"] 当 [day] 为 "saturday" 或 "sunday" 时为真。在后续章节中,我们还会看到它们的其他形式。

程序 [basics-18.cs] 如下:

// 分支结构:switch 语句和 switch 表达式
int choice = 2;
bool error = false;
switch (choice)
{
    case 0:
        return;
    case 1:
        M1();
        break;
    case 2:
        M2();
        break;
    default:
        error = true;
        break;
}
Console.WriteLine($"error={error}");

// 同一分支对应多个值,string 类型的表达式
string day = "saturday";
switch (day)
{
    case "saturday":
    case "sunday":
        Console.WriteLine($"{day} : weekend");
        break;
    default:
        Console.WriteLine($"{day} : weekday");
        break;
}

// switch 表达式(C# 8):它返回一个值
string dayType = day switch
{
    "saturday" or "sunday" => "weekend",
    "monday" or "tuesday" or "wednesday" or "thursday" or "friday" => "weekday",
    _ => "unknown day"
};
Console.WriteLine($"{day} : {dayType}");

// 关系模式(<、<=、>、>=)和逻辑模式(and、or、not)(C# 9)
Console.WriteLine($"-5 : {Classify(-5)}");
Console.WriteLine($"0 : {Classify(0)}");
Console.WriteLine($"7 : {Classify(7)}");
Console.WriteLine($"42 : {Classify(42)}");
Console.WriteLine($"1000 : {Classify(1000)}");
// not 模式
bool workingDay = day is not ("saturday" or "sunday");
Console.WriteLine($"{day} working day : {workingDay}");

// 上面使用的局部函数
static void M1()
{
    Console.WriteLine("M1");
}

static void M2()
{
    Console.WriteLine("M2");
}

static string Classify(int n) => n switch
{
    < 0 => "negative",
    0 => "zero",
    > 0 and <= 10 => "small",
    > 10 and < 100 => "medium",
    _ => "large"
};

结果:

> dotnet run basics-18.cs
M2
error=False
saturday : weekend
saturday : weekend
-5 : negative
0 : zero
7 : small
42 : medium
1000 : large
saturday working day : False

说明:

  • 第 4–15 行:上述算法的 C# 实现;
  • 第 7 行:在顶级语句中,[return] 会终止程序;
  • 第 24–25 行:两个值对应相同的动作;
  • 第 34–38 行:针对字符串的 switch 表达式。各模式通过 [or] 组合;
  • 第 49 行:与运算符 [not] 结合 [is] 使用的模式;
  • 第 53–60 行:两个局部函数;
  • 第 63–69 行:一个函数体为 switch 表达式的局部函数。=> 符号取代了用花括号括起来的函数体以及 [return] 语句;这被称为表达式体。关系模式对整数 [n] 进行分类。

3.5.4. 循环结构

3.5.4.1. 已知重复次数

for 结构

语法如下:

1
2
3
4
for (i = id; i <= if; i = i + ip)
{
    actions;
}

注意:

  • [for] 的三个参数用圆括号括起来,并以分号分隔;
  • [for] 中的每个动作都以分号结束;
  • 只有当动作多于一个时才必须使用花括号;
  • 花括号后面不跟分号。

其算法中的等价形式是 for 结构:

1
2
3
for i varying from id to if in steps of ip
    actions
endfor

它可以转换为 while 结构:

1
2
3
4
5
i <- id
while i <= if
    actions
    i <- i + ip
endwhile

foreach 结构

语法如下:

1
2
3
4
foreach (Type variable in collection)
{
    instructions;
}

注意:

  • [collection] 是对象的可枚举集合。我们已经熟悉的可枚举集合是数组;我们将在第 5 章中看到其他集合([List<T>]、[Dictionary<K, V>] 等);
  • [Type] 是集合中对象的类型。对于数组,它就是数组元素的类型。也可以改写为 [var];
  • [variable] 是循环的局部变量,它将依次取集合中的所有值。在循环内部不能修改它。

3.5.4.2. 重复次数未知

while 循环

1
2
3
4
while (condition)
{
    actions;
}

只要条件为真,循环就会继续。循环可能一次也不执行。注意事项与 [for] 相同。对应的算法结构是 while 结构:

1
2
3
while condition
    actions
endwhile

“do while” 循环

语法如下:

1
2
3
4
do
{
    instructions;
} while (condition);

循环一直继续,直到条件变为假。这里,循环至少执行一次。对应的算法结构是“repeat … until”结构:

1
2
3
repeat
    actions
until not condition

通用循环结构(for)

语法如下:

1
2
3
4
for (start_instructions; condition; end_of_loop_instructions)
{
    instructions;
}

只要条件为真,循环就会继续(在每次迭代之前求值)。[start_instructions] 语句在首次进入循环之前执行。[end_of_loop_instructions] 语句在循环的每次迭代之后执行。[start_instructions] 和 [end_of_loop_instructions] 中的各条指令以逗号分隔。对应的算法结构如下:

1
2
3
4
5
start_instructions
while condition
    actions
    end_of_loop_instructions
endwhile

3.5.4.3. 循环控制语句

指令
作用
[break]
退出 [for]、[foreach]、[while]、[do ... while] 循环
[continue]
进入 [for]、[foreach]、[while]、[do ... while] 循环的下一次迭代

3.5.4.4. 示例

程序 [basics-19.cs] 如下:

// 循环结构
// 计算前 10 个整数之和的四种方式
int i, sum, n = 10;
for (i = 1, sum = 0; i <= n; i = i + 1)
{
    sum = sum + i;
}
Console.WriteLine($"for (1) : sum={sum}");

for (i = 1, sum = 0; i <= n; sum = sum + i, i = i + 1)
{
}
Console.WriteLine($"for (2) : sum={sum}");

i = 1;
sum = 0;
while (i <= n)
{
    sum += i;
    i++;
}
Console.WriteLine($"while : sum={sum}");

i = 1;
sum = 0;
do
{
    sum += i++;
} while (i <= n);
Console.WriteLine($"do while : sum={sum}");

// 循环变量可以在 for 中声明:它只在循环内部存在
int product = 1;
for (int k = 1; k <= 5; k++)
{
    product *= k;
}
Console.WriteLine($"5! = {product}");

// foreach:遍历集合的所有元素
string[] friends = ["paul", "hélène", "jacques", "sylvie"];
foreach (string name in friends)
{
    Console.WriteLine(name);
}

// break 和 continue
for (int k = 1; k <= 10; k++)
{
    // 跳过偶数
    if (k % 2 == 0)
    {
        continue;
    }
    // 在 7 之后停止
    if (k > 7)
    {
        break;
    }
    Console.Write($"{k} ");
}
Console.WriteLine();

// 用 break 退出的无限循环:大于 50 的第一个 7 的倍数
int multiple = 50;
while (true)
{
    multiple++;
    if (multiple % 7 == 0)
    {
        break;
    }
}
Console.WriteLine($"first multiple of 7 greater than 50 : {multiple}");

结果:

> dotnet run basics-19.cs
for (1) : sum=55
for (2) : sum=55
while : sum=55
do while : sum=55
5! = 120
paul
hélène
jacques
sylvie
1 3 5 7 
first multiple of 7 greater than 50 : 56

说明:

  • 第 3–30 行:计算前 10 个整数之和的四种方法;
  • 第 4–8 行:经典的 [for] 循环;
  • 第 10–13 行:所有工作都在循环结束语句中完成;循环体为空。2008 年的课程使用 [for (...) ;]:C# 接受这种空语句,但编译器会发出警告(“possible invalid empty statement”),因为误放在 [for] 后面的分号是一种典型错误。空块 { } 可以明确无误地表达同样的意思;
  • 第 28 行:[i++] 返回 [i] 自增之前的值:[i] 被加到 [sum] 上,然后 [i] 自增;
  • 第 34 行:[for] 最常见的形式:循环变量在 [for] 中声明,并且只存在于循环内部;
  • 第 41–42 行:[foreach] 循环遍历数组 [friends] 的元素;
  • 第 51–58 行:对于偶数,[continue] 进入下一次迭代;[break] 在 [k] 超过 7 时立即终止循环;
  • 第 66–74 行:一个无限循环 [while (true)] ,通过 [break] 退出。当终止条件在循环中间计算时,这种形式很方便。我们将在键盘输入中使用它。

3.6. 异常处理

许多 .NET 方法都可能抛出异常,即错误。当某个方法可能抛出异常时,程序员应当对其进行处理,使程序具有更强的容错能力:应始终避免应用程序突然终止。

3.6.1. try/catch/finally 结构

异常处理遵循如下模式:

1
2
3
4
5
6
7
8
9
try
{
    code likely to throw an exception
}
catch (Exception e)
{
    handle the exception e
}
next statement

如果 [try] 块中的代码没有抛出异常,则继续执行下一条语句;否则,执行转入 [catch] 块的主体,然后再执行下一条语句。请注意以下几点:

  • [e] 是类型为 [Exception] 或其派生类型的对象。异常有许多类型:[IndexOutOfRangeException]、[FormatException]、[OverflowException]、[ArgumentException] 等。写成 [catch (Exception e)],表示你想处理所有类型的异常。如果 [try] 子句的代码可能产生多种类型的异常,你可能希望更具体一些,用多个 [catch] 子句来处理异常:
try
{
    code likely to throw the exceptions
}
catch (IndexOutOfRangeException e1)
{
    handle the exception e1
}
catch (FormatException e2)
{
    handle the exception e2
}
next statement

[catch] 子句按顺序求值;执行第一个类型与异常匹配的子句。因此,[catch (Exception e)] 子句必须放在最后;

  • 可以在 [finally] [try / catch] 子句之后添加 finally 子句:
try
{
    code likely to throw an exception
}
catch (Exception e)
{
    handle the exception e
}
finally
{
    code executed after try or catch
}
next statement

无论是否发生异常,[finally] 子句中的代码总会被执行。例如,可以用它来关闭文件;

  • 在 [catch] 子句中,你可能不想使用现成的 [Exception] 对象。这时可以不写 [catch (Exception e) { ... }],而写成 [catch (Exception) { ... }] ,或者更简单地写成 [catch { ... }];
  • 类 [Exception] 有一个属性 [Message] ,详细说明所发生的错误。要显示它,可以这样写:
1
2
3
4
5
catch (Exception ex)
{
    Console.WriteLine($"The following error occurred: {ex.Message}");
    ...
}
  • 类 [Exception] 有一个方法 [ToString] ,它返回一个字符串,其中包含异常类型、[Message] 属性的值以及调用堆栈,即出错时正在执行的方法列表,以及源文件名和行号。这是对开发人员最有用的信息,但并不是给用户看的。在本课程中,我们通常显示异常类型的名称 [ex.GetType().Name] 及其消息。

3.6.2. 第一个示例

程序 [basics-20.cs] 演示了访问不存在的数组元素所产生的异常:

// 由错误的数组索引引起的异常
int[] tab = [0, 1, 2, 3];
// 用 for 显示数组
for (int i = 0; i < tab.Length; i++)
{
    Console.WriteLine($"tab[{i}]={tab[i]}");
}
// 用 foreach 显示数组
foreach (int elmt in tab)
{
    Console.WriteLine(elmt);
}
// 引发异常
try
{
    tab[100] = 6;
}
catch (Exception e)
{
    Console.Error.WriteLine($"The following error occurred: {e.GetType().FullName} - {e.Message}");
    return;
}
finally
{
    Console.WriteLine("finally ...");
}
Console.WriteLine("This line is not executed");

结果:

> dotnet run basics-20.cs
tab[0]=0
tab[1]=1
tab[2]=2
tab[3]=3
0
1
2
3
The following error occurred: System.IndexOutOfRangeException - Index was outside the bounds of the array.
finally ...

说明:

  • 第 16 行:这条语句抛出异常,因为数组 [tab] 在索引 100 处没有元素;
  • 第 20 行:异常的类型是 [System.IndexOutOfRangeException] (结果的第 10 行);
  • 第 21 行:程序退出;
  • 第 23–25 行:尽管 [catch] 子句中包含 [return] 语句,[finally] 子句仍然被执行了(结果的第 11 行)。请注意,[finally] 子句总是会被执行;
  • 第 27 行:由于 [return],这一行不会被执行。

3.6.3. 受控输入

下面是另一个示例 [basics-21.cs],其中我们处理将不表示整数的字符串转换为整数时引发的异常:

// 输入年龄并处理转换异常
// 询问姓名
Console.Write("Name: ");
string name = Console.ReadLine() ?? "";
// 询问年龄
int age = 0;
bool ageOK = false;
while (!ageOK)
{
    // 提问
    Console.Write("age: ");
    // 读取并检查答案
    try
    {
        age = int.Parse(Console.ReadLine() ?? "");
        ageOK = age >= 1;
    }
    catch (FormatException)
    {
    }
    if (!ageOK)
    {
        Console.WriteLine("Incorrect age, try again...");
    }
}
// 最终显示
Console.WriteLine($"Your name is {name} and you are {age} year(s) old");

结果:

1
2
3
4
> dotnet run basics-21.cs
Name: dupont
age: 23
Your name is dupont and you are 23 year(s) old
1
2
3
4
5
6
7
8
> dotnet run basics-21.cs
Name: durand
age: x
Incorrect age, try again...
age: -4
Incorrect age, try again...
age: 12
Your name is durand and you are 12 year(s) old

说明:

  • 第 4 行:如果输入流已关闭,[ReadLine] 返回 [null]:此时用空字符串替代它。因此变量 [name] 可以是 [string] 类型;
  • 第 8–23 行:年龄输入循环;
  • 第 15 行:通过键盘输入的行使用 [int.Parse] 方法转换为整数。如果无法转换,该方法会抛出异常。这就是为什么要把该操作放在 [try / catch] 中;
  • 第 16 行:如果执行到这一行,说明转换成功。不过,我们还要验证得到的整数大于或等于 1;
  • 第 18 行:如果抛出 [FormatException] 异常,控制流转到 [catch],其中不执行任何操作。因此,初始化为 [ageOK] 的布尔变量 [false] 仍保持为 [false]。2008 年课程的代码写的是 [catch { }],它会捕获所有异常:不推荐这样做,因为它还会掩盖未预料到的错误;
  • 第 21–23 行:如果年龄不正确,则显示错误消息。

该程序有一个弱点:像 99999999999 这样的年龄会引发 [OverflowException] 异常,该异常未被捕获,导致程序终止。我们可以添加一个 [catch] 子句;不过,更简单的做法是使用 [int.TryParse],下面的示例应用程序就是这样做的。我们将把异常留给真正异常的情况。

3.6.4. 多个 catch 子句、过滤器和异常抛出

程序本身可以使用 [throw] 语句抛出异常:

throw new ArgumentException("error message");

当前方法的执行停止,异常沿着调用方法向上传播,直到某个 [catch] 子句处理它;如果没有任何子句处理它,程序就会终止并显示该异常。在 [catch] 子句中,[throw;] 语句(不带参数)会重新抛出当前异常,例如在记录日志之后。

从 C# 6 开始,[catch] 子句后面可以跟一个 [when (condition)] 过滤器:只有当条件为真时才会执行该子句。从 C# 7 开始,[throw] 还可以用作表达式,置于 ?? 运算符的右侧或三元运算符之中。

程序 [basics-22.cs] 演示了这些可能性:

// 多个 catch 子句、when 过滤器、抛出异常
string[] inputs = ["12", "abc", "", "99999999999", "-3", "150"];
foreach (string input in inputs)
{
    try
    {
        int age = ReadAge(input);
        Console.WriteLine($"[{input}] : age={age}");
    }
    // when 过滤器:仅当条件为真时才选中该子句
    catch (FormatException) when (input.Length == 0)
    {
        Console.WriteLine($"[{input}] : empty input");
    }
    catch (FormatException e)
    {
        Console.WriteLine($"[{input}] : {e.GetType().Name} - {e.Message}");
    }
    catch (OverflowException e)
    {
        Console.WriteLine($"[{input}] : {e.GetType().Name} - {e.Message}");
    }
    catch (ArgumentException e)
    {
        Console.WriteLine($"[{input}] : {e.GetType().Name} - {e.Message}");
    }
}

// throw 表达式(C# 7):位于 ?? 右侧或三元运算符中
string?[] names = ["dupont", null];
foreach (string? name in names)
{
    try
    {
        string valid = name ?? throw new ArgumentNullException(nameof(name), "the name is mandatory");
        Console.WriteLine($"name={valid}");
    }
    catch (ArgumentNullException e)
    {
        Console.WriteLine($"{e.GetType().Name} - {e.Message}");
    }
}

// 一个抛出异常的局部函数
static int ReadAge(string text)
{
    // int.Parse 会抛出 FormatException 或 OverflowException
    int age = int.Parse(text);
    // 如果年龄超出范围,我们自己抛出异常
    if (age < 0 || age > 130)
    {
        throw new ArgumentException($"age out of bounds [0,130] : {age}");
    }
    return age;
}

结果:

1
2
3
4
5
6
7
8
9
> dotnet run basics-22.cs
[12] : age=12
[abc] : FormatException - The input string 'abc' was not in a correct format.
[] : empty input
[99999999999] : OverflowException - Value was either too large or too small for an Int32.
[-3] : ArgumentException - age out of bounds [0,130] : -3
[150] : ArgumentException - age out of bounds [0,130] : 150
name=dupont
ArgumentNullException - the name is mandatory (Parameter 'name')

说明:

  • 第 2 行:模拟输入,其中一些有效,一些无效;
  • 第 7 行:局部函数 [ReadAge] 可能抛出多种类型的异常;
  • 第 11 行:只有当输入为空时,该子句才处理 [FormatException] ;
  • 第 15 行:其他的 [FormatException];
  • 第 19 行:对于 [int] 来说过大的数字;
  • 第 23 行:由 [ReadAge] 自身抛出的异常;
  • 第 35 行:一个 [throw] 表达式:如果 [name] 等于 [null],则抛出 [ArgumentNullException] 异常。运算符 [nameof] (C# 6)以字符串形式返回变量的名称;[ArgumentNullException] 会把它加入自己的消息中(结果的第 9 行);
  • 第 52 行:如果年龄超出范围,[ReadAge] 函数会抛出异常。

3.7. 示例应用程序 - V1

我们的目标是编写一个计算纳税人应纳税额的程序。我们考虑一种简化的情形:纳税人只需申报一份工资收入。数字取自 2004 年针对 2003 年收入的税率表,并原样使用:这是一道编程练习,而不是对当前税款的计算。该应用程序将作为我们的主线:在后续章节中我们会再次回到它,逐步加入类、文件、数据库,然后是网络功能。

  • 我们计算雇员的份数:如果未婚,份数 = nbChildren/2 + 1;如果已婚,份数 = nbChildren/2 + 2,其中 nbChildren 是其子女人数;
  • 如果他至少有三个孩子,则额外获得半份;
  • 他的应税收入 R 按 R = 0.72 * S 计算,其中 S 是其年薪;
  • 他的家庭系数按 QF = R / 份数 计算;
  • 他的税额 I 根据下表计算:
界限
coeffR
coeffN
4962
0
0
8382
0.068
291.09
14,753
0.191
1,322.92
23,888
0.283
2,668.39
38,868
0.374
4,846.98
47,932
0.426
6,883.66
0
0.481
9,505.54

每一行有 3 个字段。要计算税额 I,需找到第一行,使得 QF 小于或等于其界限。例如,如果 QF = 5,000,则找到的行为:

8382    0.068    291.09

于是税额 I 等于 0.068 * R - 291.09 * 份数,并向下取整到欧元。如果 QF 使得条件 QF ≤ 界限始终不成立,则使用最后一行的系数:I = 0.481 * R - 9505.54 * 份数。因此,最后一行中的界限 0 永远不会被使用。

对应的 C# 程序 [tax-v1.cs] 如下:

// 税款计算 - 版本 1
// 2004 年税率表(2003 年收入):这只是练习,不是现行税率表

// 税款计算所需的数据数组
decimal[] limits = [4962M, 8382M, 14753M, 23888M, 38868M, 47932M, 0M];
decimal[] coeffR = [0M, 0.068M, 0.191M, 0.283M, 0.374M, 0.426M, 0.481M];
decimal[] coeffN = [0M, 291.09M, 1322.92M, 2668.39M, 4846.98M, 6883.66M, 9505.54M];

// 婚姻状况
string answer;
while (true)
{
    Console.Write("Are you married (Y/N)? ");
    answer = (Console.ReadLine() ?? "").Trim().ToLower();
    if (answer is "y" or "n")
    {
        break;
    }
    Console.Error.WriteLine("Incorrect answer. Try again");
}
bool married = answer == "y";

// 子女数
int nbChildren;
while (true)
{
    Console.Write("Number of children: ");
    if (int.TryParse(Console.ReadLine(), out nbChildren) && nbChildren >= 0)
    {
        break;
    }
    Console.Error.WriteLine("Incorrect answer. Try again");
}

// 年薪
int salary;
while (true)
{
    Console.Write("Annual salary: ");
    if (int.TryParse(Console.ReadLine(), out salary) && salary >= 0)
    {
        break;
    }
    Console.Error.WriteLine("Incorrect answer. Try again");
}

// 份数
decimal shares = married ? nbChildren / 2M + 2 : nbChildren / 2M + 1;
if (nbChildren >= 3)
{
    shares += 0.5M;
}

// 应税收入
decimal income = 0.72M * salary;

// 家庭系数
decimal quotient = income / shares;

// 查找税率档:第一个满足 quotient <= limit 的档,
// 如果都不满足则取最后一档
int i = 0;
while (i < limits.Length - 1 && quotient > limits[i])
{
    i++;
}

// 税额(舍去到欧元)
int tax = (int)(coeffR[i] * income - coeffN[i] * shares);

// 显示结果
Console.WriteLine($"Tax to pay: {tax} euros");

说明:

  • 第 5–7 行:数值带有后缀 M,以使其成为 [decimal] 类型。[decimal] 类型可以精确地表示十进制数,例如 0.068;这是用于财务计算的类型。如果使用 [double],0.068 只是一个二进制近似值;
  • 第 10–21 行:在 [while (true)] 循环中输入婚姻状况,答案正确时通过 [break] 退出循环;
  • 第 14 行:[Console.ReadLine()] 返回键盘输入的字符串 C1,或者 [null] (替换为 "");[C1.Trim()] 去掉 C1 的首尾空格并返回字符串 C2;[C2.ToLower()] 返回转换为小写的字符串 C2。这样 Y 和 y 都可以接受;
  • 第 15 行:用 [or] 组合的模式;
  • 第 19 行:错误消息写入 [Error] 流;
  • 第 21 行:布尔变量 [married] 从关系式 [answer == "y"] 得到值 [true] 或 [false] ;
  • 第 28 行:如果输入不是整数,[TryParse] 返回 [false] ;此时条件 [nbChildren >= 0] 不会被求值(&& 运算符短路)。[TryParse] 接受 [null] 字符串:此时它返回 [false]。与 2008 年的版本不同,这里没有使用异常;
  • 第 40 行:工资的处理方式相同;
  • 第 48 行:不能简单地写 nbChildren / 2:如果 nbChildren 等于 3,就会得到 3/2,这是整数除法,结果是 1,而不是 1.5。由于除数 2M 是 [decimal] 类型,除法按 [decimal] 进行。2008 年的课程材料使用 [(decimal)nbChildren / 2],效果相同;
  • 第 62–65 行:确定税率档。计算在第一个大于或等于家庭系数的界限处停止,并且最迟在最后一档税率处停止。2008 年的版本最初把 QF 写入界限表的最后一个单元格以确保循环停止:这会改动税率表数据;条件 [i < limits.Length - 1] 可避免这种副作用;
  • 第 69 行:通过转换为 [int],税额被向下取整到欧元。

下面是一些输出示例:

1
2
3
4
5
> dotnet run tax-v1.cs
Are you married (Y/N)? y
Number of children: 2
Annual salary: 60000
Tax to pay: 4282 euros
> dotnet run tax-v1.cs
Are you married (Y/N)? yes
Incorrect answer. Try again
Are you married (Y/N)? y
Number of children: three
Incorrect answer. Try again
Number of children: 3
Annual salary: 60000 euros
Incorrect answer. Try again
Annual salary: 60000
Tax to pay: 2959 euros
1
2
3
4
5
> dotnet run tax-v1.cs
Are you married (Y/N)? n
Number of children: 0
Annual salary: 60000
Tax to pay: 11519 euros

这些结果与 2008 年课程中的相同:年薪 60,000 欧元的已婚纳税人,有 2 个孩子时应缴 4,282 欧元,有 3 个孩子时应缴 2,959 欧元。同样薪资的单身无子女者缴纳 11,519 欧元。在第二次运行中,输入“60000 euros”被拒绝:[int.TryParse] 只接受恰好表示一个整数的字符串(允许有前导和尾随空格)。

3.8. 主程序参数

主函数 [Main] 可以接受字符串数组 [string[]] 作为参数。该数组包含启动应用程序时使用的命令行参数。因此,如果程序 P 用如下命令启动:

P arg0 arg1 ... argn

并且函数 [Main] 声明如下:

        static void Main(string[] args)

那么我们将得到 args[0]="arg0"、args[1]="arg1",依此类推。在使用顶级语句时,程序员并不编写 [Main] 方法,但数组 [args] 同样可用:它是编译器生成的 [Main] 方法的参数。

使用 [dotnet run] 时,程序的参数放在两个连字符([--])之后,以便将它们与 [dotnet run] 命令本身的选项分隔开:

dotnet run prog.cs -- a0 a1 a2

2008 年的课程在 Visual Studio 项目属性中指定参数;如今,命令行就足够了。下面是一个示例 [basics-23.cs]:

1
2
3
4
5
6
7
// 命令行参数
// 使用顶级语句时,args 数组是预定义的
Console.WriteLine($"There are {args.Length} argument(s)");
for (int i = 0; i < args.Length; i++)
{
    Console.WriteLine($"args[{i}]={args[i]}");
}

结果:

1
2
3
4
5
6
> dotnet run basics-23.cs -- a0 a1 a2 a3
There are 4 argument(s)
args[0]=a0
args[1]=a1
args[2]=a2
args[3]=a3

包含空格的参数必须用引号括起来:

1
2
3
4
> dotnet run basics-23.cs -- "jean dupont" 23
There are 2 argument(s)
args[0]=jean dupont
args[1]=23

使用传统 [Main] 方法编写的同一个程序:[basics-24.cs]:

// 使用经典 Main 方法时的命令行参数
namespace Basics;

public static class Program
{
    public static void Main(string[] args)
    {
        Console.WriteLine($"There are {args.Length} argument(s)");
        for (int i = 0; i < args.Length; i++)
        {
            Console.WriteLine($"args[{i}]={args[i]}");
        }
    }
}

结果:

1
2
3
4
5
6
> dotnet run basics-24.cs -- a0 a1 a2 a3
There are 4 argument(s)
args[0]=a0
args[1]=a1
args[2]=a2
args[3]=a3

说明:

  • 第 2 行:文件范围的命名空间(C# 10);
  • 第 4 行:静态类只包含静态成员;
  • 第 6 行:程序的入口点。由于该文件不包含顶级语句,编译器会查找名为 [Main] 的静态方法;
  • 第 8 行:其余部分与 [basics-23.cs] 相同。

签名 [static void Main()] 在函数 [Main] 不带参数时有效。[Main] 也可以返回 [int],此时它就是程序的返回码:[static int Main(string[] args)]。

3.9. 枚举

枚举是一种数据类型,其值域由一组具名的整数常量构成。设想一个需要处理考试成绩的程序。成绩有五种可能:Pass、FairlyGood、Good、VeryGood 和 Excellent。于是我们可以为这五个常量定义一个枚举:

enum Honours { Pass, FairlyGood, Good, VeryGood, Excellent }

在内部,这五个常量被编码为连续的整数:第一个常量为 0,下一个为 1,依此类推。我们也可以显式地设置这些值:[enum Honours { Pass = 10, FairlyGood = 12, ... }]。可以声明一个变量,使其从枚举中取值:

Honours myHonours = Honours.Pass;

可以将变量与枚举中各个可能的值进行比较:

1
2
3
4
if (myHonours == Honours.Pass)
{
    Console.WriteLine("Could do better");
}

正如简单类型 [int] 等价于结构 [System.Int32],每个枚举都派生自类 [System.Enum]。该类提供静态方法,可用于获取枚举类型的值和名称:

  • [Enum.GetValues<Honours>()] (.NET 5)返回枚举 [Honours] 的值数组;
  • [Enum.GetNames<Honours>()] 返回它们的名称数组;
  • [Enum.TryParse(str, out Honours m)] 将字符串转换为枚举值。

2008 年的课程介绍的是 [Enum.GetValues(typeof(Honours))]:这种形式仍然有效,它返回一个无类型的数组,之后还必须进行转换。泛型形式 [GetValues<Honours>()] 则直接返回类型为 [Honours[]] 的数组。

程序 [basics-25.cs] 演示了刚才所描述的内容:

// 枚举
// 一个取值来自 Honours 枚举的变量
Honours myHonours = Honours.Pass;
// 显示变量的值
Console.WriteLine($"honours={myHonours}");
// 用枚举的值进行测试
if (myHonours == Honours.Pass)
{
    Console.WriteLine("Could do better");
}
// 荣誉列表:名称和整数值
foreach (Honours m in Enum.GetValues<Honours>())
{
    Console.WriteLine($"{m} = {(int)m}");
}
// 名称列表
Console.WriteLine(string.Join(", ", Enum.GetNames<Honours>()));
// 整数 → 枚举
Honours m3 = (Honours)3;
Console.WriteLine($"(Honours)3 = {m3}");
// 字符串 → 枚举
if (Enum.TryParse("Good", out Honours m2))
{
    Console.WriteLine($"m2={m2}, m2 > Pass : {m2 > Honours.Pass}");
}
// switch 表达式中的枚举
string assessment = myHonours switch
{
    Honours.Pass or Honours.FairlyGood => "correct",
    Honours.Good or Honours.VeryGood => "very correct",
    _ => "remarkable"
};
Console.WriteLine($"assessment : {assessment}");
Console.WriteLine($"type : {typeof(Honours).FullName}, underlying type : {Enum.GetUnderlyingType(typeof(Honours)).Name}");

// 类型的声明放在顶级语句之后
enum Honours { Pass, FairlyGood, Good, VeryGood, Excellent }

结果:

> dotnet run basics-25.cs
honours=Pass
Could do better
Pass = 0
FairlyGood = 1
Good = 2
VeryGood = 3
Excellent = 4
Pass, FairlyGood, Good, VeryGood, Excellent
(Honours)3 = VeryGood
m2=Good, m2 > Pass : True
assessment : correct
type : Honours, underlying type : Int32

说明:

  • 第 3 行:一个 [Honours] 类型的变量;
  • 第 5 行:枚举值以其名称显示;
  • 第 12–14 行:值的列表。[(int)m] 转换返回该常量的整数值;
  • 第 17 行:名称列表;
  • 第 19 行:反向转换,即从整数转换为枚举;
  • 第 22 行:将字符串转换为枚举值。枚举值的比较方式与编码它们的整数相同;
  • 第 27–31 行:枚举与 switch 语句配合得很好;
  • 第 34 行:底层整数类型默认为 [int] ;
  • 第 37 行:枚举的声明。在包含顶级语句的文件中,类型声明(枚举、类等)放在语句之后。

值为 2 的幂(1、2、4、8 等)的枚举可以加上特性 [Flags]:此时可以使用 | 运算符(按位或)组合其值,以表示一组选项,例如文件的访问权限(read | write)。

3.10. 向函数传递参数

这里我们关注参数是如何传递给函数的。请看下面的函数:

1
2
3
4
5
static void ChangeInt(int a)
{
    a = 30;
    Console.WriteLine($"Formal parameter a={a}");
}

在函数定义的第 1 行中,[a] 称为形式参数。它仅用于定义函数 [ChangeInt]。它完全可以命名为 [b]。现在来看一个使用该函数的示例:

1
2
3
int age = 20;
ChangeInt(age);
Console.WriteLine($"Actual parameter age={age}");

这里,在第 2 行的语句中,[age] 是实际参数,它将把自己的值传递给形式参数 [a]。我们关心的是形式参数如何获取实际参数的值。

3.10.1. 传递方式

C# 支持以下传递方式:

  • 按值传递 (默认方式):实际参数的值被复制到对应的形式参数中。这是两个不同的实体:如果函数修改了形式参数,实际参数保持不变。这种方式适用于函数的输入参数;
  • 使用 [ref] 按引用传递:实际参数和形式参数是同一个实体。如果函数修改了形式参数,实际参数也会随之被修改。关键字 [ref] 必须同时出现在函数定义和调用中。实际参数在调用之前必须有值。这种方式适用于输入输出参数;
  • 使用 [out] 按引用传递:与 [ref] 相同,但该参数是仅用于输出的参数:实际参数不需要初始值,并且函数必须为形式参数赋值。这是 [TryParse] 方法所使用的方式。从 C# 7 开始,可以在调用中声明变量:[out var x] 或 [out int x];
  • 使用 [in] 按只读引用传递(C# 7.2):参数按引用传递,从而避免复制,但函数不能修改它。这种方式只对较大的结构有用;对于预定义类型,按值传递同样高效。

程序 [basics-26.cs] 演示了这些不同的方式:

// 参数传递方式
// 1 - 按值传递
int age = 20;
ChangeInt(age);
Console.WriteLine($"Actual parameter age={age}");

// 2 - 使用 ref 按引用传递
int age2 = 20;
ChangeInt2(ref age2);
Console.WriteLine($"Actual parameter age2={age2}");

// 3 - 使用 out 按引用传递:无需初始化变量
int age3;
ChangeInt3(out age3);
Console.WriteLine($"Actual parameter age3={age3}");
// out var(C# 7):变量在调用处声明
ChangeInt3(out var age4);
Console.WriteLine($"Actual parameter age4={age4}");

// 4 - 使用 ref 交换两个值
int x = 1, y = 2;
Swap(ref x, ref y);
Console.WriteLine($"after swap : x={x}, y={y}");

// 5 - 使用 in 只读地按引用传递
decimal price = 100M;
Console.WriteLine($"InclTax({price})={InclTax(in price)}");

// 6 - 按值传递数组:复制的是它的引用
int[] array = [1, 2, 3];
ModifyArray(array);
Console.WriteLine($"array=[{string.Join(", ", array)}]");

// 局部函数
static void ChangeInt(int a)
{
    a = 30;
    Console.WriteLine($"Formal parameter a={a}");
}

static void ChangeInt2(ref int a2)
{
    a2 = 30;
    Console.WriteLine($"Formal parameter a2={a2}");
}

static void ChangeInt3(out int a3)
{
    a3 = 30;
    Console.WriteLine($"Formal parameter a3={a3}");
}

static void Swap(ref int a, ref int b)
{
    int temp = a;
    a = b;
    b = temp;
}

static decimal InclTax(in decimal amount)
{
    // amount = 0; 会被拒绝:in 参数不能被修改
    return amount * 1.2M;
}

static void ModifyArray(int[] t)
{
    // 我们修改所引用的数组:调用方能看到修改
    t[0] = 100;
    // 我们让 t 指向另一个数组:调用方看不到
    t = [7, 8, 9];
    Console.WriteLine($"in ModifyArray : t=[{string.Join(", ", t)}]");
}

结果:

> dotnet run basics-26.cs
Formal parameter a=30
Actual parameter age=20
Formal parameter a2=30
Actual parameter age2=30
Formal parameter a3=30
Actual parameter age3=30
Formal parameter a3=30
Actual parameter age4=30
after swap : x=2, y=1
InclTax(100)=120,0
in ModifyArray : t=[7, 8, 9]
array=[100, 2, 3]

说明:

  • 第 3–5 行:实际参数 [age] 的值 20 被复制到形式参数 [a] (第 35 行)。随后该参数被修改(第 37 行)。实际参数保持不变;
  • 第 8–10 行:使用 [ref] 时,实际参数 [age2] 随形式参数 [a2] 的修改而变化;
  • 第 13–15 行:变量 [age3] 在调用之前没有初始化;使用 [out] 时这是可以的;
  • 第 17 行:变量 [age4] 在调用中声明;
  • 第 21–22 行:交换两个值需要按引用传递;如果按值传递,函数交换的只是副本;
  • 第 27 行:只读传递。调用时关键字 [in] 是可选的。结果 120.0 带有一位小数,因为两个 [decimal] 值的乘积会保留其操作数的小数位数:100 × 1.2 = 120.0;
  • 第 30–32 行:数组是引用类型;按值传递的是数组的引用。因此函数 [ModifyArray] 操作的是与调用者相同的数组:[t[0]] 所做的修改(第 69 行)对调用者可见。但是,让 [t] 指向另一个数组(第 71 行)只会修改引用的局部副本。

如果把第 8 行替换为 [int age2;],编译器会拒绝该程序:

error CS0165: Use of unassigned local variable 'age2'

可以通过为 [age2] 赋初值来规避此问题,或者把关键字 [ref] 替换为关键字 [out]:这表示该参数仅为输出参数。同样,如果函数 [InclTax] 试图修改其参数 [in]:

error CS8331: Cannot assign to variable 'amount' or use it as the right hand side of a ref assignment because it is a readonly variable

3.10.2. 可选参数、命名参数、可变数量的参数

C# 4 引入了可选参数:可以在函数定义中为参数指定默认值;调用者随后可以省略它。可选参数放在必需参数之后。它还引入了命名参数:调用函数时,可以在实际参数前加上形式参数的名称和冒号。这使得位于其他参数之前的可选参数可以被省略,或者使参数能以任意顺序提供。

关键字 [params] 允许编写带有可变数量参数的函数:最后一个形式参数是数组,调用者既可以传递一个数组,也可以传递一个值列表(可以为空),由编译器将其整理成数组。从 C# 13 开始,[params] 参数也可以是其他集合类型,例如 [List<T>] 或 [ReadOnlySpan<T>]。

程序 [basics-27.cs] 如下:

// 可选参数、命名参数、可变数量的参数
// 可选参数(C# 4):它们有默认值
Console.WriteLine(Greet("Pierre"));
Console.WriteLine(Greet("Pierre", "Good evening"));
// 命名参数(C# 4):可以跳过可选参数或改变顺序
Console.WriteLine(Greet("Pierre", uppercase: true));
Console.WriteLine(Greet(uppercase: true, greeting: "Hi", name: "Paul"));

// params:可变数量的参数
Console.WriteLine($"Sum()={Sum()}");
Console.WriteLine($"Sum(1, 2, 3)={Sum(1, 2, 3)}");
int[] values = [10, 20, 30];
Console.WriteLine($"Sum(values)={Sum(values)}");
// 一个带可变数量参数的框架方法
Console.WriteLine(string.Join(" - ", "a", "b", "c"));

static string Greet(string name, string greeting = "Hello", bool uppercase = false)
{
    string message = $"{greeting} {name}";
    return uppercase ? message.ToUpper() : message;
}

static int Sum(params int[] numbers)
{
    // numbers 是一个数组
    int sum = 0;
    foreach (int number in numbers)
    {
        sum += number;
    }
    return sum;
}

结果:

1
2
3
4
5
6
7
8
9
> dotnet run basics-27.cs
Hello Pierre
Good evening Pierre
HELLO PIERRE
HI PAUL
Sum()=0
Sum(1, 2, 3)=6
Sum(values)=60
a - b - c

说明:

  • 第 17 行:函数 [Greet] 有一个必需参数 [name],以及两个可选参数 [greeting] 和 [uppercase];
  • 第 3 行:两个可选参数都取默认值;
  • 第 4 行:只有 [uppercase] 取默认值;
  • 第 6 行:通过命名参数,我们传递 [uppercase] 而不传递 [greeting];
  • 第 7 行:使用命名参数时,顺序是任意的;
  • 第 23 行:[Sum] 接受任意数量的整数;
  • 第 10–13 行:[Sum] 分别在不带任何参数、带三个整数以及带一个数组的情况下被调用;
  • 第 15 行:许多 .NET 方法,例如 [string.Join] 或带格式的 [Console.WriteLine] ,都有一个 [params] 参数。

3.11. 局部函数和元组

3.11.1. 局部函数

局部函数 (C# 7)是在方法内部定义的函数,或者像我们的示例那样,定义在顶级语句之间的函数。它只能在该位置使用。由于我们的程序不再有类,局部函数取代了 2008 年示例中的静态方法。局部函数:

  • 可以在定义之前被调用;
  • 可以使用其周围的局部变量,除非它被声明为 [static]:[static] 关键字(C# 8)确保它只依赖于自己的参数,从而更容易理解。我们尽可能将局部函数声明为 [static] ;
  • 可以有表达式体:[static int Square(int x) => x * x;] 等价于形如 [{ return x * x; }] 的函数体。

在较大的程序中,我们会编写类和方法:这是下一章的主题。

3.11.2. 元组

元组 (C# 7)将多个值(可以是不同类型)组合成一个实体。类型 [(int, string)] 表示由一个整数和一个字符串构成的二元组;它的元素称为 [Item1] 和 [Item2]。可以为它们命名:[(int Number, string Name)]。元组可以被解构:[var (number, name) = t;] 将其元素赋给两个变量。

元组使函数无需使用 [out] 参数即可返回多个值:这通常更易读。

程序 [basics-28.cs] 如下:

// 局部函数和元组
// 带表达式体的局部函数
static int Square(int x) => x * x;
Console.WriteLine($"Square(7)={Square(7)}");

// 非静态局部函数可以使用程序的变量
int counter = 0;
void Increment() => counter++;
Increment();
Increment();
Console.WriteLine($"counter={counter}");

// 元组把多个值组合在一起
(int, string) t1 = (1, "one");
Console.WriteLine($"t1={t1}, t1.Item1={t1.Item1}, t1.Item2={t1.Item2}");
// 元组的元素可以命名
(int Number, string Name) t2 = (2, "two");
var t3 = (Number: 3, Name: "three");
Console.WriteLine($"t2.Number={t2.Number}, t3.Name={t3.Name}");
// 解构:把元组拆分为多个变量
var (number, name) = t3;
Console.WriteLine($"number={number}, name={name}");

// 不使用 out 参数而返回多个值的函数
var (quotient, remainder) = Divide(17, 5);
Console.WriteLine($"17 = 5 * {quotient} + {remainder}");
var mm = MinMax([12, -4, 35, 7]);
Console.WriteLine($"min={mm.Min}, max={mm.Max}");
// 框架也使用元组
var (q, r) = Math.DivRem(23, 4);
Console.WriteLine($"Math.DivRem(23, 4) : quotient={q}, remainder={r}");

// 用元组交换两个变量
int a = 1, b = 2;
(a, b) = (b, a);
Console.WriteLine($"a={a}, b={b}");

static (int Quotient, int Remainder) Divide(int a, int b) => (a / b, a % b);

static (int Min, int Max) MinMax(int[] values)
{
    int min = values[0], max = values[0];
    foreach (int v in values)
    {
        if (v < min) min = v;
        if (v > max) max = v;
    }
    return (min, max);
}

结果:

> dotnet run basics-28.cs
Square(7)=49
counter=2
t1=(1, one), t1.Item1=1, t1.Item2=one
t2.Number=2, t3.Name=three
number=3, name=three
17 = 5 * 3 + 2
min=-4, max=35
Math.DivRem(23, 4) : quotient=5, remainder=3
a=2, b=1

说明:

  • 第 3 行:一个带表达式体的静态局部函数;
  • 第 7–8 行:一个非静态局部函数:它修改程序变量 [counter];
  • 第 14 行:一个元素没有名称的元组。打印元组时,其元素显示在圆括号中;
  • 第 17–18 行:两个带命名元素的元组:第一个通过其类型命名,第二个通过表达式中给出的名称命名;
  • 第 21 行:元组 [t3] 的解包;
  • 第 25 行:函数 [Divide] 返回整数除法的商和余数;结果被直接解包;
  • 第 27 行:这里保留了元组,并使用其元素的名称 [Min] 和 [Max];
  • 第 30 行:从 .NET 6 起,[Math.DivRem] 也返回一个元组(商,余数);
  • 第 35 行:使用元组可以在一行中交换两个变量,而无需临时变量;
  • 第 38 行:函数返回的类型是命名元组;
  • 第 40–48 行:一个在一次遍历中计算数组最小值和最大值的函数。