Skip to content

9. 异步编程

上一章介绍了线程:我们可以“同时”执行多段代码,对它们进行同步,并把任务分配给线程池。本章在 2008 年的课程中并不存在,它讨论的是一个相关但不同的问题:如何编写这样一个程序,它要 等待 很长时间(等待磁盘、网络或数据库),却不在这些等待期间阻塞线程。.NET 中的答案在于 C# 语言的两个关键字 [async] 和 [await],以及一个类型 [Task]。如今它们无处不在:后续各章将用它们来访问数据库([OpenAsync]、[ExecuteReaderAsync]、[ToListAsync]、[SaveChangesAsync]),编写 TCP 服务器([AcceptTcpClientAsync])、Web 客户端([HttpClient])以及使用 ASP.NET Core 的 Web 服务。

本章的所有示例都是单文件应用程序([async-01.cs]、[async-02.cs]……),在 [09-async] 文件夹中使用 [dotnet run async-NN.cs] 运行。其中许多示例用秒表([Stopwatch])测量时长:显示的毫秒数在每次运行之间、在不同机器之间都会有所不同(这些示例是在一台双处理器机器上运行的)。重要的是 数量级:1 秒还是 3 秒,300 毫秒还是 0 毫秒。

9.1. 为什么要异步

9.1.1. 会等待的操作

程序执行两类工作:

  • 计算任务,它们占用处理器:对列表排序、计算税款、分析文本;
  • 输入/输出 (I/O),本质上就是等待外围设备:从磁盘读取文件、向 Web 服务器发送请求并等待其响应、在数据库服务器上执行 SQL 查询。

两者的数量级差别很大。处理器每秒执行几十亿条指令。对磁盘(SSD)的一次读取操作大约需要十分之一毫秒;在本地网络上的一次往返只需零点几毫秒;与位于全国另一端的服务器的一次往返需要几十毫秒;而一个稍复杂的 SQL 请求有时可能需要几秒钟。在这些等待期间,处理器本可以执行数百万条指令。

当程序使用同步(阻塞)方法通过网络连接读取一行数据时,执行这次读取的线程会被 阻塞:它什么也不做,但仍然存在。它占用内存(它的栈,大约一兆字节),被操作系统所识别,而且最重要的是,它不能再用来做其他任何事情。在一次只做一件事的小型控制台程序中,这不成问题。但在两种情形下,问题就严重得多:

  • 在 服务器上:每个客户端由一个被阻塞的线程来服务,就会占用该线程。2008 年的课程在讨论异步 TCP 客户端的结论部分已经解释过这一点:如果线程池有 N 个线程,且这 N 个线程都在执行阻塞操作,那么就没有空闲线程可以服务新的客户端。现代 Web 服务器只用几十个线程就能处理成千上万个同时发生的请求:之所以能做到这一点,是因为它的线程从不在 I/O 上被阻塞;
  • 在 图形用户界面中:单个线程(UI 线程)负责处理点击并重绘窗口。如果它被一次下载阻塞,窗口就会冻结。

异步 就是启动 I/O 操作,在其运行期间 释放 线程(硬件和操作系统传输数据时并不需要它),然后在操作完成后恢复工作,可能是在另一个线程上:

Image

  • 在 [1] 中,线程 T1 启动 I/O,并一直阻塞到它完成;
  • 在 [2] 中,线程 T1 启动 I/O 后返回线程池,在那里它可以处理其他请求。当 I/O 操作完成时,系统通知 .NET,由 .NET 让线程池中的一个线程(T2,或者在 T1 空闲时由 T1)执行处理的 其余部分。

[async-01.cs] 程序在 100 次操作上测量这一差异,每次操作都等待一秒(用等待来模拟 I/O)。它使用了我们将在本章后面解释的指令([Task.Run]、[Task.Delay]、[await]);这里我们只关心结果。

// 为什么要异步:100 个操作,每个都要等待一秒
// (等待模拟一次 I/O:磁盘读取、网络请求、SQL 查询……)
using System.Diagnostics;

const int nbOperations = 100;
Console.WriteLine($"{nbOperations} operations of one second, {Environment.ProcessorCount} processors");

// 1 - 每个操作一个线程,每个线程在等待期间被阻塞
var stopwatch = Stopwatch.StartNew();
var threads = new Thread[nbOperations];
for (int i = 0; i < nbOperations; i++)
{
    threads[i] = new Thread(() => Thread.Sleep(1000));
    threads[i].Start();
}
Display("1 - one thread per operation", ProcessThreads());
foreach (var thread in threads)
{
    thread.Join();
}
Display("    end");

// 2 - 把操作交给线程池,但它们会阻塞线程池
stopwatch.Restart();
var tasks = new Task[nbOperations];
for (int i = 0; i < nbOperations; i++)
{
    tasks[i] = Task.Run(() => Thread.Sleep(1000));
}
Display("2 - thread pool, blocking waits", ProcessThreads());
Task.WaitAll(tasks);
Display("    end");

// 3 - 异步等待:等待期间不阻塞任何线程
stopwatch.Restart();
for (int i = 0; i < nbOperations; i++)
{
    tasks[i] = Task.Delay(1000);
}
Display("3 - asynchronous waits", ProcessThreads());
await Task.WhenAll(tasks);
Display("    end");

// 启动各操作半秒后,进程的线程数
int ProcessThreads()
{
    if (stopwatch.ElapsedMilliseconds < 500)
    {
        Thread.Sleep(500 - (int)stopwatch.ElapsedMilliseconds);
    }
    using var process = Process.GetCurrentProcess();
    return process.Threads.Count;
}

// 显示耗时,以及(如果提供)线程数
void Display(string message, int? nbThreads = null)
{
    string threadsInfo = nbThreads is null ? "" : $", {nbThreads,3} threads in the process";
    Console.WriteLine($"{message,-42} : {stopwatch.ElapsedMilliseconds,5} ms{threadsInfo}");
}

结果:

1
2
3
4
5
6
7
8
> dotnet run async-01.cs
100 operations of one second, 2 processors
1 - one thread per operation               :   526 ms, 110 threads in the process
    end                                    :  1012 ms
2 - thread pool, blocking waits            :   501 ms,  13 threads in the process
    end                                    : 24007 ms
3 - asynchronous waits                     :   501 ms,  17 threads in the process
    end                                    :  1002 ms

说明:

  • 第 8–21 行:2008 年课程中的方案,每个操作一个线程。每个线程执行 [Thread.Sleep(1000)]:它被阻塞一秒。100 次等待同时发生,整个过程恰好耗时一秒(第 4 行),但代价是多出 100 个线程:此时进程拥有超过 100 个线程(第 3 行)。如果有 10,000 个操作,就需要 10,000 个线程;
  • 第 23–31 行:这些操作被委托给线程池([Task.Run]),线程池已在上一章介绍过。线程池起初拥有与处理器数量相同的线程(此处为 2 个),只有在它们全部忙碌时才会逐步增加,因为它假定自己的线程在进行计算,没有必要让线程数量远远超过处理器数量。但在这里,它的线程并没有在计算:它们处于空闲状态。这些操作要等待空闲线程,整个过程耗时……超过二十秒(第 6 行)。这就是所谓的“线程池饥饿”,是将线程池与阻塞式 I/O 结合使用的服务器中最常见的缺陷;
  • 第 34–41 行:这些等待是异步的(用 [Task.Delay] 代替 [Thread.Sleep])。等待期间没有线程被阻塞:系统定时器会在一秒后唤醒 .NET。整个过程持续一秒,线程数量不会增加(第 7 行显示的线程是线程池在第 2 步期间创建的;它们处于空闲状态);
  • 第 51 行:[Process.GetCurrentProcess()] 提供对当前正在运行的进程的访问;其属性 [Threads] 是它的线程集合(包括 .NET 的线程和系统的线程)。

让我们记住这个教训:等待时不能阻塞线程。异步并不会让 I/O 更快;它让你可以用很少的线程同时处理许多 I/O 操作,并让应用程序所需的线程保持可用(GUI 线程、服务器线程池中的线程)。

9.1.2. 三种先后出现的模型

.NET 提出了三种编写异步代码的方式。前两种仍会出现在遗留代码和较早的文章中,因此认识它们是有用的。

模型
起源
原理
APM(“异步编程模型”,Asynchronous Programming Model)
.NET 1.0(2002)
一对方法:[BeginXxx] 和 [EndXxx]。[BeginXxx] 启动操作并接收一个回调方法([AsyncCallback]);该回调方法在操作结束时由线程池中的线程执行,并调用 [EndXxx] 来获取结果或异常。示例:[Socket.BeginConnect] / [EndConnect],2008 年课程中的异步 TCP 客户端就使用了它们。
EAP(“基于事件的异步模式”,Event-based Asynchronous Pattern)
.NET 2.0(2005)
一个启动操作的 [XxxAsync] 方法和一个在操作完成时触发的 [XxxCompleted] 事件。示例:[WebClient.DownloadStringAsync] 和 [DownloadStringCompleted],以及 2008 年课程中学习过的 [BackgroundWorker] 类(事件 [DoWork]、[ProgressChanged]、[RunWorkerCompleted])。
TAP(“基于任务的异步模式”,Task-based Asynchronous Pattern)
.NET 4.0(2010),C# 5(2012)
一个返回任务([XxxAsync] [Task] 或 [Task<T>])的方法,该任务代表当前的操作。调用方代码使用关键字 [await] 等待该任务。这是当前的模型,也是本课程其余部分唯一使用的模型。

APM 和 EAP 模式有同样的缺陷:代码被拆成了若干片段。本来自然读作“先连接,再读取,然后显示”的逻辑,变成了一个启动连接的方法、一个开始读取的回调方法,以及另一个显示数据的回调方法;变量必须在这些方法之间共享,异常在不同的地方处理,而一个简单的循环(“只要还有数据就读取”)则变成一个递归调用自身的回调方法,就像 2008 年课程中的读取方法([lecture])那样。TAP 模式配合 [async] 和 [await],使你可以编写 形式上与同步代码一样的异步代码。

程序 [async-02.cs] 按照 APM 和 TAP 这两种极端模型编写了同一个 TCP 客户端。它还包含一个由线程运行的小型服务器,可响应两个客户端(网络编程将在第 12 章详细介绍;目前只需知道,客户端连接到服务器并读取服务器发送给它的消息即可)。

// 同一个 TCP 客户端,先用 2008 年的 APM 模型编写,再用当前的 TAP 模型编写
using System.Net;
using System.Net.Sockets;
using System.Text;

const int port = 27500;
// 一个最小化的服务器,由一个线程执行:它为两个客户端服务后停止
var listener = new TcpListener(IPAddress.Loopback, port);
listener.Start();
var server = new Thread(() =>
{
    for (int i = 1; i <= 2; i++)
    {
        using Socket service = listener.AcceptSocket();
        // 服务器需要一些时间才回答
        Thread.Sleep(500);
        service.Send(Encoding.UTF8.GetBytes($"Hello client no. {i}"));
    }
    listener.Stop();
});
server.Start();
Display("start of the program");

// 1 - APM 模型(Asynchronous Programming Model,异步编程模型):BeginXxx / EndXxx 和回调方法
var end = new ManualResetEventSlim(false);
byte[] buffer = new byte[1024];
var client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
// 我们发起连接,并给出完成时要回调的方法
client.BeginConnect(IPAddress.Loopback, port, Connected, client);
Display("APM: connection launched, the program goes on");
// 主线程已无事可做:它等待最后一个回调方法的信号
end.Wait();

// 回调方法 1:连接已建立
void Connected(IAsyncResult result)
{
    // 我们取回作为 BeginConnect 最后一个参数传入的对象
    var socket = (Socket)result.AsyncState!;
    // 我们结束该操作(如果失败,抛出异常的是 EndConnect)
    socket.EndConnect(result);
    Display("APM: connected, read launched");
    // 我们发起对服务器回答的读取,使用另一个回调方法
    socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, Received, socket);
}

// 回调方法 2:数据已到达
void Received(IAsyncResult result)
{
    var socket = (Socket)result.AsyncState!;
    int nbBytes = socket.EndReceive(result);
    Display($"APM: received [{Encoding.UTF8.GetString(buffer, 0, nbBytes)}]");
    socket.Close();
    // 我们通知主线程
    end.Set();
}

// 2 - TAP 模型(Task-based Asynchronous Pattern,基于任务的异步模式):XxxAsync 和 await
using (var client2 = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
{
    await client2.ConnectAsync(IPAddress.Loopback, port);
    Display("TAP: connected, read launched");
    int nbBytes = await client2.ReceiveAsync(buffer);
    Display($"TAP: received [{Encoding.UTF8.GetString(buffer, 0, nbBytes)}]");
}
server.Join();

// 显示内容以执行它的线程编号为前缀
static void Display(string message)
{
    Console.WriteLine($"[thread {Environment.CurrentManagedThreadId,2}] {message}");
}

结果:

1
2
3
4
5
6
7
> dotnet run async-02.cs
[thread  1] start of the program
[thread  1] APM: connection launched, the program goes on
[thread  6] APM: connected, read launched
[thread  6] APM: received [Hello client no. 1]
[thread  6] TAP: connected, read launched
[thread  6] TAP: received [Hello client no. 2]

说明:

  • 第 8–21 行:服务器。它监听本机的 27500 端口([IPAddress.Loopback],即 127.0.0.1),依次接受两个连接,并在半秒后向每个客户端发送一条欢迎消息;
  • 第 24–54 行:按 APM 模式编写的客户端,与 2008 年的课程相同:
    • 第 29 行:[BeginConnect] 启动连接并立即交还控制权(结果的第 3 行)。它的最后两个参数是连接结束时要调用的回调方法 [Connected],以及一个任意对象,回调方法会在其 [AsyncState] 参数 [IAsyncResult] 的属性中找到它:在本例中就是套接字本身;
    • 第 32 行:主线程已无事可做。为防止程序在交换完成之前终止,它等待最后一个回调方法发出的信号:一个 [ManualResetEventSlim] 对象,其 [Wait] 方法会阻塞调用它的线程,直到另一个线程调用其 [Set] 方法(这是线程部分所见 [AutoResetEvent] 屏障的轻量级版本);
    • 第 35–43 行:连接回调方法。它必须用收到的参数调用 [EndConnect] :这个调用终止该操作,如果连接失败还会抛出异常。然后它用 [BeginReceive] 启动读取操作,并指定第二个回调方法 [Received];
    • 第 47–54 行:读取回调方法用 [EndReceive] 获取收到的字节数,显示消息,关闭套接字,并释放主线程;
    • 结果表明,回调方法是由主线程以外的线程执行的(是线程池中的线程,而不是线程 1);
  • 第 57–65 行:使用 TAP 模型的同一个客户端。[ConnectAsync] 和 [ReceiveAsync] 返回任务,而 [await] 等待它们完成,且不阻塞线程:代码像同步代码一样自上而下阅读;变量是普通的局部变量;没有回调方法或信号需要管理。执行其余代码的线程通常不再是线程 1:我们将在“由哪个线程执行其余部分?”一节解释原因;
  • 第 68 行:每条显示的内容都以执行它的线程的编号作为前缀,该编号来自 [Environment.CurrentManagedThreadId]。

没有必要记住 APM 模式。如果你需要使用只提供这种模式的旧库,方法 [Task.Factory.FromAsync] 可以把一对 [BeginXxx] / [EndXxx] 转换成返回 [Task] 的方法;在关于 [TaskCompletionSource] 的一节中,我们将看到如何把基于事件的 API(EAP 模型)转换成任务。

9.2. 任务:Task 与 Task<T>

任务 是表示正在进行或已完成的操作的对象:

  • [Task] 表示不返回结果的操作;
  • [Task<T>] 表示将返回类型为 [T] 的结果的操作。[Task<T>] 派生自 [Task]。

任务不是线程。任务可以由线程池中的线程执行(由 [Task.Run] 创建的任务就是这种情况),但许多任务并不由任何线程执行:[Task.Delay(1000)] 返回的任务只是在一秒后由定时器“完成”;[ReceiveAsync] 返回的任务在系统发出数据已到达的信号时完成。任务是对结果的一个 承诺 ,可以对它进行查询(它完成了吗?成功了吗?)和等待。

程序 [async-03.cs] 演示了创建任务和等待任务的主要方式:

// 任务:创建、等待、状态、结果、延续

// 1 - Task.Run 把一个处理交给线程池,并返回一个 Task<T> 任务
Task<long> task1 = Task.Run(() =>
{
    // 一个耗时零点几秒的计算
    long sum = 0;
    for (int i = 1; i <= 200_000_000; i++)
    {
        sum += i % 7;
    }
    return sum;
});
Console.WriteLine($"task1 launched, status: {task1.Status}");
// await 挂起程序直到任务结束,并返回其结果
long result = await task1;
Console.WriteLine($"task1 finished, status: {task1.Status}, result: {result}");

// 2 - Task.Delay 返回一个在延迟后结束的任务,不占用线程
Task task2 = Task.Delay(300);
Console.WriteLine($"task2 launched, status: {task2.Status}");
await task2;
Console.WriteLine($"task2 finished, status: {task2.Status}");

// 3 - 已经完成的任务
Task<int> task3 = Task.FromResult(42);
Task task4 = Task.CompletedTask;
Console.WriteLine($"task3: status {task3.Status}, result {await task3} ; task4: status {task4.Status}");

// 4 - 失败的任务:await 会重新抛出它的异常
Task<int> task5 = Task.Run(() => int.Parse("abc"));
try
{
    await task5;
}
catch (FormatException e)
{
    Console.WriteLine($"task5: status {task5.Status}, {e.GetType().Name}: {e.Message}");
}

// 5 - 阻塞形式 Wait() 和 Result:当前线程在等待期间被阻塞
Task<string> task6 = Task.Run(() =>
{
    Thread.Sleep(300);
    return "done";
});
task6.Wait();
Console.WriteLine($"task6: Wait() then Result = {task6.Result}");

// 6 - 延续:任务完成时要做的事
Task<int> task7 = Task.Delay(300).ContinueWith(t => 2 * 21);
Console.WriteLine($"task7: result of the continuation = {await task7}");

// 7 - IsCompleted、IsCompletedSuccessfully、IsFaulted、IsCanceled
Console.WriteLine($"task1: IsCompletedSuccessfully={task1.IsCompletedSuccessfully}, task5: IsCompleted={task5.IsCompleted}, IsFaulted={task5.IsFaulted}");
Console.WriteLine($"task5.Exception: {task5.Exception?.GetType().Name}, {task5.Exception?.InnerException?.GetType().Name}");

结果:

> dotnet run async-03.cs
task1 launched, status: WaitingToRun
task1 finished, status: RanToCompletion, result: 599999998
task2 launched, status: WaitingForActivation
task2 finished, status: RanToCompletion
task3: status RanToCompletion, result 42 ; task4: status RanToCompletion
task5: status Faulted, FormatException: The input string 'abc' was not in a correct format.
task6: Wait() then Result = done
task7: result of the continuation = 42
task1: IsCompletedSuccessfully=True, task5: IsCompleted=True, IsFaulted=True
task5.Exception: AggregateException, FormatException

说明:

  • 第 4–12 行:[Task.Run] 把一个函数分配给线程池,并立即返回一个表示其执行的任务。该函数返回一个 [long],因此任务的类型是 [Task<long>]。[Task.Run] 是用于在后台执行计算的工具;不能用它来“使阻塞式 I/O 操作异步化”([async-01.cs] 的第 2 步就是这样做的);
  • 第 14 行:[Status] 属性返回任务的状态。刚启动之后,任务在这里等待线程池中的某个线程接手它([WaitingToRun]);根据机器的负载,你也可能看到 [Running] (正在运行);
  • 第 16 行:[await task1] 等待任务完成,且不阻塞线程,并返回其结果,本例中结果的类型为 [long]。表达式 [await t] 的类型为 [T] ,如果 [t] 的类型为 [Task<T>];如果 [t] 的类型为 [Task],则它没有值;
  • 第 20 行:[Task.Delay(300)] 返回一个将在 300 毫秒后完成的任务。在此期间不占用任何线程。这相当于 [Thread.Sleep(300)] 的异步版本。它的状态 [WaitingForActivation], 表示“等待外部事件”;
  • 第 26–27 行:[Task.FromResult(42)] 返回一个已经以结果 42 完成的任务,而 [Task.CompletedTask] 返回一个已经完成且没有结果的任务。当某个方法需要返回任务但已经有了结果时(例如一个缓存的值),就会用到它们;
  • 第 31–36 行:函数抛出异常的任务以状态 [Faulted] 结束。异常保留在任务内部,而 [await] 会重新抛出它;可以用标准的 [try / catch] 捕获它;
  • 第 42–48 行:[Wait()] 通过 阻塞当前线程来等待任务完成,而 [Result] 属性返回 [Task<T>] 的结果,如果任务尚未结束,同样会阻塞线程。这些是上一章中等待线程的形式([Join])。应该避免使用它们:它们具有阻塞式 I/O 的所有缺点,会把异常包装在 [AggregateException] 中(第 56 行),并且在图形应用程序中可能造成死锁。它们应只保留给你确知任务已经完成的少数情形;
  • 第 51 行:[ContinueWith] 为任务附加一个 延续——一个在任务完成时执行的函数。延续接收已完成的任务,并在这里返回一个整数:这会产生一个新任务 [Task<int>]。在 .NET 4.0 中,在 [await] 出现之前,异步代码就是这样编写的;[await] 基于类似的机制(登记一段要在任务结束时执行的后续代码),只是由编译器以更安全的方式实现。[ContinueWith] 现在几乎不再被直接使用;
  • 第 54–56 行:布尔属性 [IsCompleted] (已结束,无论以何种方式)、[IsCompletedSuccessfully] (成功结束)、[IsFaulted] (因异常而结束)、[IsCanceled] (已取消),以及类型为 [Exception] 的属性 [AggregateException],其中包含任务的异常。

[Status] 属性(枚举 [TaskStatus])的可能取值如下:

状态
含义
[Created]
任务由构造函数创建,尚未启动(很少通过 [new Task(...)] 创建任务)
[WaitingForActivation]
任务正在等待外部事件:超时结束、I/O 操作或另一个任务
[WaitingToRun]
任务正在等待线程池中的线程变为可用
[Running]
任务当前正由某个线程执行
[WaitingForChildrenToComplete]
任务本身已完成,但正在等待附加的“子”任务(罕见情形)
[RanToCompletion]
任务已成功完成
[Faulted]
任务因未捕获的异常而终止
[Canceled]
任务已被取消(参见关于取消的一节)

最后三种状态是终态:已完成的任务不会再改变状态。

9.3. 异步方法:async 与 await

9.3.1. 编写异步方法

包含 [await] 的方法必须用 [async] 修饰符声明。它返回:

  • [Task] 如果它不返回结果(相当于 [void]);
  • [Task<T>] 如果它返回类型为 [T] 的结果:在方法内部,你写 [return value;] ,其中的值类型为 [T],编译器会把它包装到任务中。

按照约定,返回任务的方法的名称以 [Async] 结尾:[ReadAllTextAsync]、[ConnectAsync]、[MakeCoffeeAsync]。

程序 [async-04.cs] 煮咖啡并数方糖:

// 异步方法:async Task、async Task<T> 和执行顺序
using System.Diagnostics;

var stopwatch = Stopwatch.StartNew();
Display("call of MakeCoffeeAsync");
Task making = MakeCoffeeAsync();
Display("MakeCoffeeAsync has returned control: the program goes on");
Display("call of CountSugarsAsync");
Task<int> counting = CountSugarsAsync(3);
Display("CountSugarsAsync has returned control");
// 现在我们等待这两个结果
await making;
int nbSugars = await counting;
Display($"coffee ready, with {nbSugars} sugar(s)");

// 不返回结果的异步方法:它返回一个 Task
async Task MakeCoffeeAsync()
{
    Display("  coffee: the machine is heating");
    // 在第一次等待(await)一个未完成的任务时,方法把控制权交还给调用者
    await Task.Delay(1000);
    // 其余部分将在延迟结束后执行
    Display("  coffee: the machine is pouring the coffee");
    await Task.Delay(500);
    Display("  coffee: done");
}

// 返回整数的异步方法:它返回一个 Task<int>
async Task<int> CountSugarsAsync(int count)
{
    for (int i = 1; i <= count; i++)
    {
        await Task.Delay(200);
        Display($"  sugar no. {i}");
    }
    // 我们返回一个 int,编译器把它包装进 Task<int>
    return count;
}

// 显示自开始以来经过的时间
void Display(string message)
{
    Console.WriteLine($"{stopwatch.ElapsedMilliseconds,5} ms : {message}");
}

结果:

> dotnet run async-04.cs
    1 ms : call of MakeCoffeeAsync
   29 ms :   coffee: the machine is heating
   33 ms : MakeCoffeeAsync has returned control: the program goes on
   33 ms : call of CountSugarsAsync
   36 ms : CountSugarsAsync has returned control
  237 ms :   sugar no. 1
  436 ms :   sugar no. 2
  636 ms :   sugar no. 3
 1031 ms :   coffee: the machine is pouring the coffee
 1532 ms :   coffee: done
 1532 ms : coffee ready, with 3 sugar(s)

说明:

  • 第 17–25 行:一个没有返回值的异步方法。它正常地同步执行,直到遇到第一个针对未完成任务的 [await] (第 21 行)。此时,它 把控制权交还给调用者,并传回一个代表它的未完成任务;这就是为什么结果的第 4 行紧接在第 3 行之后出现,而不是晚一秒;
  • 第 23 行:一秒的超时过去之后,方法在 恢复 紧接在 [await] 之后的位置继续执行,局部变量保持不变,直到下一个 [await] 或直到它结束。当它结束时,返回给调用者的任务转为 [RanToCompletion] 状态;
  • 第 29–37 行:一个返回整数的异步方法:其返回类型是 [Task<int>], 但 [return] 指令返回的是一个 [int];
  • 第 6–9 行:主程序调用这两个方法但不等待它们。它获得两个任务并继续执行。这两个方法随后“同时”进行:在机器加热的同时数方糖(第 7–9 行);
  • 第 12–13 行:主程序等待这两个任务。咖啡在 1.5 秒后就准备好了——也就是两个操作中较长者的时长——而不是 2.1 秒(1.5 + 3 × 0.2)之后。

需要特别注意,[async] 并不会使方法变成异步的:它只是允许在方法内部使用 [await] 。一个不等待任何未完成任务的 [async] 方法会完全同步地执行(实际上,对于其中没有 [await] 的 [async] 方法,编译器会发出警告)。真正异步的是被等待的操作([Task.Delay]、异步 I/O)。

9.3.2. 编译器做了什么

一个方法怎么能在循环中间被中断、交还控制权,然后稍后在同一位置、以相同的局部变量值恢复执行?编译器把 [async] 方法转换成一个 状态机:这是一个类(在程序的优化版本,即以“Release”模式编译时,是一个结构),其字段是该方法的局部变量以及一个指示从何处恢复的状态编号。对于方法 [CountSugarsAsync],生成的代码大致如下:

// 编译器生成的内容(大幅简化)
Task<int> CountSugarsAsync(int count)
{
    var machine = new CountSugarsMachine { count = count, state = 0 };
    machine.Advance();         // 执行方法直到第一个 await
    return machine.ResultTask; // 状态机稍后会完成的任务
}

class CountSugarsMachine
{
    public int count, i, state;               // 局部变量变成字段
    public TaskCompletionSource<int> Source = new();
    public Task<int> ResultTask => Source.Task;

    public void Advance()
    {
        if (state == 0) { i = 1; }             // 第一次进入:循环开始
        else { Console.WriteLine($"  sugar no. {i}"); i++; }   // await 之后恢复执行
        if (i <= count)
        {
            state = 1;
            // 我们请求在延迟结束时被回调,然后交还控制权
            Task.Delay(200).GetAwaiter().OnCompleted(Advance);
            return;
        }
        Source.SetResult(count);               // 方法结束:任务完成
    }
}

这与 APM 模型中回调方法的原理相同([OnCompleted(Advance)] 请求在操作结束时进行回调),但拆分方法、保存变量和处理异常的是编译器。而开发者编写的是一个自上而下阅读的方法。你可以使用 ILSpy 之类的反编译器,或在 SharpLab 网站上查看实际生成的代码;它要长得多,特别是因为它还要处理所等待的任务已经完成的情形(此时执行会不间断地继续)以及异常的情形。

9.3.3. 由哪个线程执行其余的代码?

程序 [async-05.cs] 显示执行每一段代码的线程编号:

// await 之后,方法的其余部分由哪个线程执行?
Display("start of the program");
Display($"synchronization context: {SynchronizationContext.Current?.GetType().Name ?? "none"}");

// 1 - await 一个已完成的任务:不挂起,我们仍留在同一个线程上
await Task.CompletedTask;
Display("after await Task.CompletedTask");

// 2 - await 一个未完成的任务:其余部分由线程池中的线程执行
for (int i = 1; i <= 3; i++)
{
    await Task.Delay(100);
    Display($"after await Task.Delay(100) no. {i}");
}

// 3 - 等待期间,线程是空闲的:它可以去执行别的事情
Task t1 = WorkAsync("A");
Task t2 = WorkAsync("B");
await Task.WhenAll(t1, t2);
Display($"end of the program, threads created by the pool: {ThreadPool.ThreadCount}");

async Task WorkAsync(string name)
{
    for (int i = 1; i <= 3; i++)
    {
        Display($"  {name}{i} : before await");
        await Task.Delay(100);
    }
}

// 显示内容以执行它的线程编号为前缀
static void Display(string message)
{
    Console.WriteLine($"[thread {Environment.CurrentManagedThreadId,2}] {message}");
}

结果:

> dotnet run async-05.cs
[thread  1] start of the program
[thread  1] synchronization context: none
[thread  1] after await Task.CompletedTask
[thread  5] after await Task.Delay(100) no. 1
[thread  5] after await Task.Delay(100) no. 2
[thread  5] after await Task.Delay(100) no. 3
[thread  5]   A1 : before await
[thread  5]   B1 : before await
[thread  6]   A2 : before await
[thread  5]   B2 : before await
[thread  6]   B3 : before await
[thread  5]   A3 : before await
[thread  6] end of the program, threads created by the pool: 2

说明:

  • 第 3 行:[SynchronizationContext.Current] 是当前线程的 同步上下文 。在控制台程序中没有同步上下文(值为 [null]);我们将在 [ConfigureAwait] 一节中看到它在图形用户界面中所起的作用;
  • 第 6 行:等待一个已经完成的任务并不会挂起方法:执行会立即在同一个线程上继续(线程 1,第 4 行);
  • 第 10–13 行:在等待一个未完成的任务之后,在没有同步上下文的情况下,方法的其余部分由线程池中 任意一个线程 执行。主程序的线程,即线程 1,不再被使用:在等待期间,它无事可做。因此,在异步方法中,永远不要假定 [await] 之后的代码与之前的代码由同一个线程执行;
  • 第 17–19 行:对 [WorkAsync] 方法的两次调用同时进行。这六个代码块由线程池中的一个或两个线程执行(每次执行情况会有所不同),它们在 A 和 B 之间随着等待的发生而切换:一个在等待时,另一个就在工作。没有线程被固定分配给 A 或 B,在等待期间也没有任何线程被阻塞;
  • 第 20 行:[ThreadPool.ThreadCount] 返回线程池当前已创建的线程数:只有寥寥几个。

这种在不增加线程数量的情况下同时执行多个操作的方式称为并发。它不同于 并行,后者是在多个处理器上同时执行多个计算(如上一章所讨论的:[Parallel.For]、[Task.Run])。异步有利于 I/O 并发;它不会让计算变得更快。

9.3.4. 异步主程序

前面的程序直接在顶级语句中使用 [await] 。这从 C# 9 起就成为可能:当顶级语句包含 [await] 时,编译器会生成一个异步的 [Main] 方法,其签名为 [static async Task Main(string[] args)](或者 [Task<int>] ,如果程序使用 [return integer;])。

你也可以显式地编写这个方法,从 C# 7.1 起就可以这样做。程序 [async-06.cs] 就是这样做的:

// 异步 Main 方法的显式形式
namespace Async06;

public static class Program
{
    // Main 可以返回 Task 或 Task<int>(程序的退出代码)
    public static async Task<int> Main(string[] args)
    {
        // 秒数作为参数传入
        if (args.Length != 1 || !int.TryParse(args[0], out int nbSeconds) || nbSeconds < 0)
        {
            Console.WriteLine("syntax: dotnet run async-06.cs -- nbSeconds");
            return 1;
        }
        for (int i = nbSeconds; i > 0; i--)
        {
            Console.WriteLine($"{i} s left");
            await Task.Delay(1000);
        }
        Console.WriteLine("finished");
        return 0;
    }
}

结果,先是带参数,然后是不带参数:

1
2
3
4
5
> dotnet run async-06.cs -- 3
3 s left
2 s left
1 s left
finished
> dotnet run async-06.cs
syntax: dotnet run async-06.cs -- nbSeconds

说明:

  • 第 7 行:[Main] 方法是异步的,并返回一个 [Task<int>]。这个整数是程序的退出码(0 表示成功,其他任何值表示错误),脚本可以检查它(在 Linux 上用 [echo $?] ,在 Windows 上用 [echo %ERRORLEVEL%] );
  • 第 10 行:参数是倒计时的秒数。它在 [--] 之后传递,位于 [dotnet run async-06.cs -- 3] 命令中;
  • 第 18 行:等待一秒,不阻塞任何线程。

当 [Main] 是异步的时,运行时会调用它,获取返回的任务,并在程序终止前等待该任务完成。这是唯一执行阻塞式等待的地方,而且是由 .NET 自己执行的。

9.4. 顺序执行与并发执行

9.4.1. Task.WhenAll

咖啡的例子已经说明了这一点:启动 一个异步操作的时刻与 等待它 的时刻可以不同。写成 [await MethodAsync()] 会启动操作并立即等待它;写成 [var t = MethodAsync();] 然后在稍后写 [await t;] ,则允许在两者之间启动其他操作。程序 [async-07.cs] 用三个耗时一秒的操作比较了这两种做法:

// 三个一秒钟操作的顺序执行与并发执行
using System.Diagnostics;

var stopwatch = Stopwatch.StartNew();

// 1 - 依次执行:每个操作等待前一个操作结束
int a = await ReadTemperatureAsync("Angers");
int b = await ReadTemperatureAsync("Brest");
int c = await ReadTemperatureAsync("Colmar");
Console.WriteLine($"in sequence: {a}, {b}, {c} in {stopwatch.ElapsedMilliseconds} ms");

// 2 - 并发执行:我们启动三个操作,然后等待它们
stopwatch.Restart();
Task<int> ta = ReadTemperatureAsync("Angers");
Task<int> tb = ReadTemperatureAsync("Brest");
Task<int> tc = ReadTemperatureAsync("Colmar");
await Task.WhenAll(ta, tb, tc);
Console.WriteLine($"concurrently: {ta.Result}, {tb.Result}, {tc.Result} in {stopwatch.ElapsedMilliseconds} ms");

// 3 - 对 Task<T> 集合使用 Task.WhenAll 会直接返回结果数组
stopwatch.Restart();
string[] cities = ["Angers", "Brest", "Colmar", "Dijon", "Évry", "Foix"];
int[] temperatures = await Task.WhenAll(cities.Select(ReadTemperatureAsync));
Console.WriteLine($"{cities.Length} cities: [{string.Join(", ", temperatures)}] in {stopwatch.ElapsedMilliseconds} ms");

// 模拟查询一个一秒后回答的远程服务
static async Task<int> ReadTemperatureAsync(string city)
{
    await Task.Delay(1000);
    // 由城市名称派生出的"温度"
    return 10 + city.Length;
}

结果:

1
2
3
4
> dotnet run async-07.cs
in sequence: 16, 15, 16 in 3007 ms
concurrently: 16, 15, 16 in 1001 ms
6 cities: [16, 15, 16, 15, 14, 14] in 1005 ms

说明:

  • 第 7–9 行:每个操作先启动,再等待它完成,然后才启动下一个。代码不会阻塞任何线程,但这三个操作是一个接一个执行的:共 3 秒(第 2 行)。当一个操作需要上一个操作的结果时,这是正确的做法;
  • 第 14–16 行:三个操作启动时彼此并不等待。它们同时运行;
  • 第 17 行:[Task.WhenAll] 返回一个任务,当传给它的 所有 任务都完成时,该任务完成。我们用 [await] 等待它:耗时 1 秒而不是 3 秒(第 3 行);
  • 第 18 行:三个任务都已完成,因此 [Result] 属性无需阻塞即可返回它们的结果。我们也可以写成 [await ta],它会立即返回已完成任务的结果;
  • 第 23 行:当传给 [Task<T>] 的集合时,[Task.WhenAll] 返回一个 [Task<T[]>] ,其结果是结果数组,按任务的顺序排列(而不是按它们完成的顺序)。LINQ 的表达式 [cities.Select(ReadTemperatureAsync)] 为每个城市调用该方法,从而产生六个同时启动的任务。这六个操作总共耗时一秒。

[Task.WhenAll] 是 [Task.WaitAll] (在 [async-01.cs] 中使用)的异步等价物,后者通过阻塞当前线程来等待所有任务。

9.4.2. Task.WhenAny

[Task.WhenAny] 返回一个任务,只要传给它的任务中 任何一个 完成,该任务就会终止;它的结果就是最先完成的那个任务。程序 [async-08.cs] 以两种方式使用它:

// Task.WhenAny:对第一个完成的任务作出反应
using System.Diagnostics;

var stopwatch = Stopwatch.StartNew();

// 1 - 我们查询三个镜像服务器,只保留第一个回答
Task<string>[] requests =
[
    QueryAsync("mirror-paris", 800),
    QueryAsync("mirror-lyon", 300),
    QueryAsync("mirror-lille", 600),
];
// WhenAny 返回第一个完成的任务(一个 Task<string>)
Task<string> first = await Task.WhenAny(requests);
Console.WriteLine($"{stopwatch.ElapsedMilliseconds,5} ms : first answer: {await first}");
// 其他请求仍在继续:我们在这里等待它们,以便看到它们的回答
await Task.WhenAll(requests);
Console.WriteLine($"{stopwatch.ElapsedMilliseconds,5} ms : all the answers: {string.Join(", ", requests.Select(t => t.Result))}");

// 2 - 限时操作:我们让它与一个延迟"赛跑"
stopwatch.Restart();
Task<string> slow = QueryAsync("slow-server", 2000);
Task winner = await Task.WhenAny(slow, Task.Delay(500));
if (winner == slow)
{
    Console.WriteLine($"{stopwatch.ElapsedMilliseconds,5} ms : answer obtained in time: {await slow}");
}
else
{
    Console.WriteLine($"{stopwatch.ElapsedMilliseconds,5} ms : the slow server did not answer within the 500 ms delay");
}

// 模拟一个在 [duration] 毫秒后回答的服务器
static async Task<string> QueryAsync(string server, int duration)
{
    await Task.Delay(duration);
    return $"{server} ({duration} ms)";
}

结果:

1
2
3
4
> dotnet run async-08.cs
  309 ms : first answer: mirror-lyon (300 ms)
  803 ms : all the answers: mirror-paris (800 ms), mirror-lyon (300 ms), mirror-lille (600 ms)
  500 ms : the slow server did not answer within the 500 ms delay

说明:

  • 第 7–11 行:向三个镜像服务器发出查询;它们都保存相同的信息,但响应速度各不相同。这三个任务存放在一个用集合表达式初始化的数组中;
  • 第 14 行:[await Task.WhenAny(requests)] 返回最先完成的任务,其类型为 [Task<string>]。为了获得它的结果,我们再等待它一次(第 15 行):它已经完成,因此 [await] 会立即返回该字符串。第一个响应在 300 毫秒后到达(第 2 行);
  • 第 17 行:其他请求不会被 [WhenAny] 停止;它们会继续运行直到结束。要停止它们,就需要取消它们,我们将在关于取消的一节中介绍。在这里,我们等待它们,以便显示所有响应;
  • 第 22–24 行:[WhenAny] 的一种经典用法:通过让操作与超时之间进行一场“竞赛”来限制等待的时长。如果超时获胜,说明操作耗时过长。.NET 现在提供了一种更直接的方式来处理这种情况:[WaitAsync] 方法,稍后将会讨论。

9.4.3. Task.WhenEach

我们常常希望在多个操作完成时就处理它们的结果,而不必等待最慢的那个。在 .NET 9 之前,我们为此编写一个循环,调用 [Task.WhenAny],处理得到的任务,并把它从列表中移除。.NET 9 引入了 [Task.WhenEach] 方法,它按任务完成的顺序以 异步流 的形式返回任务,并用 [await foreach] 对其进行迭代(异步流将在本章后面讨论)。

程序 [async-09.cs] 处理五个“文件”,每个文件的处理需要 100 到 900 毫秒:

// Task.WhenEach(.NET 9):按任务完成的顺序处理结果
using System.Diagnostics;

var stopwatch = Stopwatch.StartNew();
int[] durations = [900, 300, 700, 100, 500];
// 我们启动所有任务
List<Task<string>> tasks = durations.Select((duration, i) => ProcessAsync($"file{i}.txt", duration)).ToList();

// await foreach:每个任务一完成就被交付
await foreach (Task<string> task in Task.WhenEach(tasks))
{
    Console.WriteLine($"{stopwatch.ElapsedMilliseconds,5} ms : {await task}");
}
Console.WriteLine($"{stopwatch.ElapsedMilliseconds,5} ms : all the files have been processed");

// 模拟处理一个耗时 [duration] 毫秒的文件
static async Task<string> ProcessAsync(string file, int duration)
{
    await Task.Delay(duration);
    return $"{file} processed in {duration} ms";
}

结果:

1
2
3
4
5
6
7
> dotnet run async-09.cs
  111 ms : file3.txt processed in 100 ms
  312 ms : file1.txt processed in 300 ms
  509 ms : file4.txt processed in 500 ms
  710 ms : file2.txt processed in 700 ms
  906 ms : file0.txt processed in 900 ms
  906 ms : all the files have been processed

说明:

  • 第 7 行:启动这五个处理。LINQ 的 [Select] 方法向函数提供元素及其索引([(duration, i)]);
  • 第 10–12 行:[Task.WhenEach(tasks)] 提交每个任务,一旦它完成:先是文件 3(100 毫秒),最后是文件 0(900 毫秒)。[await foreach] 循环等待下一个任务,而不阻塞任何线程。每个交付的任务都是已完成的:[await task] 会立即返回其结果;
  • 整个过程耗时 900 毫秒——即最长的那个处理步骤的时长——并且每个结果都会尽快显示。

9.5. 异步代码中的异常

9.5.1. 通过 [await] 传播

异步方法中抛出的异常在调用时不会传播给调用者:它被 保存在任务中,该任务随即转为 [Faulted] 状态。是 [await] 指令把它重新抛出。程序 [async-10.cs] 考察了各种情形:

// 异步代码中的异常

// 1 - await 会重新抛出被等待任务的异常
try
{
    int value = await ReadValueAsync("twelve");
    Console.WriteLine($"value = {value}");
}
catch (FormatException e)
{
    Console.WriteLine($"1 - exception caught: {e.GetType().Name} : {e.Message}");
}

// 2 - 调用异步方法不会抛出异常:异常被存储在任务中
// (这里,异常在方法的第一个 await 之前就已发生)
Task<int> task = ReadValueAsync("");
Console.WriteLine($"2 - after the call: status={task.Status}");
try
{
    await task;
}
catch (ArgumentException e)
{
    Console.WriteLine($"2 - it is the await that throws the exception: {e.GetType().Name} : {e.Message}");
}

// 3 - 多个任务失败时的 Task.WhenAll
Task<int>[] tasks = [ReadValueAsync("1"), ReadValueAsync("two"), ReadValueAsync("3"), ReadValueAsync("four")];
Task<int[]> all = Task.WhenAll(tasks);
try
{
    int[] values = await all;
}
catch (Exception e)
{
    // await 只会重新抛出第一个异常……
    Console.WriteLine($"3 - await rethrows: {e.GetType().Name} : {e.Message}");
    // ……但所有异常都在任务的 Exception 属性中,其类型为 AggregateException
    AggregateException ae = all.Exception!;
    Console.WriteLine($"3 - {ae.GetType().Name} with {ae.InnerExceptions.Count} exceptions:");
    foreach (Exception inner in ae.InnerExceptions)
    {
        Console.WriteLine($"      {inner.GetType().Name} : {inner.Message}");
    }
    // 成功的任务确实有它们的结果
    foreach (Task<int> t in tasks.Where(t => t.IsCompletedSuccessfully))
    {
        Console.WriteLine($"      successful task, result = {t.Result}");
    }
}

// 4 - 阻塞形式会把异常包装在 AggregateException 中
try
{
    int value = ReadValueAsync("five").Result;
}
catch (AggregateException e)
{
    Console.WriteLine($"4 - Result throws: {e.GetType().Name} containing {e.InnerException?.GetType().Name}");
}

// 一个异步方法,如果字符串不是整数就会失败
static async Task<int> ReadValueAsync(string text)
{
    // 在任何 await 之前立即检查参数
    ArgumentException.ThrowIfNullOrWhiteSpace(text);
    // 读取需要一点时间
    await Task.Delay(100);
    return int.Parse(text);
}

结果:

> dotnet run async-10.cs
1 - exception caught: FormatException : The input string 'twelve' was not in a correct format.
2 - after the call: status=Faulted
2 - it is the await that throws the exception: ArgumentException : The value cannot be an empty string or composed entirely of whitespace. (Parameter 'text')
3 - await rethrows: FormatException : The input string 'two' was not in a correct format.
3 - AggregateException with 2 exceptions:
      FormatException : The input string 'two' was not in a correct format.
      FormatException : The input string 'four' was not in a correct format.
      successful task, result = 1
      successful task, result = 3
4 - Result throws: AggregateException containing FormatException

说明:

  • 第 63–69 行:被测试的方法。它首先检查自己的参数(如果字符串为 [ArgumentException.ThrowIfNullOrWhiteSpace] 则抛出 [ArgumentException] ,即字符串为 [null]、空或空白),然后等待 100 毫秒,接着转换整个字符串,如果字符串不是数字,就会抛出 [FormatException] ;
  • 第 3–11 行:标准情形。由 [int.Parse] 在方法的 [await] 之后抛出的异常,会由调用者的 [await] 重新抛出:包围 [try / catch] 该 [await] 的结构会拦截它,与同步调用完全一样。这就是 [await] 带来的重大简化:在 APM 模型中,异常由回调方法内的 [EndXxx] 重新抛出,远离发起该操作的代码;
  • 第 16–24 行:这里,异常在方法中第一个 [await] 之前就已抛出。然而,这次调用不会触发任何东西:[async] 方法返回一个已经失败的任务(状态为 [Faulted],第 3 行),抛出异常的是 [await] 。[async] 方法在被调用时永远不会抛出异常;
  • 第 28–32 行:[Task.WhenAll] 等待四个任务,其中两个失败。于是任务 [all] 也会失败,并包含 两个 异常。但 [await] 只重新抛出其中一个,也就是第一个(第 5 行):语言设计者选择保留 [catch] 的通常形式(拦截 [FormatException],而不是某个包装器);
  • 第 39–43 行:要查看所有异常,请查阅任务 [all] 的 [Exception] 属性。它的类型是 [AggregateException],这是一种包含其他异常的异常,可通过其属性 [InnerExceptions] 访问;
  • 第 46–48 行:[WhenAll] 的失败并不妨碍其他任务成功;它们的结果是可用的;
  • 第 52–59 行:阻塞形式([Result]、[Wait()])不会重新抛出异常本身,而是抛出包含该异常的 [AggregateException] 。这是优先使用 [await] 而不是它们的又一个理由。

9.5.2. async void:应当避免

[async] 方法也可以声明为 [void]。在这种情况下,它不返回任何任务,这有两个严重后果:调用者无法知道它何时结束(无法等待它),也无法捕获它的异常。[async void] 方法中未捕获的异常会在线程池中的某个线程上重新抛出,没有人能够捕获它:它会 终止程序。程序 [async-11.cs] 演示了这一点:

// 为什么不能编写 async void 方法

// 我们显示未处理异常的消息,然后停止程序
AppDomain.CurrentDomain.UnhandledException += (sender, e) =>
{
    var exception = (Exception)e.ExceptionObject;
    Console.WriteLine($"unhandled exception: {exception.GetType().Name} : {exception.Message}");
    Console.WriteLine("the process is going to be stopped");
    Environment.Exit(1);
};

// 1 - async Task 方法:调用者可以 await 它并捕获它的异常
try
{
    await SaveAsync("a");
}
catch (InvalidOperationException e)
{
    Console.WriteLine($"1 - async Task: exception caught: {e.Message}");
}

// 2 - async void 方法:调用者既不能 await 它,也不能捕获它的异常
try
{
    Save("b");
    Console.WriteLine("2 - async void: the method has returned control, the try saw nothing");
}
catch (InvalidOperationException e)
{
    Console.WriteLine($"2 - async void: exception caught: {e.Message}");
}
// 程序继续它的工作……
for (int i = 1; i <= 5; i++)
{
    await Task.Delay(100);
    Console.WriteLine($"the program is working ({i})");
}
Console.WriteLine("normal end of the program");

static async Task SaveAsync(string data)
{
    await Task.Delay(200);
    throw new InvalidOperationException($"failure saving [{data}]");
}

// 不要这样做:async void 仅用于事件处理程序
static async void Save(string data)
{
    await Task.Delay(200);
    throw new InvalidOperationException($"failure saving [{data}]");
}

结果:

1
2
3
4
5
6
7
> dotnet run async-11.cs
1 - async Task: exception caught: failure saving [a]
2 - async void: the method has returned control, the try saw nothing
the program is working (1)
the program is working (2)
unhandled exception: InvalidOperationException : failure saving [b]
the process is going to be stopped

说明:

  • 第 4–9 行:[AppDomain.CurrentDomain.UnhandledException] 事件在某个异常无处被捕获时触发,就在系统终止进程之前。它的处理程序无法阻止这次终止;我们在这里用它显示一条自定义消息(而不是 .NET 将显示的堆栈跟踪),然后用 [Environment.Exit(1)] 亲自终止进程;
  • 第 15–19 行:方法 [SaveAsync] 返回一个 [Task]:它的异常被正常拦截;
  • 第 25–26 行:声明为 [Save] 的方法 [async void] 在遇到第一个 [await] 时交还控制权;[try] 在没有遇到任何东西的情况下结束。200 毫秒之后,该方法在线程池中的某个线程上抛出它的异常:程序在执行过程中被中止(第 4–7 行),而第 [normal end of the program] 行永远不会显示。

因此规则是:异步方法总是返回 [Task] 或 [Task<T>],绝不返回 [void]。唯一的例外是 GUI 事件处理程序(例如按钮点击):事件处理程序的签名要求 [void],所以我们写成 [private async void CalculateButton_Click(object sender, EventArgs e)]。在这种情况下,所有异常都在处理程序内部用 [try / catch] 捕获。

一个相关的错误是调用返回任务的方法却不等待它([SaveAsync("c");] 不带 [await]):编译器会用警告(CS4014)标出这一点,因为该任务抛出的任何异常都会丢失。如果你确实想启动一个任务而不等待它(“即发即弃”,fire-and-forget),就必须显式指定被忽略的元素 [_]:[_ = SaveAsync("c");],并且该方法随后必须自己处理自己的异常。

9.6. 取消与超时

9.6.1. CancellationTokenSource 与 CancellationToken

长时间运行的异步操作必须是 可取消的:用户点击了 [Cancel],Web 服务器客户端断开了连接,应用程序关闭了,或者超时了。为此,.NET 使用一种 协作式 机制,涉及两个对象:

  • 一个 [CancellationTokenSource] (取消源),由决定取消的代码持有。它的 [Cancel()] 方法请求取消;[CancelAfter(delay)] 在超时后自动请求取消;
  • 一个 [CancellationToken] (取消令牌),通过源的 [Token] 属性获得,并作为参数传给可取消的操作。操作检查该令牌([IsCancellationRequested]),或者在已请求取消时要求它抛出异常([ThrowIfCancellationRequested()]),并把它传递给自己所调用的操作。

这一机制是协作式的:没有人会强行中断某个操作(2008 年课程中的 [Thread.Abort] 方法在当前的 .NET 中已经过时:它只会抛出 [PlatformNotSupportedException]);操作会在能够干净地停止的某个点自行停止。按照约定,被取消的操作以抛出 [OperationCanceledException] 结束,其任务的状态为 [Canceled]。

程序 [async-12.cs] 以三种方式取消一个模拟的下载:

// 取消异步操作:CancellationTokenSource 和 CancellationToken
using System.Diagnostics;

var stopwatch = Stopwatch.StartNew();

// 1 - 一个在 1.2 秒后自行取消的取消源
using (var source = new CancellationTokenSource())
{
    source.CancelAfter(TimeSpan.FromSeconds(1.2));
    try
    {
        // 取消源的令牌被传给操作
        await DownloadAsync(10, source.Token);
    }
    catch (OperationCanceledException e)
    {
        Display($"1 - {e.GetType().Name} : {e.Message}");
    }
}

// 2 - 一个自己定期检查是否必须停止的计算
stopwatch.Restart();
using (var source = new CancellationTokenSource(TimeSpan.FromMilliseconds(300)))
{
    Task<long> computation = Task.Run(() => Compute(source.Token), source.Token);
    try
    {
        long result = await computation;
        Display($"2 - result: {result}");
    }
    catch (OperationCanceledException e)
    {
        Display($"2 - {e.GetType().Name}, status of the task: {computation.Status}");
    }
}

// 3 - 由程序用 Cancel() 显式请求取消
stopwatch.Restart();
using (var source = new CancellationTokenSource())
{
    Task download = DownloadAsync(10, source.Token);
    await Task.Delay(700);
    Display("3 - the program requests the cancellation");
    source.Cancel();
    try
    {
        await download;
    }
    catch (OperationCanceledException)
    {
        Display($"3 - download cancelled, IsCanceled={download.IsCanceled}");
    }
}

// 模拟下载 [nbBlocks] 个数据块(每 300 毫秒一个块)
async Task DownloadAsync(int nbBlocks, CancellationToken token)
{
    for (int i = 1; i <= nbBlocks; i++)
    {
        // Task.Delay 接受令牌:一旦请求取消,等待就会停止
        await Task.Delay(300, token);
        Display($"  block {i}/{nbBlocks} received");
    }
}

// 一个长时间的同步计算,每 1,000,000 次迭代检查一次令牌
static long Compute(CancellationToken token)
{
    long sum = 0;
    for (long i = 0; i < 100_000_000_000; i++)
    {
        if (i % 1_000_000 == 0)
        {
            // 如果已请求取消,则抛出 OperationCanceledException
            token.ThrowIfCancellationRequested();
        }
        sum += i % 7;
    }
    return sum;
}

void Display(string message)
{
    Console.WriteLine($"{stopwatch.ElapsedMilliseconds,5} ms : {message}");
}

结果:

> dotnet run async-12.cs
  307 ms :   block 1/10 received
  620 ms :   block 2/10 received
  921 ms :   block 3/10 received
 1211 ms : 1 - TaskCanceledException : A task was canceled.
  304 ms : 2 - OperationCanceledException, status of the task: Canceled
  300 ms :   block 1/10 received
  600 ms :   block 2/10 received
  700 ms : 3 - the program requests the cancellation
  701 ms : 3 - download cancelled, IsCanceled=True

说明:

  • 第 56–62 行:模拟的下载每 300 毫秒接收一个数据块。它接收一个 [CancellationToken] 作为最后一个参数(这是约定),并把它传给 [Task.Delay] (第 61 行):如果在等待期间请求取消,等待会被立即中断,并抛出 [TaskCanceledException]——一个派生自 [OperationCanceledException] 的类。.NET 几乎所有的异步方法都接受令牌:[ReadAllTextAsync]、[ConnectAsync]、[ToListAsync]……;
  • 第 6–17 行:该源是在 [using] 中创建的,因为它使用了必须释放的定时器。[CancelAfter] 在 1.2 秒后请求取消:下载接收三个数据块,然后在 1,200 毫秒时停止(第 5 行)。我们拦截 [OperationCanceledException],即基类,它处理所有的取消;
  • 第 21–33 行:一个可以被取消的同步计算(而不是等待)。方法 [Compute] (第 67–79 行)每一百万次迭代用 [ThrowIfCancellationRequested()] 检查一次令牌,如果已请求取消,它就会抛出 [OperationCanceledException]。该计算由 [Task.Run] 委托给线程池,令牌也同时传给了它:于是任务以状态 [Canceled] 而不是 [Faulted] 结束(第 6 行)。这里,源是带延迟创建的(构造函数 [CancellationTokenSource(TimeSpan)]),这等价于 [CancelAfter];
  • 第 37–51 行:该源在 700 毫秒后由 [Cancel()] 显式取消。取消是即时的:对第三个数据块的等待被中断(第 9–10 行)。

9.6.2. 重写 BackgroundWorker 示例

2008 年的课程用一个示例介绍了 [BackgroundWorker] 类,该示例有五个耗时 1 到 5 秒的处理,其中第 3 个抛出异常,第 4 个被取消。你必须把方法订阅到事件 [DoWork] 和 [RunWorkerCompleted],启用取消([WorkerSupportsCancellation]),在工作循环中测试 [CancellationPending] ,并填充事件参数的 [Result] 和 [Cancel] 属性;而且课程指出,在发生异常或取消时,无法确定是哪个处理受到了影响。[BackgroundWorker] 在 .NET 中仍然存在,但它是为 Windows Forms 图形用户界面设计的,如今已不再有存在的意义:任务能以更简单的方式完成同样的事情。程序 [async-13.cs] 重写了这个示例:

// 用任务重写 2008 年课程中的 BackgroundWorker 示例:
// 五个耗时 1 到 5 秒的处理,3 号抛出异常,4 号被取消
using System.Diagnostics;

var stopwatch = Stopwatch.StartNew();
using var cancellation = new CancellationTokenSource();
var tasks = new Task<Result>[5];
for (int i = 0; i < tasks.Length; i++)
{
    // 只有 4 号处理会收到取消源的令牌
    CancellationToken token = i == 4 ? cancellation.Token : CancellationToken.None;
    tasks[i] = SleepAsync(i, i + 1, token);
}
// 我们在 2.5 秒后取消 4 号处理
cancellation.CancelAfter(2500);
Console.WriteLine($"{stopwatch.Elapsed.TotalSeconds,4:F1} s : the {tasks.Length} processings are launched");

// 每个处理一完成我们就使用它,无论它以何种方式结束
await foreach (Task<Result> task in Task.WhenEach(tasks))
{
    int number = Array.IndexOf(tasks, task);
    string outcome = task.Status switch
    {
        TaskStatus.RanToCompletion => $"finished: scheduled duration {task.Result.Duration} s, actual duration {task.Result.ActualDuration:F1} s",
        TaskStatus.Faulted => $"encountered the following error: {task.Exception!.InnerException!.Message}",
        TaskStatus.Canceled => "cancelled",
        _ => $"unexpected status {task.Status}",
    };
    Console.WriteLine($"{stopwatch.Elapsed.TotalSeconds,4:F1} s : processing {number} {outcome}");
}

// 处理:休眠 [duration] 秒,以一秒为单位分段
static async Task<Result> SleepAsync(int number, int duration, CancellationToken token)
{
    var start = Stopwatch.GetTimestamp();
    // 3 号处理的异常
    if (number == 3)
    {
        throw new InvalidOperationException("test....");
    }
    for (int i = 1; i <= duration; i++)
    {
        await Task.Delay(1000, token);
    }
    // 返回给调用者的结果
    return new Result(duration, Stopwatch.GetElapsedTime(start).TotalSeconds);
}

// 一个处理的结果
record Result(int Duration, double ActualDuration);

结果:

1
2
3
4
5
6
7
> dotnet run async-13.cs
 0.0 s : the 5 processings are launched
 0.0 s : processing 3 encountered the following error: test....
 1.0 s : processing 0 finished: scheduled duration 1 s, actual duration 1.0 s
 2.0 s : processing 1 finished: scheduled duration 2 s, actual duration 2.0 s
 2.5 s : processing 4 cancelled
 3.0 s : processing 2 finished: scheduled duration 3 s, actual duration 3.0 s

说明:

  • 第 33–46 行:处理过程。第 3 个抛出异常;其他的“休眠” [duration] 秒,以一秒为增量,使用可取消的 [Task.Delay],并返回一个结果——一个 [record]——其中包含计划的时长和实际的时长。[Stopwatch.GetTimestamp()] 和 [Stopwatch.GetElapsedTime(start)] 无需创建 [Stopwatch] 对象就能测量时长;
  • 第 8–15 行:启动这五个处理。只有第 4 个处理接收取消源的令牌;其他的接收 [CancellationToken.None],这是一个永远不会被取消的令牌。第 4 个处理在 2.5 秒后被取消,尽管它还有 2.5 秒的休眠时间;
  • 第 19–29 行:借助 [Task.WhenEach],每个处理一结束就被处理,无论它是如何结束的:我们不使用 [await task],因为它会触发异常,而是用 [switch] 表达式检查它的状态。作业编号根据它在任务数组中的位置获得([Array.IndexOf]):2008 年课程中报告的问题就这样解决了;
  • 结果表明,第 3 个立即失败,第 0、1、2 个分别在 1、2、3 秒后完成,而第 4 个在 2.5 秒时被取消。

9.6.3. 限制等待的时长

程序 [async-14.cs] 提供了两个互补的工具:方法 [WaitAsync] 以及相关的取消源。

// 限制等待时长:WaitAsync 和链接令牌
using System.Diagnostics;

var stopwatch = Stopwatch.StartNew();

// 1 - WaitAsync(TimeSpan):我们最多等待一秒
Task<string> slow = QueryAsync("slow-server", 3000, CancellationToken.None);
try
{
    string answer = await slow.WaitAsync(TimeSpan.FromSeconds(1));
    Display($"1 - answer: {answer}");
}
catch (TimeoutException e)
{
    Display($"1 - {e.GetType().Name} : {e.Message}");
}
// 注意:WaitAsync 放弃的是等待,而不是操作,操作会继续进行
Display($"1 - status of the operation: {slow.Status}");

// 2 - 要真正停止操作,必须给它传入一个取消令牌
stopwatch.Restart();
using (var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(1)))
{
    Task<string> slow2 = QueryAsync("slow-server", 3000, timeout.Token);
    try
    {
        Display($"2 - answer: {await slow2}");
    }
    catch (OperationCanceledException)
    {
        Display($"2 - operation cancelled after one second, status: {slow2.Status}");
    }
}

// 3 - 组合两种取消原因:一个延迟和一个来自调用者的请求
stopwatch.Restart();
using var generalStop = new CancellationTokenSource();
await Task.WhenAll(ProcessWithTimeoutAsync("fast", 500, 1000, generalStop.Token),
                   ProcessWithTimeoutAsync("slow", 3000, 1000, generalStop.Token),
                   ProcessWithTimeoutAsync("medium", 1500, 2000, generalStop.Token),
                   StopAfterAsync(1200));

// 一个限制在 [timeout] 毫秒内的处理,调用者也可以停止它
async Task ProcessWithTimeoutAsync(string name, int duration, int timeout, CancellationToken stop)
{
    // 两种原因中任何一种发生时,链接的取消源都会被取消
    using var linked = CancellationTokenSource.CreateLinkedTokenSource(stop);
    linked.CancelAfter(timeout);
    try
    {
        Display($"3 - {await QueryAsync(name, duration, linked.Token)}");
    }
    catch (OperationCanceledException) when (stop.IsCancellationRequested)
    {
        Display($"3 - {name} : stopped at the caller's request");
    }
    catch (OperationCanceledException)
    {
        Display($"3 - {name} : timeout of {timeout} ms exceeded");
    }
}

// 调用者在 [duration] 毫秒后请求全部停止
async Task StopAfterAsync(int duration)
{
    await Task.Delay(duration);
    Display("3 - general stop requested");
    generalStop.Cancel();
}

// 模拟一个在 [duration] 毫秒后回答的服务器
static async Task<string> QueryAsync(string server, int duration, CancellationToken token)
{
    await Task.Delay(duration, token);
    return $"{server} answered in {duration} ms";
}

void Display(string message)
{
    Console.WriteLine($"{stopwatch.ElapsedMilliseconds,5} ms : {message}");
}

结果:

1
2
3
4
5
6
7
8
> dotnet run async-14.cs
 1024 ms : 1 - TimeoutException : The operation has timed out.
 1037 ms : 1 - status of the operation: WaitingForActivation
 1001 ms : 2 - operation cancelled after one second, status: Canceled
  502 ms : 3 - fast answered in 500 ms
 1003 ms : 3 - slow : timeout of 1000 ms exceeded
 1204 ms : 3 - general stop requested
 1204 ms : 3 - medium : stopped at the caller's request

说明:

  • 第 10 行:[t.WaitAsync(TimeSpan)](.NET 6)返回一个任务,该任务与 [t] 一同完成,只要 [t] 在时限内完成;否则它会以 [TimeoutException] 失败。这直接实现了“竞赛”,即 [Task.WhenAny] 在程序 [async-08.cs] 中的用法。另一个重载 [WaitAsync(CancellationToken)],使你可以停止等待一个不接受令牌的任务;
  • 第 18 行:[WaitAsync] 中止的是等待,而不是操作。操作仍在继续(状态为 [WaitingForActivation]);它会消耗资源,而它的结果将会丢失;
  • 第 20–31 行:要真正停止操作,必须在超时结束时向它传递一个已取消的令牌。操作在 1 秒后以状态 [Canceled] 结束。只要操作接受令牌,这就是首选的解决方案;
  • 第 44–59 行:一个处理可能因多种原因被取消;这里是由于它自己的超时和来自调用者的总体停止请求。[CancellationTokenSource.CreateLinkedTokenSource(stop)] 创建一个 链接 源:如果令牌 [stop] 被取消,它就会被取消,它也可以单独取消,在本例中使用 [CancelAfter(timeout)]。为了确定是这两个原因中的哪一个,使用了异常过滤器 [when] (第 53 行):只有当调用者请求终止时,才会保留第一个 [catch] ;
  • 第 38–41 行:三个处理步骤,以及在 1,200 毫秒时请求的总体停止。[fast] 处理正常完成;[slow] 处理超过了一秒的时限;[medium] 处理被分配了两秒,但被总体终止所终止。

9.7. 报告进度:IProgress<T>

长时间运行的操作往往需要报告其进度(进度条、百分比)。使用 [BackgroundWorker] 时,处理过程调用 [ReportProgress],而界面订阅 [ProgressChanged] 事件。对于任务,则使用 [IProgress<T>] 接口,它只有一个方法:

1
2
3
4
public interface IProgress<in T>
{
    void Report(T value);
}

操作接收一个 [IProgress<T>] 对象作为参数,并通过 [Report] 向它传递报告;它并不知道这些报告将如何显示。.NET 提供了实现 [Progress<T>],它面向图形用户界面:它保存创建它的线程(UI 线程)的同步上下文,并在那里执行报告处理,这使得图形组件可以得到更新,而不必担心线程问题。2008 年的课程必须使用委托对图形组件调用 [Invoke] 才能达到同样的结果。在没有同步上下文的控制台程序中,[Progress<T>] 由线程池中的线程处理报告,且不保证它们的顺序:因此程序 [async-15.cs] 使用它自己实现的 [IProgress<T>]。它模拟一次文件复制,用户可以通过键入 [Enter] 取消它:

// 用 IProgress<T> 报告操作进度;用户可以取消操作
using var cancellation = new CancellationTokenSource();
// 一个后台任务等待用户键入 [Enter] 以请求取消
_ = Task.Run(() =>
{
    Console.ReadLine();
    cancellation.Cancel();
});
Console.WriteLine("Copy in progress, type [Enter] to cancel it");

// 接收进度报告的对象
IProgress<Advancement> progress = new ConsoleProgress();
try
{
    int nbFiles = await CopyAsync(8, progress, cancellation.Token);
    Console.WriteLine($"Copy finished: {nbFiles} files copied");
}
catch (OperationCanceledException)
{
    Console.WriteLine("Copy cancelled by the user");
}

// 操作不知道进度如何显示:它只负责报告
static async Task<int> CopyAsync(int nbFiles, IProgress<Advancement>? progress, CancellationToken token)
{
    for (int i = 1; i <= nbFiles; i++)
    {
        // 文件的复制
        await Task.Delay(300, token);
        // 进度报告(调用者可能不需要任何报告:此时 progress 为 null)
        progress?.Report(new Advancement(100 * i / nbFiles, $"file{i}.dat"));
    }
    return nbFiles;
}

// 一个进度报告
record Advancement(int Percentage, string File);

// 在控制台中显示进度报告
class ConsoleProgress : IProgress<Advancement>
{
    public void Report(Advancement advancement)
    {
        // 一个 20 个字符的进度条
        string bar = new string('#', advancement.Percentage / 5).PadRight(20, '.');
        Console.WriteLine($"[{bar}] {advancement.Percentage,3} % {advancement.File}");
    }
}

不取消时的结果:

> dotnet run async-15.cs
Copy in progress, type [Enter] to cancel it
[##..................]  12 % file1.dat
[#####...............]  25 % file2.dat
[#######.............]  37 % file3.dat
[##########..........]  50 % file4.dat
[############........]  62 % file5.dat
[###############.....]  75 % file6.dat
[#################...]  87 % file7.dat
[####################] 100 % file8.dat
Copy finished: 8 files copied

用户在复制操作期间、一秒半之后输入 [Enter] 时的结果:

1
2
3
4
5
6
7
> dotnet run async-15.cs
Copy in progress, type [Enter] to cancel it
[##..................]  12 % file1.dat
[#####...............]  25 % file2.dat
[#######.............]  37 % file3.dat
[##########..........]  50 % file4.dat
Copy cancelled by the user

说明:

  • 第 24–33 行:操作接收一个 [IProgress<Advancement>] 和一个取消令牌。每处理完一个文件,它就通过一个 [Advancement] 对象报告进度(一个包含百分比和文件名的 [record] )。该参数被声明为可空([IProgress<Advancement>?]),并与 [?.] 运算符一起使用:不想要报告的调用者传入 [null];
  • 第 40–46 行:[IProgress<Advancement>] 的控制台实现显示一个 20 个字符的进度条;
  • 第 4–7 行:线程池中的一个任务等待用户键入 [Enter] ([Console.ReadLine] 是阻塞式读取,因此使用 [Task.Run]:被阻塞的是线程池中的一个线程,而不是程序),然后请求取消。程序不等待它,因此使用弃元 [_]:在程序结束时,这个任务被放弃;
  • 第 15–20 行:程序启动复制并等待其完成。取消会导致 [OperationCanceledException]。

9.8. 异步输入/输出

I/O 正是异步的本质所在。.NET 中的类为其所有 I/O 方法都提供了异步版本:文件([File]、[FileStream]、[StreamReader]、[StreamWriter]),网络([Socket]、[TcpClient]、[NetworkStream]、[HttpClient],详见第 12 章),数据库(ADO.NET 和 Entity Framework Core,第 10 章和第 11 章)。程序 [async-16.cs] 演示异步文件 I/O:读取示例目录中的税率档次文件 [TaxData.txt],该文件位于程序文件夹中:

1
2
3
4
5
6
7
4962:0:0
8382:0.068:291.09
14753:0.191:1322.92
23888:0.283:2668.39
38868:0.374:4846.98
47932:0.426:6883.66
0:0.481:9505.54

每一行包含档次上限、系数 [coeffR] 和系数 [coeffN],以字符 [:] 分隔,并使用小数点书写(该税率表是 2003 年收入适用的 2004 年税率表,在本练习中原样保留)。程序在 [09-async] 文件夹中运行,并在 当前文件夹中查找其文件。

// 文件的异步输入 / 输出
using System.Globalization;

const string data = "TaxData.txt";
const string report = "report-16.txt";

// 1 - 一次操作读取整个文件
string[] lines = await File.ReadAllLinesAsync(data);
Console.WriteLine($"1 - File.ReadAllLinesAsync: {lines.Length} lines");

// 2 - 用 StreamReader 逐行读取
var brackets = new List<TaxBracket>();
using (var reader = new StreamReader(data))
{
    string? line;
    // 到达文件末尾时,ReadLineAsync 返回 null
    while ((line = await reader.ReadLineAsync()) is not null)
    {
        brackets.Add(TaxBracket.Parse(line));
    }
}
Console.WriteLine($"2 - StreamReader.ReadLineAsync: {brackets.Count} brackets, the 2nd is {brackets[1]}");

// 3 - File.ReadLinesAsync 返回一个异步行流,用 await foreach 迭代
int nbBrackets = 0;
await foreach (string line in File.ReadLinesAsync(data))
{
    nbBrackets++;
}
Console.WriteLine($"3 - File.ReadLinesAsync: {nbBrackets} lines");

// 4 - 用 StreamWriter 写入:await using 以异步方式释放流
await using (var writer = new StreamWriter(report))
{
    await writer.WriteLineAsync("Brackets of the tax scale (exercise: 2004 scale on 2003 income)");
    foreach (var (bracket, i) in brackets.Select((t, i) => (t, i + 1)))
    {
        string limit = bracket.Limit == 0 ? "beyond" : $"up to {bracket.Limit:N0} €";
        await writer.WriteLineAsync($"bracket {i} : {limit,-18} rate {bracket.CoeffR:P1}");
    }
}

// 5 - 把整个文件读取为一个字符串
string text = await File.ReadAllTextAsync(report);
Console.Write($"4 and 5 - content of [{report}]:\n{text}");

// 6 - 追加到文件末尾,然后删除
await File.AppendAllTextAsync(report, "end of the report\n");
Console.WriteLine($"6 - last line: {(await File.ReadAllLinesAsync(report))[^1]}");
File.Delete(report);

// 一个税率档次;文件使用小数点:我们用固定区域性读取它
readonly record struct TaxBracket(decimal Limit, decimal CoeffR, decimal CoeffN)
{
    public static TaxBracket Parse(string line)
    {
        string[] fields = line.Split(':');
        return new TaxBracket(decimal.Parse(fields[0], CultureInfo.InvariantCulture),
                                decimal.Parse(fields[1], CultureInfo.InvariantCulture),
                                decimal.Parse(fields[2], CultureInfo.InvariantCulture));
    }
}

结果:

> dotnet run async-16.cs
1 - File.ReadAllLinesAsync: 7 lines
2 - StreamReader.ReadLineAsync: 7 brackets, the 2nd is TaxBracket { Limit = 8382, CoeffR = 0.068, CoeffN = 291.09 }
3 - File.ReadLinesAsync: 7 lines
4 and 5 - content of [report-16.txt]:
Brackets of the tax scale (exercise: 2004 scale on 2003 income)
bracket 1 : up to 4,962 €      rate 0.0 %
bracket 2 : up to 8,382 €      rate 6.8 %
bracket 3 : up to 14,753 €     rate 19.1 %
bracket 4 : up to 23,888 €     rate 28.3 %
bracket 5 : up to 38,868 €     rate 37.4 %
bracket 6 : up to 47,932 €     rate 42.6 %
bracket 7 : beyond             rate 48.1 %
6 - last line: end of the report

说明:

  • 第 8 行:[File.ReadAllLinesAsync] 读取整个文件并返回 [Task<string[]>]。[File] 类的读写方法都有异步版本:[ReadAllTextAsync]、[ReadAllBytesAsync]、[WriteAllTextAsync]、[WriteAllLinesAsync]、[AppendAllTextAsync] 等。它们都接受取消令牌作为最后一个参数;
  • 第 13–19 行:使用 [StreamReader] 逐行读取。[ReadLineAsync] 返回 [Task<string?>],在文件末尾其结果为 [null]。每一行由 [TaxBracket] 的 [Parse] 方法(第 55–60 行)转换,该方法以不依赖区域性(culture-invariant)的格式读取数字,因此在法语环境的机器上也能识别小数点;
  • 第 26–28 行:[File.ReadLinesAsync] (.NET 7)返回行的异步流 ([IAsyncEnumerable<string>]),使用 [await foreach] 遍历。与 [ReadAllLinesAsync] 不同,它不会将整个文件加载到内存中:而是按需读取各行。这是处理大文件的首选方法;
  • 第 33–39 行:使用 [StreamWriter] 及其方法 [WriteLineAsync] 写入。[StreamWriter] 使用 [await using] (C# 8)声明:退出代码块时,通过其方法 [DisposeAsync] 释放它,该方法会异步刷新其缓冲区。[await using] 用于实现 [IAsyncDisposable] 接口的对象([StreamWriter]、[FileStream]、数据库连接等);[StreamReader]只执行一次读取,仅实现 [IDisposable] ,使用标准的 [using];
  • 第 36 行:循环遍历由 [Select] 生成的元组(档次,编号)并对其进行解构;
  • 第 44–50 行:[ReadAllTextAsync] 重新读取已写入的文件,[AppendAllTextAsync] 向其中添加一行,然后删除该文件。[File.Delete] 没有异步版本:删除文件是一个非常短暂的操作。

注意:在 Windows 上,未指定任何特殊选项而打开的 [FileStream] 通过将同步读取委托给线程池来执行其异步操作;若要获得真正的异步系统 I/O,请使用 [FileOptions.Asynchronous] 选项(或 [useAsync: true])打开它。[File] 类的方法会自动处理这一点。对于本地文件,这种差异很少能察觉;而对于网络操作,差异则很明显,因为网络操作的异步 I/O 始终是真正的异步 I/O。

9.9. 异步流:IAsyncEnumerable<T>

异步方法在一段时间之后返回一个结果。迭代器(返回 [IEnumerable<T>] 并使用 [yield return] 的方法)按需生成并返回一个结果序列。异步流 (C# 8)将两者结合:它是一个值的序列,其中每个值在生成之前都可能需要异步等待。它们用于读取大文件中的行、SQL 查询结果的各行、通过网络连接到达的消息、传感器测量值等等……

  • 其类型是 [IAsyncEnumerable<T>];
  • 它由一个 [async] 方法生成,该方法返回 [IAsyncEnumerable<T>] ,并同时包含 [await] 和 [yield return];
  • 它由 [await foreach] 消费。

我们已经遇到过其中两个:[Task.WhenEach] 和 [File.ReadLinesAsync]。程序 [async-17.cs] 编写了一个异步流:

// 异步流:IAsyncEnumerable<T>、yield return、await foreach
using System.Diagnostics;
using System.Runtime.CompilerServices;

var stopwatch = Stopwatch.StartNew();

// 1 - 每个值一产生就被处理
await foreach (Measure measure in ReadMeasuresAsync("sensor-1", 4))
{
    Display($"1 - received {measure}");
}

// 2 - 我们可以在结束之前退出循环:生产者也随之停止
stopwatch.Restart();
await foreach (Measure measure in ReadMeasuresAsync("sensor-2", 100))
{
    Display($"2 - received {measure}");
    if (measure.Value >= 22)
    {
        break;
    }
}

// 3 - 取消:WithCancellation 把令牌传给标有 [EnumeratorCancellation] 的参数
stopwatch.Restart();
using var source = new CancellationTokenSource(TimeSpan.FromMilliseconds(700));
try
{
    await foreach (Measure measure in ReadMeasuresAsync("sensor-3", 100).WithCancellation(source.Token))
    {
        Display($"3 - received {measure}");
    }
}
catch (OperationCanceledException)
{
    Display("3 - reading cancelled");
}

// 4 - 对异步流使用 LINQ(System.Linq.AsyncEnumerable,.NET 10)
stopwatch.Restart();
List<double> high = await ReadMeasuresAsync("sensor-4", 6)
    .Where(m => m.Value > 21)
    .Select(m => m.Value)
    .ToListAsync();
Display($"4 - measures above 21: [{string.Join(" ; ", high)}]");

// 一个异步生产者:每 200 毫秒一次测量
static async IAsyncEnumerable<Measure> ReadMeasuresAsync(string sensor, int count,
    [EnumeratorCancellation] CancellationToken token = default)
{
    try
    {
        for (int i = 1; i <= count; i++)
        {
            // 等待下一次测量
            await Task.Delay(200, token);
            // 测量值交付给消费者;生产者将在下一次请求时从这里继续
            yield return new Measure(sensor, i, 19.5 + i * 0.75);
        }
    }
    finally
    {
        // 正常结束、被消费者 break 或被取消时执行
        Console.WriteLine($"          {sensor} : end of the production");
    }
}

void Display(string message)
{
    Console.WriteLine($"{stopwatch.ElapsedMilliseconds,5} ms : {message}");
}

// 一次测量
record Measure(string Sensor, int Number, double Value)
{
    public override string ToString() => $"{Sensor} no. {Number} : {Value} °C";
}

结果:

> dotnet run async-17.cs
  214 ms : 1 - received sensor-1 no. 1 : 20.25 °C
  426 ms : 1 - received sensor-1 no. 2 : 21 °C
  626 ms : 1 - received sensor-1 no. 3 : 21.75 °C
  827 ms : 1 - received sensor-1 no. 4 : 22.5 °C
          sensor-1 : end of the production
  204 ms : 2 - received sensor-2 no. 1 : 20.25 °C
  404 ms : 2 - received sensor-2 no. 2 : 21 °C
  605 ms : 2 - received sensor-2 no. 3 : 21.75 °C
  809 ms : 2 - received sensor-2 no. 4 : 22.5 °C
          sensor-2 : end of the production
  201 ms : 3 - received sensor-3 no. 1 : 20.25 °C
  404 ms : 3 - received sensor-3 no. 2 : 21 °C
  604 ms : 3 - received sensor-3 no. 3 : 21.75 °C
          sensor-3 : end of the production
  703 ms : 3 - reading cancelled
          sensor-4 : end of the production
 1213 ms : 4 - measures above 21: [21.75 ; 22.5 ; 23.25 ; 24]

说明:

  • 第 48–64 行:生产者。它等待 200 毫秒([await]),然后交付一个测量值([yield return]),如此反复。每次 [yield return] 之后,它都会暂停,直到消费者请求下一个值。[finally] 块在生产者停止时执行,无论停止的原因是什么;
  • 第 49 行:异步流的取消令牌是一个标有特性 [[EnumeratorCancellation]] (命名空间 [System.Runtime.CompilerServices])的参数。如果调用方没有提供令牌,则将其设为 [default] (一个永远不会被取消的令牌);
  • 第 7–10 行:[await foreach] 循环会等待每个测量值而不阻塞线程,并在其生成后立即处理:每 200 毫秒一个(第 2–6 行);
  • 第 13–20 行:当消费者通过 [break] 退出循环时,该流会被释放(方法 [DisposeAsync],由 [await foreach] 调用):生产者不再生成剩余的 96 个测量值,并执行其 [finally] 块(第 11 行);
  • 第 24–36 行:扩展方法 [WithCancellation] 将令牌传递给标有 [[EnumeratorCancellation]] 的参数。令牌在 700 毫秒后被取消:对第 4 个测量值的等待被中断;[OperationCanceledException] 穿过生产者(生产者会执行其 [finally]),然后穿过消费者的 [await foreach] 循环;
  • 第 41–44 行:.NET 10 为异步流引入了 LINQ(类 [System.Linq.AsyncEnumerable],此前由 NuGet 包 [System.Linq.Async] 提供):[Where]、[Select]、[Take]、[FirstAsync]、[ToListAsync] 等适用于 [IAsyncEnumerable<T>]。生成流的方法([Where]、[Select])返回另一个流;生成值的方法([ToListAsync]、[CountAsync]、[FirstAsync])返回一个待完成的任务;
  • 第 76 行:[record] [Measure] 的 [ToString] 方法被重新定义,以实现更紧凑的显示。

9.10. ValueTask、ConfigureAwait 与 TaskCompletionSource

9.10.1. ValueTask<T>

任务是一个对象:每次调用返回 [Task<T>] 的方法时(通常)都会在堆上分配一个对象,垃圾回收器随后必须回收它。对于持续数毫秒的 I/O,这可以忽略不计;但对于每秒被调用数百万次、且大多数时候已经拥有结果的方法(缓存、预先填充的 缓冲区),情况就不同了。针对这种情况,.NET 提供了 [ValueTask<T>] 结构体(C# 7,2017 年):它要么直接包含结果(无需分配),要么在操作确实是异步时包含一个真正的任务。程序 [async-18.cs] 将其用于一个带缓存的汇率服务:

// ValueTask<T>:一个多数情况下已经有结果的异步方法
using System.Diagnostics;

var service = new RateService();
var stopwatch = Stopwatch.StartNew();
foreach (string code in new[] { "EUR", "USD", "EUR", "EUR", "USD", "GBP", "EUR" })
{
    long start = stopwatch.ElapsedMilliseconds;
    decimal rate = await service.ReadRateAsync(code);
    Console.WriteLine($"{code} : {rate,6} read in {stopwatch.ElapsedMilliseconds - start,3} ms");
}
Console.WriteLine($"server accesses: {service.NbServerAccesses}, cache answers: {service.NbCacheAccesses}");

class RateService
{
    private readonly Dictionary<string, decimal> cache = [];
    public int NbServerAccesses { get; private set; }
    public int NbCacheAccesses { get; private set; }

    // ValueTask<decimal>:结果在缓存中时不分配 Task
    public ValueTask<decimal> ReadRateAsync(string code)
    {
        if (cache.TryGetValue(code, out decimal rate))
        {
            // 快速的同步路径:结果已经已知
            NbCacheAccesses++;
            return ValueTask.FromResult(rate);
        }
        // 缓慢的异步路径:必须查询服务器
        return new ValueTask<decimal>(ReadServerRateAsync(code));
    }

    private async Task<decimal> ReadServerRateAsync(string code)
    {
        NbServerAccesses++;
        // 模拟查询远程服务器
        await Task.Delay(300);
        decimal rate = code switch
        {
            "EUR" => 1m,
            "USD" => 1.17m,
            "GBP" => 0.87m,
            _ => throw new ArgumentException($"unknown currency: {code}"),
        };
        cache[code] = rate;
        return rate;
    }
}

结果:

1
2
3
4
5
6
7
8
9
> dotnet run async-18.cs
EUR :      1 read in 323 ms
USD :   1.17 read in 301 ms
EUR :      1 read in   0 ms
EUR :      1 read in   0 ms
USD :   1.17 read in   0 ms
GBP :   0.87 read in 301 ms
EUR :      1 read in   0 ms
server accesses: 3, cache answers: 4

说明:

  • 第 21–30 行:该方法不是 [async]。如果汇率在缓存中,它返回一个直接包含结果的 [ValueTask<decimal>] ([ValueTask.FromResult]):不会创建任何对象。否则,它将查询服务器的 [async] 方法的任务包装在 [ValueTask<decimal>] 中;
  • 第 33–45 行:模拟的服务器查询(300 毫秒),并将结果存入缓存。[async] 方法也可以直接返回 [ValueTask<T>];
  • 第 9 行:对调用方来说,没有任何变化:它使用 [ValueTask] 和 [await] 等待。结果显示了 3 次服务器访问(每次 300 毫秒)和 4 次来自缓存的即时响应。

[ValueTask<T>] 有一些限制:它只能被等待一次 (不能对同一个 [ValueTask] 使用两次 [await],也不能从多个位置同时等待),并且不能直接传递给 [Task.WhenAll]:必须先使用 [AsTask()] 将其转换为任务。经验法则很简单:默认使用 [Task] 和 [Task<T>] ,仅在经测量确认负载很重且经常同步完成的代码中才使用 [ValueTask] 。你主要会在 .NET 的方法中遇到 [ValueTask] 作为返回类型:[Stream.ReadAsync(Memory<byte>)]、[DisposeAsync]、[ChannelWriter.WriteAsync] 等。

9.10.2. ConfigureAwait 与同步上下文

程序 [async-05.cs] 已经表明,在控制台中,方法在 [await] 之后的剩余部分由池中的任意线程执行。在图形应用程序(Windows Forms、WPF、MAUI)中并非如此。图形组件只能由 UI 线程操作:2008 年的课程不得不在其回调方法中使用 [listBoxEvts.Invoke(...)],以便让该线程执行更新。有了 [await],这就不再必要了:界面线程拥有一个同步上下文 ([SynchronizationContext.Current] 不为 [null]),由 [await] 保存;等待结束时,方法的其余部分会交还给该上下文,从而由界面线程执行。我们可以这样写:

1
2
3
4
5
6
private async void DownloadButton_Click(object sender, EventArgs e)
{
    statusLabel.Text = "downloading…";                     // 界面线程
    string page = await client.GetStringAsync(address);     // 等待期间界面保持响应
    pageTextBox.Text = page;                                 // 回到界面线程
}

这种返回原始上下文的做法有代价,也有风险:如果代码在等待任务([task.Result])时阻塞了界面线程,而该任务又需要同一个线程来执行其剩余代码,两者就会无限期地互相等待(“死锁”)。这就是“不要使用 [.Result]”这条规则的主要原因。

方法 [ConfigureAwait(false)] 指示 [await] 不要返回原始上下文:[await stream.ReadAsync(buffer).ConfigureAwait(false);]。此后其余代码由池中的线程执行。建议如下:

  • 在通用库 (不处理图形用户界面,也不知道谁会调用它)的代码中,对每个 [await] 都使用 [ConfigureAwait(false)]:这样效率略高,并且可以在粗心的调用方使用 [.Result] 时避免死锁;
  • 在应用程序代码(图形用户界面、控制台程序、ASP.NET Core 应用程序)中,则不要写它。控制台程序和 ASP.NET Core 应用程序本来就没有同步上下文:[ConfigureAwait(false)] 在那里没有任何区别。

本课程中的示例都是应用程序,因此不使用 [ConfigureAwait]。

9.10.3. TaskCompletionSource<T>:将事件转换为任务

有时你需要使用某个通过 事件 来通知操作结束的 API(EAP 模型,或任何发布事件的类),而其余代码是使用 [await] 编写的。[TaskCompletionSource<T>] 类允许你创建一个由你自己 在所需时刻结束的任务:

  • 它的 [Task] 属性是一个未完成的 [Task<T>],会返回给调用方;
  • [SetResult(value)] / [TrySetResult(value)] 使任务成功完成;
  • [SetException(exception)] / [TrySetException(exception)] 使其以失败结束;
  • [SetCanceled()] / [TrySetCanceled()] 取消它。

如果任务已经完成,[TryXxx] 方法会返回 [false] 而不是抛出异常。事实上,前面介绍的 [CountSugarsAsync] 方法的简化状态机用的正是 [TaskCompletionSource<int>]。程序 [async-19.cs] 等待一个通过事件发布其测量值的温度计达到某一温度:

// TaskCompletionSource<T>:把基于事件的 API 转换为任务
using System.Diagnostics;

var stopwatch = Stopwatch.StartNew();
var thermometer = new Thermometer();
thermometer.Start();

// 1 - 我们等待(不阻塞线程)第一个大于或等于 21 °C 的测量值
double measure = await WaitForTemperatureAsync(thermometer, 21, CancellationToken.None);
Console.WriteLine($"{stopwatch.ElapsedMilliseconds,5} ms : 1 - temperature reached: {measure} °C");

// 2 - 同样的等待,但限制在一秒内:任务被取消
using (var timeout = new CancellationTokenSource(1000))
{
    try
    {
        measure = await WaitForTemperatureAsync(thermometer, 30, timeout.Token);
        Console.WriteLine($"{stopwatch.ElapsedMilliseconds,5} ms : 2 - temperature reached: {measure} °C");
    }
    catch (OperationCanceledException)
    {
        Console.WriteLine($"{stopwatch.ElapsedMilliseconds,5} ms : 2 - 30 °C not reached within one second");
    }
}
thermometer.Stop();

// 把温度计的 MeasureTaken 事件转换为任务
static Task<double> WaitForTemperatureAsync(Thermometer thermometer, double threshold, CancellationToken token)
{
    // 任务的源,由我们自己来完成它
    var source = new TaskCompletionSource<double>(TaskCreationOptions.RunContinuationsAsynchronously);
    // 用取消令牌注册的回调,任务完成时要释放
    CancellationTokenRegistration registration = default;
    // 事件处理程序在达到阈值时完成任务
    void OnMeasure(object? sender, double temperature)
    {
        if (temperature >= threshold && source.TrySetResult(temperature))
        {
            thermometer.MeasureTaken -= OnMeasure;
            registration.Dispose();
        }
    }
    thermometer.MeasureTaken += OnMeasure;
    // 取消请求使任务以 Canceled 状态完成
    registration = token.Register(() =>
    {
        if (source.TrySetCanceled(token))
        {
            thermometer.MeasureTaken -= OnMeasure;
        }
    });
    // 任务立即返回;它稍后才会完成
    return source.Task;
}

// 一个通过事件每 200 毫秒发布一次测量值的温度计("旧式"API)
class Thermometer
{
    public event EventHandler<double>? MeasureTaken;
    private Timer? timer;
    private double temperature = 19;

    public void Start()
    {
        timer = new Timer(_ =>
        {
            temperature += 0.5;
            Console.WriteLine($"          measure: {temperature} °C");
            MeasureTaken?.Invoke(this, temperature);
        }, null, 200, 200);
    }

    public void Stop()
    {
        timer?.Dispose();
    }
}

结果:

> dotnet run async-19.cs
          measure: 19.5 °C
          measure: 20 °C
          measure: 20.5 °C
          measure: 21 °C
  805 ms : 1 - temperature reached: 21 °C
          measure: 21.5 °C
          measure: 22 °C
          measure: 22.5 °C
          measure: 23 °C
          measure: 23.5 °C
 1812 ms : 2 - 30 °C not reached within one second

说明:

  • 第 57–75 行:温度计,一个“老式”类:一个计时器([System.Threading.Timer],它在池中的线程上按固定间隔执行一个方法)每 200 毫秒将温度升高 0.5 °C,并通过类型为 [MeasureTaken] 的事件 [EventHandler<double>] 发布(事件已在第 7 章中讨论);
  • 第 28–53 行:将事件转换为任务的方法。它不是 [async]:它创建一个 [TaskCompletionSource<double>],为事件订阅一个处理程序,并立即返回尚未完成的源任务;
  • 第 31 行:此选项指定,等待该任务的剩余代码不应由调用 [TrySetResult] 的线程(此处是正在触发事件的计时器线程)执行,而应由池中的线程执行。几乎在所有情况下,这都是推荐的选项;
  • 第 35–40 行:每次测量时,处理程序都会检查阈值。达到阈值后,处理程序以该温度作为结果结束任务,然后取消对事件的订阅,并释放与取消令牌的注册;
  • 第 45–47 行:[token.Register(action)] 注册一个在请求取消时执行的操作。在这里,它取消任务(状态为 [Canceled])并取消订阅处理程序。没有这一步,一个等待永远不会达到的阈值的任务将永远不会结束;
  • 第 9–22 行:对调用方来说,等待某个温度与任何其他异步方法没有区别:使用 [await] 等待它,并通过取消令牌限制其时间。

前面提到的 [Task.Factory.FromAsync] 对 APM 模型([BeginXxx] / [EndXxx])的 API 起着相同的作用。

9.11. 异步并行

9.11.1. Parallel.ForEachAsync

[Task.WhenAll] 同时启动所有操作。这并不总是理想的:要下载 10,000 个网页,你不会希望向同一台服务器同时打开 10,000 个连接。上一章介绍了 [Parallel.ForEach],它将集合的处理分布到多个线程上;其异步版本 [Parallel.ForEachAsync] (.NET 6)使用异步函数处理集合的元素,并限制并发操作的数量。程序 [async-20.cs] 下载九个页面,每次最多三个:

// Parallel.ForEachAsync:以有限数量的同时操作处理一个集合
using System.Diagnostics;

var stopwatch = Stopwatch.StartNew();
string[] pages = [.. Enumerable.Range(1, 9).Select(i => $"page{i}.html")];
int inProgress = 0;

// 同一时间最多 3 个下载
var options = new ParallelOptions { MaxDegreeOfParallelism = 3 };
await Parallel.ForEachAsync(pages, options, async (page, token) =>
{
    // 由同时进行的操作共享的计数器:我们以原子方式修改它
    int n = Interlocked.Increment(ref inProgress);
    Display($"start of {page} ({n} in progress)");
    // 模拟页面的下载
    await Task.Delay(1000, token);
    Interlocked.Decrement(ref inProgress);
    Display($"end of {page}");
});
Display($"the {pages.Length} pages are downloaded");

void Display(string message)
{
    Console.WriteLine($"{stopwatch.ElapsedMilliseconds,5} ms [thread {Environment.CurrentManagedThreadId,2}] : {message}");
}

结果:

> dotnet run async-20.cs
   12 ms [thread  4] : start of page1.html (1 in progress)
   12 ms [thread  6] : start of page2.html (2 in progress)
   29 ms [thread  6] : start of page3.html (3 in progress)
 1024 ms [thread  6] : end of page1.html
 1025 ms [thread  6] : start of page4.html (3 in progress)
 1028 ms [thread  4] : end of page3.html
 1028 ms [thread  6] : end of page2.html
 1029 ms [thread  4] : start of page5.html (2 in progress)
 1029 ms [thread  6] : start of page6.html (3 in progress)
 2023 ms [thread  6] : end of page4.html
 2023 ms [thread  6] : start of page7.html (3 in progress)
 2028 ms [thread  6] : end of page6.html
 2028 ms [thread  6] : start of page8.html (3 in progress)
 2030 ms [thread  4] : end of page5.html
 2030 ms [thread  4] : start of page9.html (3 in progress)
 3025 ms [thread  8] : end of page9.html
 3026 ms [thread  8] : end of page7.html
 3025 ms [thread  4] : end of page8.html
 3026 ms [thread  4] : the 9 pages are downloaded

说明:

  • 第 5 行:九个页面名称,使用带展开运算符 [..] 的集合表达式构造;
  • 第 9 行:[ParallelOptions] 的 [MaxDegreeOfParallelism] 属性设置并发操作的最大数量(默认为处理器的数量)。也可以在此设置取消令牌([CancellationToken]);
  • 第 10–18 行:[Parallel.ForEachAsync] 接收集合、选项和一个异步函数(一个 [async] lambda 表达式),该函数会针对每个元素被调用,并传入该元素和一个取消令牌,该令牌应传递给函数中的异步操作。[Parallel.ForEachAsync] 返回一个在所有元素处理完毕时完成的任务;
  • 第 13–17 行:这些函数在多个线程上同时运行:它们共享的计数器 [inProgress] 使用上一章中的 [Interlocked] 类以原子方式修改;
  • 结果显示了三波、每波三个页面:一个页面一结束,另一个就开始,正在进行的下载数量从未超过 3。整个过程耗时 3 秒,而不是 9 秒。当两个线程几乎同时写入时,各行的顺序在每次执行时可能不同,所显示的时间甚至可能比上一行稍早;
  • 只有两三个线程执行了所有函数:在等待期间,没有线程处于忙碌状态。

9.11.2. 生产者/消费者:System.Threading.Channels

上一章使用 生产者/消费者模式介绍了 [BlockingCollection<T>] 集合:生产者线程将元素加入队列,消费者线程将其取出;只要队列为空,[Take] (或枚举 [GetConsumingEnumerable])就会阻塞消费者;只要有界队列已满,[Add] 就会阻塞生产者。这些等待都会阻塞线程。通道(Channel)位于 [System.Threading.Channels] 命名空间(.NET Core 3.0)中,以异步等待的方式提供同样的功能:

  • [Channel.CreateBounded<T>(capacity)] 创建有界通道,[Channel.CreateUnbounded<T>()] 创建无界通道;
  • [Writer] 属性([ChannelWriter<T>])供生产者使用:[WriteAsync] 发布一个项(异步等待出现可用空间),[TryWrite] 尝试立即添加它,[Complete] 表示不会再有更多元素;
  • [Reader] 属性([ChannelReader<T>])供消费者使用:[ReadAsync] 获取一个元素,而 [ReadAllAsync] 返回包含所有元素的异步流,当通道被 [Complete] 关闭且为空时,该流结束。

程序 [async-21.cs] 处理每 50 毫秒生成一次的订单,使用两个消费者,每个消费者处理一个订单需要 400 毫秒:

// 使用通道(System.Threading.Channels)的生产者 / 消费者
using System.Diagnostics;
using System.Threading.Channels;

var stopwatch = Stopwatch.StartNew();
// 有界通道:最多包含 2 个等待处理的订单
Channel<int> channel = Channel.CreateBounded<int>(2);

// 生产者和两个消费者同时工作
Task producer = ProduceAsync(channel.Writer, 8);
Task consumer1 = ConsumeAsync("C1", channel.Reader);
Task consumer2 = ConsumeAsync("C2", channel.Reader);
await Task.WhenAll(producer, consumer1, consumer2);
Display("all the orders have been processed");

// 生产者:每 50 毫秒一个订单
async Task ProduceAsync(ChannelWriter<int> writer, int nbOrders)
{
    for (int i = 1; i <= nbOrders; i++)
    {
        await Task.Delay(50);
        // 如果通道中有空位,TryWrite 会立即写入订单,否则立即丢弃
        if (writer.TryWrite(i))
        {
            Display($"P  : order {i} dropped");
        }
        else
        {
            // 通道已满:WriteAsync 等待(不阻塞线程)直到有空位被释放
            Display($"P  : channel full, order {i} waits");
            await writer.WriteAsync(i);
            Display($"P  : order {i} dropped");
        }
    }
    // 不会再写入任何内容:消费者将退出它们的循环
    writer.Complete();
    Display("P  : end of the production");
}

// 一个消费者:处理一个订单需要 400 毫秒
async Task ConsumeAsync(string name, ChannelReader<int> reader)
{
    // ReadAllAsync 返回一个异步流,在通道关闭且为空时结束
    await foreach (int order in reader.ReadAllAsync())
    {
        Display($"{name} : processing of order {order}");
        await Task.Delay(400);
    }
    Display($"{name} : no more orders");
}

void Display(string message)
{
    Console.WriteLine($"{stopwatch.ElapsedMilliseconds,5} ms : {message}");
}

结果:

> dotnet run async-21.cs
   63 ms : C1 : processing of order 1
   63 ms : P  : order 1 dropped
  130 ms : P  : order 2 dropped
  130 ms : C2 : processing of order 2
  181 ms : P  : order 3 dropped
  233 ms : P  : order 4 dropped
  284 ms : P  : channel full, order 5 waits
  479 ms : P  : order 5 dropped
  479 ms : C1 : processing of order 3
  530 ms : P  : channel full, order 6 waits
  530 ms : C2 : processing of order 4
  530 ms : P  : order 6 dropped
  583 ms : P  : channel full, order 7 waits
  879 ms : C1 : processing of order 5
  879 ms : P  : order 7 dropped
  930 ms : P  : channel full, order 8 waits
  930 ms : C2 : processing of order 6
  930 ms : P  : order 8 dropped
  935 ms : P  : end of the production
 1277 ms : C1 : processing of order 7
 1330 ms : C2 : processing of order 8
 1679 ms : C1 : no more orders
 1731 ms : C2 : no more orders
 1731 ms : all the orders have been processed

说明:

  • 第 7 行:一个整数队列(包含订单编号),最多容纳 2 个待处理订单;
  • 第 10–13 行:生产者和两个消费者是同时启动的三个异步方法;程序等待这三个方法全部结束;
  • 第 23–31 行:生产者尝试使用 [TryWrite] 提交每个订单。如果通道已满,它会发出提示,并使用 [WriteAsync] 等待出现可用空间:生产者被限制在消费者的处理节奏上(第 8–9 行),而没有任何线程被阻塞。这就是有界通道的好处:速度过快的生产者无法占满内存;
  • 第 36 行:生产完成。消费者会清空通道,然后退出其循环;
  • 第 44–49 行:每个消费者处理异步流 [ReadAllAsync]。一个订单只会交付给一个消费者:订单根据 C1 和 C2 的空闲情况在两者之间分配;
  • 与上一个示例一样,几乎同时显示的两行可能顺序错乱(因此所显示的时间戳并不总是升序的)。

通道是实现生产者-消费者模式的现代工具,既适用于异步方法之间,也适用于线程之间。

9.12. 时间:PeriodicTimer 与 TimeProvider

两个较新的类完善了与时间相关的工具:

  • [PeriodicTimer] (.NET 6)是一个与 [await] 配合使用的计时器:其方法 [WaitForNextTickAsync] 返回一个在下一次“滴答”时完成的任务。与 [System.Threading.Timer] (用于 [async-19.cs])不同,后者会在池中的线程上调用回调方法——可能在上一次调用仍在进行时——[PeriodicTimer] 被写成一个简单的循环,并且永远不会让两次执行重叠;
  • [TimeProvider] (.NET 8)是一个抽象类,表示时钟:当前时间([GetUtcNow]、[GetLocalNow])、计时([GetTimestamp]、[GetElapsedTime])以及计时器的创建。[TimeProvider.System] 是系统时钟。依赖时间的类接收一个 [TimeProvider] ,而不是直接使用 [DateTime.Now]:这样就可以用受控的时钟对其进行测试。

程序 [async-22.cs] 同时使用了这两者:

// 时间:PeriodicTimer 和 TimeProvider
// 1 - PeriodicTimer:每 500 毫秒执行一个操作,2.2 秒后停止
TimeProvider clock = TimeProvider.System;
long start = clock.GetTimestamp();
using (var timer = new PeriodicTimer(TimeSpan.FromMilliseconds(500)))
using (var stop = new CancellationTokenSource(TimeSpan.FromSeconds(2.2)))
{
    int nbTicks = 0;
    try
    {
        // WaitForNextTickAsync 在每次触发时返回 true,如果计时器被 Dispose 停止则返回 false
        while (await timer.WaitForNextTickAsync(stop.Token))
        {
            nbTicks++;
            Console.WriteLine($"{clock.GetElapsedTime(start).TotalMilliseconds,6:F0} ms : tick no. {nbTicks}");
        }
    }
    catch (OperationCanceledException)
    {
        Console.WriteLine($"{clock.GetElapsedTime(start).TotalMilliseconds,6:F0} ms : timer stopped after {nbTicks} ticks");
    }
}

// 2 - TimeProvider:依赖时间的类接收它的时钟,而不是读取 DateTime.Now
var morning = new FixedClock(new DateTimeOffset(2026, 10, 3, 9, 30, 0, TimeSpan.Zero));
var evening = new FixedClock(new DateTimeOffset(2026, 10, 3, 19, 45, 0, TimeSpan.Zero));
Console.WriteLine(new Welcome(morning).Greet("Pierre"));
Console.WriteLine(new Welcome(evening).Greet("Pierre"));

// 一个依赖当前时间的类
class Welcome(TimeProvider clock)
{
    public string Greet(string name)
    {
        DateTimeOffset now = clock.GetLocalNow();
        string greeting = now.Hour < 18 ? "Hello" : "Good evening";
        return $"[{now:dd/MM/yyyy HH:mm}] {greeting} {name}";
    }
}

// 一个用于测试的静止时钟:它总是给出相同的时间(通用时间)
class FixedClock(DateTimeOffset instant) : TimeProvider
{
    public override DateTimeOffset GetUtcNow() => instant;
    public override TimeZoneInfo LocalTimeZone => TimeZoneInfo.Utc;
}

结果:

1
2
3
4
5
6
7
8
> dotnet run async-22.cs
   507 ms : tick no. 1
  1003 ms : tick no. 2
  1505 ms : tick no. 3
  2001 ms : tick no. 4
  2227 ms : timer stopped after 4 ticks
[03/10/2026 09:30] Hello Pierre
[03/10/2026 19:45] Good evening Pierre

说明:

  • 第 5–20 行:一个 500 毫秒的计时器和一个 2.2 秒的取消源。[WaitForNextTickAsync(token)] 在每个时钟脉冲时返回 [true] ,如果计时器已被释放([Dispose])则返回 [false];在这里,取消操作会在 4 次滴答之后停止循环;
  • 第 4 行:[TimeProvider] 中的 [GetTimestamp] 和 [GetElapsedTime] 用于测量时长,就像 [Stopwatch] 中的同名方法一样;
  • 第 31–37 行:类 [Welcome] 根据时间说“Hello”或“Good evening”。它在主构造函数中接收时钟,而不是从 [DateTime.Now] 读取:这是一个被注入的依赖,就像第 6 章中将 [dao] 层注入 [business] 层一样;
  • 第 42–45 行:一个停止的时钟,派生自 [TimeProvider],它重新定义了通用时间和时区。借助它,无需等到夜幕降临,就可以验证 [Welcome] 在早晨和晚上的行为。NuGet 包 [Microsoft.Extensions.TimeProvider.Testing] 提供了更完善的测试时钟 [FakeTimeProvider],可以随意拨快时间,包括延迟和计时器([Task.Delay(TimeSpan, TimeProvider)]、[new PeriodicTimer(TimeSpan, TimeProvider)])。

9.13. 应用:使用异步 I/O 计算税款

程序 [async-23.cs] 汇集了本章中与贯穿整个课程的税款计算相关的若干工具。它从文件 [TaxData.txt] (已经使用过)中读取税率档次,并从文件 [taxpayers.txt] 中读取纳税人列表:

1
2
3
4
5
6
7
y 2 60000
y 3 60000
n 0 60000
n 2 25000
y 5 120000
x 1 20000
y 1 -5

(每行包含:是否已婚 [y/n]、子女数量、年薪),计算每位纳税人的税款,并将结果写入文件 [results.txt]。所有 I/O 操作都是异步的,整个处理过程限制在 10 秒内。

// 应用程序:使用异步输入 / 输出的税额计算
// - 税率档次从 [TaxData.txt] 读取,纳税人从 [taxpayers.txt] 读取
// - 结果写入 [results.txt]
using System.Globalization;

using var cancellation = new CancellationTokenSource(TimeSpan.FromSeconds(10));
try
{
    TaxBracket[] brackets = await LoadBracketsAsync("TaxData.txt", cancellation.Token);
    int nbResults = await CalculateTaxesAsync(brackets, "taxpayers.txt", "results.txt", cancellation.Token);
    Console.WriteLine($"{nbResults} lines written to [results.txt]:");
    Console.Write(await File.ReadAllTextAsync("results.txt", cancellation.Token));
}
catch (OperationCanceledException)
{
    Console.WriteLine("processing abandoned: timeout exceeded");
}
catch (Exception e) when (e is IOException or FormatException)
{
    Console.WriteLine($"error: {e.GetType().Name} : {e.Message}");
}

// 读取税率档次(limit:coeffR:coeffN,小数点)
static async Task<TaxBracket[]> LoadBracketsAsync(string file, CancellationToken token)
{
    string[] lines = await File.ReadAllLinesAsync(file, token);
    return [.. lines.Where(l => l.Trim() != "").Select(TaxBracket.Parse)];
}

// 读取纳税人(已婚 子女数 工资),计算他们的税额并写入结果
static async Task<int> CalculateTaxesAsync(TaxBracket[] brackets, string input, string output, CancellationToken token)
{
    int nbLines = 0;
    await using var writer = new StreamWriter(output);
    await foreach (string line in File.ReadLinesAsync(input, token))
    {
        string[] fields = line.Split(' ', StringSplitOptions.RemoveEmptyEntries);
        string result = fields switch
        {
            [var m, var c, var s] when m is "y" or "n" && int.TryParse(c, out int children) && children >= 0
                                       && int.TryParse(s, out int salary) && salary >= 0
                => $"tax = {CalculateTax(brackets, m == "y", children, salary)} €",
            _ => "incorrect line",
        };
        await writer.WriteLineAsync($"{line,-12} : {result}");
        nbLines++;
    }
    return nbLines;
}

// 税额计算(2004 年税率表,应用于 2003 年收入,为练习保留)
static int CalculateTax(TaxBracket[] brackets, bool married, int nbChildren, int salary)
{
    decimal shares = married ? nbChildren / 2m + 2 : nbChildren / 2m + 1;
    if (nbChildren >= 3)
    {
        shares += 0.5m;
    }
    decimal income = 0.72m * salary;
    decimal quotient = income / shares;
    // 限额超过家庭系数的第一个档次,否则取最后一个档次
    TaxBracket bracket = brackets.FirstOrDefault(t => quotient <= t.Limit, brackets[^1]);
    return (int)(bracket.CoeffR * income - bracket.CoeffN * shares);
}

// 一个税率档次
readonly record struct TaxBracket(decimal Limit, decimal CoeffR, decimal CoeffN)
{
    public static TaxBracket Parse(string line)
    {
        string[] fields = line.Split(':');
        return new TaxBracket(decimal.Parse(fields[0], CultureInfo.InvariantCulture),
                                decimal.Parse(fields[1], CultureInfo.InvariantCulture),
                                decimal.Parse(fields[2], CultureInfo.InvariantCulture));
    }
}

结果:

1
2
3
4
5
6
7
8
9
> dotnet run async-23.cs
7 lines written to [results.txt]:
y 2 60000    : tax = 4282 €
y 3 60000    : tax = 2959 €
n 0 60000    : tax = 11519 €
n 2 25000    : tax = 792 €
y 5 120000   : tax = 11109 €
x 1 20000    : incorrect line
y 1 -5       : incorrect line

说明:

  • 第 6 行:一个取消源,将整个处理过程限制在 10 秒内。它的令牌被传递给所有异步方法;
  • 第 24–27 行:读取档次。带展开的集合表达式 [[.. sequence]] 将 LINQ 序列转换为数组;
  • 第 31–48 行:处理纳税人。使用异步流 [File.ReadLinesAsync] 逐行读取各行,并使用 [WriteLineAsync] 将结果写入由 [StreamWriter] 释放的 [await using];
  • 第 38–43 行:使用 [switch] 表达式验证一行,其中包含一个三元素的列表模式([[var m, var c, var s]])和一个检查这三个字段的 [when] 子句;
  • 第 52–63 行:税款计算。LINQ 的 [FirstOrDefault] 方法带有一个默认值,返回上限大于或等于家庭商数的第一个档次,如果没有适用的档次,则返回最后一个档次(与 2008 年的代码不同,它不会修改数据);
  • 第 14–20 行:可能的错误在主程序中的同一处统一处理:超时、I/O 或格式错误(文件缺失、数字输入不正确),通过带有 [or] 模式的 [when] 进行筛选;
  • 结果给出了基准值:夫妻合计收入 60,000 欧元、有 2 个孩子时为 4,282 欧元;有 3 个孩子时为 2,959 欧元;无子女的单身人士为 11,519 欧元。

计算本身是同步的:它不执行任何 I/O,只需几微秒。把它做成异步不仅毫无意义,甚至有害。只有涉及等待的操作才应设为异步。

9.14. 黄金法则

让我们总结一下 .NET 异步编程的规则:

  • 一路 async 到底:等待异步操作的方法本身也要变成异步方法([async Task]),其调用方也是如此,一直追溯到入口点(异步的 [Main] 、事件处理程序、ASP.NET Core 控制器操作)。将异步代码与阻塞等待混用会抵消异步的好处;
  • 不要对未完成的任务使用 [.Result]、[.Wait()] 或 [Task.WaitAll] :请改用 [await]、[Task.WhenAll]、[Task.WhenAny] 或 [Task.WhenEach]。这些阻塞形式会冻结线程,并可能在图形应用程序中造成永久死锁;
  • 不要在异步代码中使用 [Thread.Sleep] :而应使用 [await Task.Delay(...)];
  • 不要编写 [async void] 方法,GUI 事件处理程序除外;异步方法应使用 [Task] 或 [Task<T>] (在特殊情况下可使用 [ValueTask<T>]);
  • 异步方法的名称以 [Async] 结尾:[CalculateTaxesAsync]、[ReadRateAsync];
  • 可取消的异步方法接收一个 [CancellationToken] 作为其最后一个参数,并将它传递给它调用的所有异步操作;被取消的操作以 [OperationCanceledException] 结束;
  • [Task.Run] 专用于你希望在后台执行的计算(例如,避免阻塞 GUI 线程)。不要为了“使其异步”而把同步 I/O 操作包装在 [Task.Run] 中:请使用该操作的 [XxxAsync] 版本;
  • 先启动,后等待:要同时运行多个相互独立的操作,请先将它们全部启动,然后使用 [Task.WhenAll] 等待它们;要限制操作的数量,请使用 [Parallel.ForEachAsync] 或通道;
  • [ConfigureAwait(false)] 用于库中,而不用于应用程序中;
  • 已启动的任务必须被等待(或使用 [_ =] 显式忽略,同时处理其异常):被遗忘的任务会隐藏其异常,并可能因程序结束而被中断。

下表总结了线程世界(上一章,2008 年的课程)与任务世界之间的对应关系:

线程,阻塞等待
任务,异步等待
[Thread.Sleep(1000)]
[await Task.Delay(1000)]
[thread.Start()] 之后是 [thread.Join()]
[var t = MethodAsync();] 然后 [await t]
等待多个线程(循环中的 [Join] 、[Task.WaitAll])
[await Task.WhenAll(...)]
[Thread.Abort()] (已过时)、[BackgroundWorker.CancelAsync]
[CancellationTokenSource.Cancel()] 和 [CancellationToken]
[BackgroundWorker.ReportProgress] / [ProgressChanged]
[IProgress<T>.Report]
[BackgroundWorker.RunWorkerCompleted]
紧跟在 [await] 之后的代码
[BeginXxx] / [EndXxx] 和回调方法(APM)
[await XxxAsync(...)]
[Control.Invoke] 用于返回界面线程
[await],它会自动返回同步上下文
[BlockingCollection<T>] ([Add] / [GetConsumingEnumerable])
[Channel<T>] ([WriteAsync] / [ReadAllAsync])
[System.Threading.Timer]
[PeriodicTimer]

后续章节将应用这些规则:使用 ADO.NET(第 10 章)和 Entity Framework Core(第 11 章)进行异步数据库访问,异步多客户端 TCP 服务器和 [HttpClient] 客户端(第 12 章),ASP.NET Core Web 服务及其 [HttpClient] 客户端(第 13 章)。