---
title: CSharp-05-异步编程
aliases:
  - C# 异步
  - async await
  - Task 与取消
tags:
  - 编程语言/CSharp
  - 类型/教程
created: 2026-10-11
updated: 2026-10-11
level: 进阶
prerequisites:
  - "[[CSharp-01-环境与基础语法]]"
  - "[[CSharp-02-面向对象]]"
  - "[[CSharp-04-委托事件与Lambda]]"
sources:
  - https://learn.microsoft.com/zh-cn/dotnet/csharp/asynchronous-programming/
  - https://learn.microsoft.com/zh-cn/dotnet/csharp/asynchronous-programming/task-asynchronous-programming-model
  - https://learn.microsoft.com/zh-cn/dotnet/csharp/asynchronous-programming/async-scenarios
  - https://learn.microsoft.com/zh-cn/dotnet/csharp/asynchronous-programming/async-return-types
  - https://learn.microsoft.com/zh-cn/dotnet/standard/asynchronous-programming-patterns/task-based-asynchronous-pattern-tap
  - https://learn.microsoft.com/zh-cn/dotnet/standard/threading/cancellation-in-managed-threads
  - https://learn.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.task.configureawait
  - https://learn.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.taskscheduler.unobservedtaskexception
  - https://learn.microsoft.com/zh-cn/dotnet/api/system.threading.semaphoreslim
  - https://learn.microsoft.com/zh-cn/dotnet/api/system.collections.generic.iasyncenumerable-1
  - https://learn.microsoft.com/zh-cn/dotnet/csharp/whats-new/tutorials/generate-consume-asynchronous-stream
  - https://devblogs.microsoft.com/dotnet/configureawait-faq/
---

# CSharp-05-异步编程

> [!abstract] 这篇讲什么
> 异步编程解决的核心问题不是"更快"，而是**在等待 IO 时不要占着线程**。一个线程约 1 MB 栈、一次上下文切换要几微秒，而一次数据库查询要几毫秒——阻塞式等待把这两者的量级差距变成了吞吐瓶颈。
> 本篇按"代价 → 抽象 → 机制 → 陷阱 → 组合 → 取消"推进，重点讲清四件事：**`Task` 是承诺而不是线程**、**死锁是怎么被 `.Result` 造出来的**、**未 await 的异常会被静默吞掉**、**`CancellationToken` 是协作式的**。
> 阅读前提：[[CSharp-04-委托事件与Lambda]]（`async void` 与事件处理器、Lambda 与闭包）。示例以 **.NET 10 / C# 14** 为基准。

---

## 一、是什么：从"阻塞等待"到"回调承诺"

同步代码在等待 IO 时，线程**什么也不做但也不让出**：

```csharp
// 同步版本：线程在这 200ms 内被完全占用，不能服务其他请求
public static string FetchSync()
{
    Thread.Sleep(200);                    // 模拟网络/磁盘等待
    return "data";
}
```

异步版本把"等待"这件事交给操作系统与运行时，线程立刻返回线程池去干别的活：

```csharp
public static async Task<string> FetchAsync()
{
    await Task.Delay(200);                // 线程被释放，200ms 后由续体继续
    return "data";
}
```

`Task<string>` 是一个**承诺（promise）**：现在还没有字符串，但将来会有，或者会失败，或者会被取消。它由三种终态之一结束：

$$
\text{Task 状态} \in \{\ \text{RanToCompletion},\ \text{Faulted},\ \text{Canceled}\ \}
$$

---

## 二、为什么需要它：同步阻塞的真实代价

### 2.1 线程是稀缺资源

| 资源 | 典型成本 |
|---|---|
| 一个托管线程的栈 | 约 1 MB 虚拟内存（默认提交量小得多） |
| 线程创建 | 数十到数百微秒 |
| 上下文切换 | 约 1–5 微秒，外加缓存失效 |
| 一次数据库查询 | 约 1–50 毫秒 |
| 一次跨机房 HTTP 调用 | 约 50–500 毫秒 |

一次 50ms 的数据库调用期间，如果线程被阻塞，它错过的可运行时间相当于**上万次上下文切换的量级**。

### 2.2 同步 vs 异步：数值对照

假设每个请求要等 3 次各 100ms 的 IO，CPU 计算总耗时约 1ms：

| 指标 | 同步阻塞 | 异步（async/await） |
|---|---|---|
| 单请求墙上时间 | 约 301 ms | 约 301 ms |
| 单请求占用线程时间 | 约 301 ms | 约 1 ms |
| 并发 1000 个请求所需线程 | 约 1000 个 | 约 1–几十个 |
| 内存（仅线程栈） | 约 1 GB 虚拟内存 | 约几十 MB |
| 线程池排队/饥饿风险 | 高（默认最小线程数增长很慢） | 低 |
| 单位时间吞吐 | 受线程数上限压制 | 受 IO 与下游容量限制 |

> [!important] 关键结论
> **异步不会让单个请求变快**，它提升的是**并发能力**与**资源利用率**。
> 如果你的场景是纯 CPU 计算（如矩阵乘法、图像压缩），异步毫无帮助——那需要的是并行（`Task.Run` + 多核），见下文 7.3。

### 2.3 为什么线程池的"增长慢"是致命的

.NET 线程池为每秒注入新线程的数量设了上限（典型值约每秒 1–2 个）。当 1000 个请求同时阻塞时，线程池不会瞬间给你 1000 个线程，于是新请求排队，延迟雪崩式上升——这就是**线程池饥饿（thread pool starvation）**。

---

## 三、`Task` 与 `Task<T>` 的本质

### 3.1 承诺，而不是线程

| 常见误解 | 事实 |
|---|---|
| `Task` 就是一根线程 | `Task` 是一个**状态机 + 续体列表**；`Task.Run` 才会用到线程池线程 |
| `await` 会新建线程 | `await` 通常**不创建任何线程**；完成时在线程池已有线程上继续 |
| `await` 会让当前线程阻塞 | `await` 让当前线程**返回**到调用方（或线程池） |
| 没有 `Task.Run` 就不算异步 | IO 型异步由操作系统 IOCP/epoll 驱动，本就无需线程 |

```csharp
// 这个 Task 完全没有线程参与：它只是把 Timer 包装成承诺
static async Task NoThreadExample()
{
    Console.WriteLine($"await 前，线程 {Environment.CurrentManagedThreadId}");
    await Task.Delay(50);
    Console.WriteLine($"await 后，线程 {Environment.CurrentManagedThreadId}");
    // 两行的线程号可能相同（续体被调度回同一线程池线程），也可能不同
}
```

### 3.2 `Task` 家族对照

| 类型 | 用途 | 是否有返回值 | 备注 |
|---|---|---|---|
| `Task` | 无返回值的异步操作 | 无 | 不能 `await` 两次（第二次仍会完成，但语义混乱） |
| `Task<T>` | 有返回值的异步操作 | 有 | 结果缓存在 `Result` 中，可多次读取 |
| `ValueTask` / `ValueTask<T>` | 常常同步完成的异步操作 | 可选 | 是 `struct`，避免分配；**只能 await 一次** |
| `TaskCompletionSource<T>` | 手工控制 Task 完成时机 | 有 | 把回调式 API 桥接成 Task |
| `IAsyncEnumerable<T>` | 异步流（多个值） | 多个值 | 用 `await foreach` 消费 |
| `Task.Yield()` | 主动让出 | 无 | 强制异步点，常用于 UI 让出 |

```csharp
// 把回调式（EAP）API 桥接为 Task —— TaskCompletionSource 的标准用法
public static Task<string> DownloadAsTaskAsync(string url)
{
    var tcs = new TaskCompletionSource<string>(
        TaskCreationOptions.RunContinuationsAsynchronously); // 防止续体同步执行导致栈增长

    var client = new HttpClient();
    client.GetAsync(url).ContinueWith(t =>
    {
        if (t.IsFaulted) tcs.TrySetException(t.Exception!.InnerExceptions);
        else if (t.IsCanceled) tcs.TrySetCanceled();
        else tcs.TrySetResult(t.Result.StatusCode.ToString());
        client.Dispose();
    }, TaskScheduler.Default);

    return tcs.Task;
}
```

> [!note] 为什么 `RunContinuationsAsynchronously` 几乎是必备项
> 默认情况下 `TrySetResult` 会**同步执行**所有等待者的续体。如果续体里有耗时或阻塞逻辑，`TrySetResult` 的调用点就被拖住了；更糟的是可能形成极深的同步调用链。加上这个选项后，续体改为投递到线程池执行。

### 3.3 三种返回类型：什么时候用哪个

| 返回类型 | 调用方可以 | 适用场景 | 反例 |
|---|---|---|---|
| `Task` | `await`、等待、组合 | 默认选择，无返回值 | — |
| `Task<T>` | `await` 取 `T` | 默认选择，有返回值 | — |
| `async void` | **什么都不能** | **仅**事件处理器 | 除了事件处理器一律禁止 |
| `ValueTask<T>` | `await`（**一次**） | 热路径且常同步完成 | 需要 `WhenAll`、需要缓存复用 |

---

## 四、`async`/`await` 的执行流程

### 4.1 编译器改写：状态机

`async` 方法被编译器改写为一个**状态机结构体**（实现 `IAsyncStateMachine`），它记录了"执行到哪一步"：

```csharp
public static async Task<int> ComputeAsync(int seed)
{
    int a = seed + 1;                 // 状态 0 之前：同步执行
    await Task.Delay(10);             // 状态 0：可能挂起
    int b = a * 2;                    // 状态 1：续体恢复后执行
    await Task.Delay(10);             // 状态 1：可能再次挂起
    return b + 3;                     // 状态 2：设置结果
}
```

改写后的形状（概念示意）：

```csharp
// 编译器实际生成的东西（极度简化）
private struct ComputeAsyncStateMachine : IAsyncStateMachine
{
    public int State;                       // -1 = 运行中，-2 = 已完成
    public AsyncTaskMethodBuilder<int> Builder;
    private int _seed, _a, _b;
    private TaskAwaiter _awaiter;

    public void MoveNext()
    {
        switch (State)
        {
            case 0: _a = _seed + 1; goto case 1;
            case 1:
                _awaiter = Task.Delay(10).GetAwaiter();
                if (!_awaiter.IsCompleted)          // 关键分支：没完成才真的"异步"
                {
                    State = 2;
                    Builder.AwaitUnsafeOnCompleted(ref _awaiter, ref this);
                    return;                          // ← 方法在此返回，线程被释放
                }
                goto case 2;
            case 2:
                _awaiter.GetResult();                // ← 异常在这一行抛出
                _b = _a * 2;
                // …再 await 一次
                Builder.SetResult(_b + 3);
                break;
        }
    }
}
```

这解释了四个常见现象：

1. **`async` 方法在第一个未完成的 `await` 之前是同步执行的**——调用方在这段时间内会被阻塞。
2. 已经完成的任务（如缓存命中）走 `IsCompleted == true` 分支，**全程无分配、无线程切换**。
3. 异常在 `GetResult()` 处抛出，所以 `try/catch` 要包在 `await` 外层，而不是包在方法调用外层。
4. 每次挂起都要分配状态机与续体（值类型状态机在首次挂起时被装箱到堆上）。

### 4.2 `await` 前后的线程切换

```csharp
static async Task ShowSwitching()
{
    Console.WriteLine($"调用线程: {Environment.CurrentManagedThreadId}");
    await Task.Delay(10);
    Console.WriteLine($"续体线程: {Environment.CurrentManagedThreadId}");
}
```

| 是否存在 `SynchronizationContext` / `TaskScheduler` | `await` 恢复位置 |
|---|---|
| 有（WPF/WinForms 的 UI 上下文、经典 ASP.NET） | **捕获**并投递回该上下文（保证回到 UI 线程） |
| 无（控制台、ASP.NET Core、`Task.Run` 内部） | 投递到线程池，**任意**可用线程 |
| 显式写了 `ConfigureAwait(false)` | 忽略上下文，直接用线程池 |

### 4.3 `SynchronizationContext` 的作用

`SynchronizationContext` 抽象了"把一段代码送回原环境执行"的能力：

```csharp
// WPF 里：Post 会通过 Dispatcher 把回调排到 UI 线程的消息队列
// 伪代码说明其行为，实际由框架提供实例
SynchronizationContext? ctx = SynchronizationContext.Current;
ctx?.Post(state => Console.WriteLine($"回到 UI 线程: {Environment.CurrentManagedThreadId}"),
          null);
```

| 环境 | `SynchronizationContext.Current` | 后果 |
|---|---|---|
| WPF / WinForms | 非 `null`（Dispatcher / WindowsForms 上下文） | 续体回到 UI 线程，**可以**直接更新控件 |
| 经典 ASP.NET（.NET Framework） | 非 `null`（`AspNetSynchronizationContext`） | 续体回到请求上下文；**`.Result` 会死锁** |
| ASP.NET Core | **`null`** | 续体在线程池任意线程；`.Result` 不会死锁但有线程饥饿风险 |
| 控制台 | `null` | 同上 |
| `Task.Run` 内部 | `null`（上下文不流动到线程池） | 同上 |

---

## 五、异常传播

### 5.1 `await` 与 `Wait()` 抛出的异常类型不同

```csharp
static async Task<int> AlwaysFailsAsync()
{
    await Task.Delay(1);
    throw new InvalidOperationException("业务失败");
}

// 路径 A：await —— 抛出原始异常，堆栈被"清洗"到 await 点
try
{
    await AlwaysFailsAsync();
}
catch (InvalidOperationException ex)
{
    Console.WriteLine($"await 捕获: {ex.GetType().Name}");   // InvalidOperationException
}

// 路径 B：.Result / .Wait() —— 包一层 AggregateException
Task<int> t = AlwaysFailsAsync();
try
{
    _ = t.Result;
}
catch (AggregateException agg)
{
    Console.WriteLine($"Result 捕获: {agg.GetType().Name}, 内层 {agg.InnerExceptions.Count} 个");
    Console.WriteLine($"内层类型: {agg.InnerException!.GetType().Name}");
}
```

| 等待方式 | 抛出的异常 | 内层异常访问 |
|---|---|---|
| `await task` | 原始异常（自动解包第一个） | 直接 `catch (InvalidOperationException)` |
| `task.Result` / `task.Wait()` | `AggregateException` | `agg.InnerExceptions` 或 `agg.Flatten()` |
| `task.GetAwaiter().GetResult()` | **原始异常**（与 `await` 一致） | 直接捕获 |

> [!important] `AggregateException` 的由来
> `Task` 设计于并行库（TPL）时代，一个任务可能派生多个子任务并**同时**失败，因此需要一个能承载多个异常的容器。
> 而 `await` 的语义是"把这一个任务的结果取出来"，所以它**解包并抛出第一个异常**。多个异常可以在 `Task.Exception.InnerExceptions` 里看到（`Task.WhenAll` 场景下尤其常见）。

### 5.2 多个异常：`Task.WhenAll` 的坑

```csharp
var tasks = new[]
{
    Task.FromException(new InvalidOperationException("A")),
    Task.FromException(new ArgumentException("B")),
    Task.FromException(new FormatException("C")),
};

// 关键：先把 WhenAll 的 Task 存下来，异常信息挂在"这一个" Task 上
Task all = Task.WhenAll(tasks);
try
{
    await all;
}
catch (Exception ex)
{
    Console.WriteLine($"await 只抛出第一个: {ex.GetType().Name}");   // InvalidOperationException

    // 想看全部异常，必须回到 WhenAll 返回的那个 Task 上取 Exception
    AggregateException agg = all.Exception!;
    Console.WriteLine($"真实异常总数: {agg.InnerExceptions.Count}"); // 3
    foreach (var inner in agg.Flatten().InnerExceptions)
        Console.WriteLine($"  - {inner.GetType().Name}: {inner.Message}");
}
```

### 5.3 未 await 的任务：异常被静默吞掉

```csharp
static void FireAndForget()
{
    // 没有 await，也没有保存 Task 引用 → 异常无人观察
    Task.Run(() => throw new InvalidOperationException("没人看得到我"));
}

FireAndForget();
Thread.Sleep(200);
Console.WriteLine("程序继续运行，异常没有让进程崩溃");
```

机制如下：

1. 任务异常被记录在 `Task.Exception` 上，状态变为 `Faulted`。
2. 如果这个 `Task` 从未被 `await`/`Wait`/读取 `Exception`，它就是**未观察的（unobserved）**。
3. 该任务被 GC 回收时，运行时触发 `TaskScheduler.UnobservedTaskException` 事件。
4. **.NET 4.5 起**，该事件若无人处理，**进程不会崩溃**（.NET 4.0 会终止进程）。这是一次为兼容性做的重大行为变更。

```csharp
// 全局兜底：把被吞掉的异常记录下来，至少能发现问题
TaskScheduler.UnobservedTaskException += (sender, e) =>
{
    Console.WriteLine($"[未观察的任务异常] {e.Exception.Flatten().InnerExceptions.Count} 个");
    foreach (var ex in e.Exception.Flatten().InnerExceptions)
        Console.WriteLine($"  - {ex.GetType().Name}: {ex.Message}");

    e.SetObserved();     // 标记为已观察，避免升级处理
};

GC.Collect();
GC.WaitForPendingFinalizers();   // 只有 GC 之后事件才会被触发
GC.Collect();
```

> [!warning] 不要用这个事件做业务兜底
> `UnobservedTaskException` 的触发时机**取决于 GC**，可能几秒后才来，也可能永远不来。
> 它只适合做"最后的观测网 + 日志告警"。真正的做法是：**永远不要丢弃返回的 `Task`**。

---

## 六、`async void` 的危害

```csharp
// 危险：调用方拿不到任何东西，无法 await、无法捕获
public static async void DangerousAsync()
{
    await Task.Delay(10);
    throw new InvalidOperationException("这个异常会直接跑到同步上下文上");
}

// 调用方以为包了 try/catch 就安全 —— 其实毫无作用
try
{
    DangerousAsync();     // 方法在第一个 await 处就返回了
}
catch (Exception)
{
    Console.WriteLine("永远不会执行到这里");
}
```

`async void` 的问题清单：

| 问题 | 后果 |
|---|---|
| 无法 `await` | 调用方无法知道它何时结束 |
| 无法组合 | 不能进 `Task.WhenAll` |
| 异常无法被调用方捕获 | 直接抛给 `SynchronizationContext`，在 UI 应用里通常**崩溃进程** |
| 无法取消 | 没有 `Task` 可传 `CancellationToken` |
| 难以测试 | 测试无法等待其完成 |

> [!important] 唯一合理用途：事件处理器
> 事件的签名被 `EventHandler` 固定为返回 `void`，所以只能用 `async void`。
> 即使如此，也应该在**方法内部**用 `try/catch` 包住整个方法体，绝不让异常逃逸：

```csharp
private async void OnSaveClicked(object? sender, EventArgs e)
{
    try
    {
        await SaveAsync();                 // 正常异步逻辑
    }
    catch (OperationCanceledException)
    {
        // 用户主动取消，不算错误
    }
    catch (Exception ex)
    {
        // async void 的异常若逃逸，在 UI 应用里会直接终止进程
        ShowError($"保存失败：{ex.Message}");
    }
}
```

如果需要从事件处理器启动一个可跟踪的后台任务，标准做法是"`async void` 只做入口，立即转交 `async Task`"：

```csharp
private void OnSaveClicked(object? sender, EventArgs e) => _ = RunSafelyAsync(SaveAsync());

private static async Task RunSafelyAsync(Task work)
{
    try { await work; }
    catch (Exception ex) { Console.WriteLine($"后台任务异常: {ex.Message}"); }
}
```

---

## 七、死锁：复现与讲解

### 7.1 UI 场景的经典死锁（完整可复现）

这是一个**真实的 WinForms 程序**，运行后界面会永久卡死：

```csharp
// 需要 <TargetFramework>net10.0-windows</TargetFramework> 与 UseWindowsForms=true
using System;
using System.Windows.Forms;

public sealed class DeadlockForm : Form
{
    private readonly Button _button = new() { Text = "点我会卡死", Dock = DockStyle.Fill };

    public DeadlockForm()
    {
        Controls.Add(_button);
        _button.Click += OnButtonClick;      // 事件处理器（唯一允许 async void 的地方）
    }

    // ★ 这就是问题所在：在 UI 线程上同步等待一个需要 UI 线程才能完成的异步操作
    private async void OnButtonClick(object? sender, EventArgs e)
    {
        _button.Text = "处理中……";
        string data = GetDataAsync().Result;  // ← 死锁发生在这行
        _button.Text = data;
    }

    private static async Task<string> GetDataAsync()
    {
        await Task.Delay(1000);               // 1 秒后需要"回到 UI 线程"才能继续
        return "完成";
    }

    [STAThread]
    public static void Main() => Application.Run(new DeadlockForm());
}
```

**死锁的四步链条**：

1. UI 线程执行到 `.Result`，**阻塞**等待 `GetDataAsync()` 完成。
2. `GetDataAsync` 内部 `await Task.Delay(1000)` 完成，续体被 `SynchronizationContext` **投递到 UI 线程的消息队列**。
3. 但 UI 线程正卡在 `.Result` 上，**没有在跑消息循环**，无法执行那个续体。
4. 续体不执行 → `Task` 永不完成 → `.Result` 永不返回。**互等，永久死锁。**

$$
\underbrace{\text{UI 线程}}_{\text{等 Task 完成}} \longleftrightarrow \underbrace{\text{Task 续体}}_{\text{等 UI 线程空闲}}
$$

在经典 ASP.NET（.NET Framework）里形状完全一样，只是把"UI 线程"换成"请求线程 + `AspNetSynchronizationContext`"。

> [!note] ASP.NET Core 为什么不会这样死锁
> ASP.NET Core **没有 `SynchronizationContext`**（`SynchronizationContext.Current` 为 `null`），续体直接投递到线程池，因此不依赖"请求线程空闲"。
> 但 `.Result` 仍然有害：它占住一根线程池线程，高并发下会触发**线程池饥饿**，表现为吞吐骤降、请求超时。**仍是反模式**。

### 7.2 三种解法

**解法一：一路 `async` 到底（首选）**

```csharp
private async void OnButtonClick(object? sender, EventArgs e)
{
    try
    {
        _button.Text = "处理中……";
        string data = await GetDataAsync();        // 不阻塞，让出 UI 线程
        _button.Text = data;
    }
    catch (Exception ex)
    {
        _button.Text = $"出错：{ex.Message}";
    }
}
```

**解法二：`ConfigureAwait(false)` 切断上下文（仅限库代码）**

```csharp
// 库内部不关心线程亲和性，用 ConfigureAwait(false) 避免"必须回到 UI 线程"
private static async Task<string> GetDataAsync()
{
    await Task.Delay(1000).ConfigureAwait(false);   // 续体在线程池执行
    return "完成";
}

// 现在下面这行"不会"死锁了 —— 但仍然不该这么写！
// string data = GetDataAsync().Result;
```

> [!warning] 解法二只是"绕过"死锁，不是"解决"问题
> `.Result` 依然阻塞线程，只是恰好不再需要 UI 线程了。一旦库内部**任何一处**漏写 `ConfigureAwait(false)`，死锁立刻回归。所以它不是可依赖的方案。

**解法三：把阻塞代码挪到线程池，再异步等待**

```csharp
private async void OnButtonClick(object? sender, EventArgs e)
{
    // Task.Run 把同步工作搬到线程池，UI 线程用 await 等待而不是阻塞
    string data = await Task.Run(() => LegacyBlockingCall());
    _button.Text = data;
}

private static string LegacyBlockingCall()
{
    // 这里可以放心用 .Result，因为运行在线程池线程上，没有 UI 上下文
    return GetDataAsync().ConfigureAwait(false).GetAwaiter().GetResult();
}
```

| 解法 | 是否根治 | 适用场景 | 代价 |
|---|---|---|---|
| 一路 async 到底 | **是** | 所有能改签名的代码 | 需要改调用链签名 |
| `ConfigureAwait(false)` | 否（缓解） | 类库内部 | 漏一处就复发 |
| `Task.Run` + await | 是（隔离） | 第三方同步 API 无法修改 | 多占一根线程池线程 |
| `GetAwaiter().GetResult()` | 否 | 极端场景（`Main` 方法、测试夹具） | 仍阻塞，只是异常不被包装 |

---

## 八、`ConfigureAwait(false)` 的作用与时机

```csharp
// 有上下文时：await 默认捕获并回到原上下文
await DoIoAsync();                        // 等价于 ConfigureAwait(true)

// 无上下文需求时：明确表示"我不在乎在哪个线程继续"
await DoIoAsync().ConfigureAwait(false);
```

| 使用位置 | 建议 | 理由 |
|---|---|---|
| **类库 / NuGet 包** | 每个 `await` 都加 `ConfigureAwait(false)` | 不假设宿主环境，避免上下文切换开销与死锁风险 |
| 应用层（UI 事件处理器） | **不加** | 下一行要更新控件，需要回到 UI 线程 |
| ASP.NET Core 控制器 | 可加可不加 | 没有 `SynchronizationContext`，加上可省一点开销 |
| `await foreach` / `await using` | 用 `.ConfigureAwait(false)` 扩展形式 | 需要在 `foreach`/`using` 上加 |

> [!important] 两条经验法则
> 1. **库代码一律 `ConfigureAwait(false)`**：它让库"对宿主上下文无感"，这是微软官方 FAQ 的核心建议。
> 2. **加了 `ConfigureAwait(false)` 之后，其后的代码可能运行在线程池线程上**，因此**不要**再访问 UI 控件、`HttpContext`（经典 ASP.NET）、`DbContext` 等有线程亲和性或作用域要求的对象。

---

## 九、并发组合

### 9.1 `Task.WhenAll` / `Task.WhenAny`

```csharp
static async Task<string> FetchAsync(string name, int ms)
{
    await Task.Delay(ms);
    return $"{name}({ms}ms)";
}

// 顺序 await：总耗时 = 各任务之和
var sw = System.Diagnostics.Stopwatch.StartNew();
await FetchAsync("A", 300);
await FetchAsync("B", 300);
Console.WriteLine($"顺序: {sw.ElapsedMilliseconds} ms");     // 约 600 ms

// WhenAll：并发启动，总耗时 = 最慢的那个
sw.Restart();
Task<string> ta = FetchAsync("A", 300);
Task<string> tb = FetchAsync("B", 300);
string[] results = await Task.WhenAll(ta, tb);               // 关键：先拿到 Task 再 await
Console.WriteLine($"并发: {sw.ElapsedMilliseconds} ms → {string.Join(",", results)}"); // 约 300 ms

// WhenAny：谁先完成用谁，典型用途是"超时"
sw.Restart();
Task<string> fast = FetchAsync("慢", 5000);
Task timeout = Task.Delay(300);
Task winner = await Task.WhenAny(fast, timeout);
if (winner == timeout)
    Console.WriteLine("超时了，不再等待");
else
    Console.WriteLine($"结果: {await fast}");
```

> [!warning] 循环里逐个 await 是隐形的性能杀手
> ```csharp
> // 错误：总耗时 = 所有请求之和
> foreach (var url in urls) results.Add(await FetchAsync(url));
> ```
> 正确做法是先把所有任务启动起来，再统一等待：
> ```csharp
> // 正确：总耗时 ≈ 最慢的那个
> Task<string>[] tasks = urls.Select(u => FetchAsync(u)).ToArray();
> string[] all = await Task.WhenAll(tasks);
> ```
> **注意**：只有当你确实要"并发"时才这样写。如果下游服务承受不了并发压力，逐个 await 反而是正确的（顺序限流）。

### 9.2 `Task.Delay` 与 `Thread.Sleep` 的区别

| 对比项 | `Thread.Sleep(1000)` | `await Task.Delay(1000)` |
|---|---|---|
| 线程占用 | **阻塞**当前线程 1 秒 | 释放线程，1 秒后调度续体 |
| 可取消 | 不能 | `Task.Delay(1000, ct)` |
| 适用位置 | 同步代码、测试、后台线程 | 异步代码（几乎总是选它） |
| 精度 | 与系统时钟相关（约 15.6 ms 粒度） | 同上 |
| 在 UI 线程上使用 | **冻结界面** | 界面正常响应 |
| 大量并发使用 | 线程池饥饿 | 一个定时器即可支撑成千上万个 |

### 9.3 `Task.Run` 的适用边界

| 工作负载 | 该怎么做 | 为什么 |
|---|---|---|
| IO 密集（HTTP、数据库、文件） | **直接用异步 API**，不要 `Task.Run` | 异步 API 内部用 IOCP，无需线程；`Task.Run` 白白多占一根线程池线程 |
| CPU 密集（计算、压缩、加密） | `await Task.Run(() => Compute())` | 计算必须占 CPU，搬到线程池可让 UI 保持响应 |
| 已有同步 API，无异步版本 | `await Task.Run(() => LegacySync())` | 隔离阻塞，是权宜之计 |
| ASP.NET Core 服务器端 | **不要** `Task.Run` 包 IO 操作 | 服务器已在线程池上，多一次切换只增加开销 |

```csharp
// 反例：服务器端的无意义 Task.Run
public async Task<IActionResult> GetBad()
{
    // Task.Run 只是把同一份工作从一根线程池线程搬到另一根
    var data = await Task.Run(() => _httpClient.GetStringAsync("https://example.com"));
    return Ok(data);
}

// 正例：直接 await
public async Task<IActionResult> GetGood()
{
    var data = await _httpClient.GetStringAsync("https://example.com");
    return Ok(data);
}
```

---

## 十、`CancellationToken` 协作式取消

`CancellationToken` **不是**强制中断：它只是一个信号。被调用方必须**主动检查**并自行退出，这就是"协作式"的含义。

```csharp
using System;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;

public static class CancellationDemo
{
    public static async Task RunAsync()
    {
        // 1) 3 秒后自动取消 —— 也可用 CancelAfter 之外的 Cancel()/CancelAsync()
        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(3));
        CancellationToken token = cts.Token;

        try
        {
            string result = await DownloadAsync("https://example.com", token);
            Console.WriteLine($"成功：{result.Length} 字符");
        }
        catch (OperationCanceledException ex) when (ex.CancellationToken == token)
        {
            // 区分"我方取消"与"网络异常"，when 过滤是关键
            Console.WriteLine("已按预期取消");
        }
    }

    private static async Task<string> DownloadAsync(string url, CancellationToken ct)
    {
        using var client = new HttpClient();

        // 2) 把 token 一路传下去：HttpClient 内部会监听它并中断 IO
        string text = await client.GetStringAsync(url, ct).ConfigureAwait(false);

        // 3) 纯 CPU 的循环必须手工检查，否则永远无法取消
        int count = 0;
        foreach (char c in text)
        {
            ct.ThrowIfCancellationRequested();   // 抛 OperationCanceledException
            if (c == 'a') count++;
        }

        // 4) 也可以在"返回成功值"与"取消"之间做选择
        if (count == 0)
            ct.ThrowIfCancellationRequested();   // 幂等：未取消时不抛

        return $"字符 a 出现 {count} 次";
    }
}
```

| API | 用途 |
|---|---|
| `CancellationTokenSource.Cancel()` | 立即请求取消（同步，会就地执行已注册的回调） |
| `CancellationTokenSource.CancelAfter(ms / TimeSpan)` | 到期自动取消 |
| `CancellationTokenSource.CancelAsync()` | 请求取消并等待回调完成（.NET 8+） |
| `token.IsCancellationRequested` | 查询状态，用于"能优雅收尾"的场景 |
| `token.ThrowIfCancellationRequested()` | 抛 `OperationCanceledException`，最简单 |
| `token.Register(callback)` | 注册清理回调（如关闭连接、释放资源） |
| `Task.Delay(ms, token)` | 可取消的延时 |
| `Task.WaitAsync(token)` | 给任意任务加一层超时/取消（.NET 6+） |

> [!warning] 取消相关的三个易错点
> 1. **不要吞掉 `OperationCanceledException` 后返回默认值**——调用方会以为操作成功完成，得到一份空数据。让异常继续传播。
> 2. **`TaskCanceledException` 是 `OperationCanceledException` 的子类**。`catch (OperationCanceledException)` 会同时捕获两者；`TaskCanceledException` 常见于 `HttpClient` 超时。
> 3. **`CancellationTokenSource` 必须 `Dispose`**（用 `using`）。它内部注册了定时器与回调链，不释放会造成泄漏。

---

## 十一、`IAsyncEnumerable<T>` 与 `await foreach`

普通 `Task<T>` 只能返回**一个**结果；异步流可以边产生边消费，避免把所有结果先攒进内存：

```csharp
// 生产者：每 200ms 产出一个数字，3 个后结束
public static async IAsyncEnumerable<int> ProduceAsync(
    [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken ct = default)
{
    for (int i = 1; i <= 3; i++)
    {
        await Task.Delay(200, ct).ConfigureAwait(false);
        yield return i * 10;               // yield return 出现在 async 方法里
    }
}

// 消费者
public static async Task ConsumeAsync()
{
    await foreach (int value in ProduceAsync().WithCancellation(CancellationToken.None))
    {
        Console.WriteLine($"收到 {value}");  // 每 200ms 打印一次，无需先攒满
    }
}

// LINQ 风格：需要 System.Linq.Async 包（Microsoft 官方扩展）
// await foreach (int v in ProduceAsync().WhereAwait(...).ConfigureAwait(false)) { }
```

| 对比项 | `IEnumerable<T>` | `IAsyncEnumerable<T>` |
|---|---|---|
| 消费语法 | `foreach` | `await foreach` |
| 每次取值的代价 | 同步，可阻塞 | 异步，`ValueTask<bool> MoveNextAsync()` |
| 取消支持 | 无内建 | 可传 `CancellationToken` |
| 适用场景 | 内存集合、文件逐行读 | 数据库流式查询、分页拉取、实时推送 |
| EF Core 支持 | `ToListAsync` 一次性 | `AsAsyncEnumerable()` 流式读取 |

> [!tip] 什么时候值得用异步流
> 数据量大到不想一次性全部加载（如导出百万行）、或者结果是"随时间陆续到达"的（如订阅推送、日志跟随）。
> 数据只有几十条时，`Task<List<T>>` 更简单也更快——异步流每次 `MoveNextAsync` 都有状态机开销。

---

## 十二、`SemaphoreSlim` 限制并发数

`Task.WhenAll` 会把所有任务同时启动，几百个请求可能压垮下游。`SemaphoreSlim` 是异步友好的限流原语：

```csharp
public static async Task LimitConcurrencyAsync(IEnumerable<string> urls)
{
    // 最多 4 个并发；注意 SemaphoreSlim 实现了 IDisposable
    using var gate = new SemaphoreSlim(initialCount: 4, maxCount: 4);
    using var client = new HttpClient();

    var tasks = urls.Select(async url =>
    {
        await gate.WaitAsync().ConfigureAwait(false);   // 用 WaitAsync 而非 Wait！
        try
        {
            string body = await client.GetStringAsync(url).ConfigureAwait(false);
            Console.WriteLine($"{url} → {body.Length} 字符");
        }
        finally
        {
            gate.Release();          // 必须放在 finally，异常也要归还许可
        }
    });

    await Task.WhenAll(tasks);
}
```

> [!warning] 三个细节
> 1. 一定要用 **`WaitAsync()`**。用同步的 `Wait()` 会阻塞线程池线程，把限流变成新的阻塞源。
> 2. `Release()` 必须在 `finally` 里，否则一次异常就永久泄漏一个许可，最终整个流程僵死。
> 3. `SemaphoreSlim` 有 `Dispose`；长期存活的对象应被释放，短命对象用 `using`。
>
> 另外，如果只是想限制**并行度**而不是"资源的许可"，.NET 6+ 还有更简洁的 `Parallel.ForEachAsync`：
> ```csharp
> using var sharedClient = new HttpClient();     // 复用连接，避免端口耗尽
> await Parallel.ForEachAsync(urls, new ParallelOptions { MaxDegreeOfParallelism = 4 },
>     async (url, ct) =>
>     {
>         // 注意：把 HttpClient.GetStringAsync 的字符串重载赋给显式类型的委托，
>         // 否则与 GetStringAsync(HttpRequestMessage, ...) 重载产生歧义（CS0121）
>         Func<string, CancellationToken, Task<string>> fetch = sharedClient.GetStringAsync;
>         string body = await fetch(url, ct);
>         Console.WriteLine($"{url} → {body.Length} 字符");
>     });
> ```
> `Parallel.ForEachAsync` 在**首个异常**发生时会取消其余尚未开始的任务，这与 `Task.WhenAll` 的"等全部结束"语义不同。

---

## 十三、`ValueTask` 简介

`ValueTask<T>` 是**值类型**的 Task，避免"结果已经同步就绪"时的堆分配：

```csharp
private static readonly Dictionary<int, string> Cache = new();

// 缓存命中时同步完成，不分配 Task 对象
public static ValueTask<string> GetCachedAsync(int id)
{
    if (Cache.TryGetValue(id, out string? cached))
        return new ValueTask<string>(cached);              // 零分配路径

    return new ValueTask<string>(LoadSlowAsync(id));        // 未命中才包装 Task
}

private static async Task<string> LoadSlowAsync(int id)
{
    await Task.Delay(100);
    string value = $"value-{id}";
    Cache[id] = value;
    return value;
}
```

| 对比项 | `Task<T>` | `ValueTask<T>` |
|---|---|---|
| 类型 | 引用类型（class） | 值类型（struct） |
| 同步完成路径 | 需分配/复用缓存 Task | **零分配** |
| 可否 await 多次 | 可以 | **不可以**（未定义行为） |
| 可否 `WhenAll` / 缓存 | 可以 | 不可以 |
| `Result` 属性 | 有（阻塞） | 有（未完成则抛异常） |
| 适用场景 | 默认选择 | 高频调用且**多数同步完成**的热路径 |
| 正确用法 | 随意 | 只 `await` 一次，不保存、不共享 |

> [!danger] `ValueTask` 的误用后果
> ```csharp
> ValueTask<int> vt = GetValueAsync();
> int a = await vt;
> int b = await vt;          // ✗ 未定义行为：可能抛异常、可能得到错误结果
>
> Task<int> t = GetValueAsync().AsTask();   // 若确实需要复用，先转成 Task（会有分配）
> ```
> 经验法则：**除非你能用基准测试证明 `Task` 的分配是瓶颈，否则一律用 `Task`**。

---

## 十四、异步反模式清单

| 反模式 | 为什么错 | 正确做法 |
|---|---|---|
| `.Result` / `.Wait()` | 阻塞线程；有上下文时**死锁**；异常被包成 `AggregateException` | 一路 `async` 到底 |
| `async void` | 异常无法捕获，可能崩溃进程；无法等待 | 返回 `Task`；只有事件处理器例外 |
| 不传 `CancellationToken` | 用户关页面/请求超时后，后台仍白干活到结束 | 每个异步 API 都接收并向下传递 token |
| 循环里逐个 `await` | 总耗时是所有请求之和 | 先启动全部任务，再 `Task.WhenAll` |
| `Task.Run` 包 IO | 白白多占一根线程池线程 | 直接用异步 IO API |
| `Task.Run` 包 `async` Lambda 的两层包装 | `Task.Run(async () => await X())` 在服务器端冗余 | 去掉 `Task.Run` |
| `catch (Exception) { }` 吞掉取消异常 | 调用方以为成功，拿到空结果 | 让 `OperationCanceledException` 传播 |
| 库代码不写 `ConfigureAwait(false)` | 宿主上下文切换开销 + 潜在死锁 | 库内每个 `await` 都加 |
| `Task.Delay` 代替真正的异步 | 只是假装异步，业务逻辑还是同步的 | 用真正可 await 的 IO API |
| 忘记 `Dispose` 的 `CancellationTokenSource` / `SemaphoreSlim` | 定时器与回调链泄漏 | `using` |
| 在 `finally` 之外 `Release()` | 一次异常就泄漏许可 | 放 `finally` |
| 用 `Thread.Sleep` 在异步方法里 | 阻塞线程池线程 | `await Task.Delay` |

---

## 十五、常见坑

> [!warning] 坑 1：`async` 方法在第一个 `await` 之前是同步的
> 如果 `await` 前的代码耗时很长（比如同步读了一个大文件），调用方会被阻塞。应当在方法入口就 `await Task.Yield()` 或把同步部分拆出去。

> [!warning] 坑 2：`using` 包在 `await` 外层并不能延长对象寿命
> ```csharp
> // 危险：using 在方法返回时就 Dispose 了，但后台任务还在用它
> public Task<string> Bad()
> {
>     using var client = new HttpClient();
>     return client.GetStringAsync("https://example.com");   // 返回的 Task 还在跑
> }
> ```
> 正确写法是把 `using` 与 `await` 放在同一个方法体内，或者使用 `IAsyncDisposable` + `await using`。

> [!warning] 坑 3：`Task.WhenAll` 在任一任务失败时行为
> `WhenAll` 会等到**所有**任务结束才抛异常，抛的是**第一个**异常。如果你希望"任一失败立刻放弃"，用 `Task.WhenAny` + 手工检查，或 `Parallel.ForEachAsync`（它在首个异常时会取消其余任务）。

> [!warning] 坑 4：`ConfigureAwait(false)` 之后的代码不能碰 UI
> 加了它之后，续体可能跑在线程池线程上，此时访问控件会抛 `InvalidOperationException: 线程间操作无效`。

> [!warning] 坑 5：`CancellationToken` 的默认值陷阱
> `default(CancellationToken)` 是 `CancellationToken.None`，永远不会取消、也无法取消。可选参数写成 `CancellationToken ct = default` 时，调用方忘记传就永远无法取消——设计 API 时最好**要求必传**。

> [!warning] 坑 6：静态 `CancellationTokenSource` 被取消后无法重用
> `CancellationTokenSource` 一旦取消就**永久处于已取消状态**。需要重复使用的场景应每次新建（或使用 .NET 8+ 的对象池模式），不要缓存一个用过的实例。

> [!warning] 坑 7：`async` Lambda 传给 `Action` 会变成 `async void`
> ```csharp
> list.ForEach(async x => await ProcessAsync(x));   // 实际是 async void！无法等待
> ```
> 想并发处理应显式收集任务：`await Task.WhenAll(list.Select(x => ProcessAsync(x)));`

---

## 十六、练习题

> [!question] 练习 1（Task 的本质）
> 解释下面两段代码的差异，并说明哪一段更能体现"`Task` 不是线程"。
> ```csharp
> Task a = Task.Run(() => Thread.Sleep(1000));
> Task b = Task.Delay(1000);
> ```

> [!question] 练习 2（异常传播）
> 给定 `Task<int> t = FaultyAsync();`，分别写出用 `t.Result`、`await t`、`t.GetAwaiter().GetResult()` 捕获异常时的 `catch` 类型，并解释差异来源。

> [!question] 练习 3（死锁分析）
> 下面代码在 WPF 里会死锁，在 ASP.NET Core 里不会。请分别说明原因，并给出两种修法（一种根治、一种缓解）。
> ```csharp
> public string Get() => LoadAsync().Result;
> private async Task<string> LoadAsync()
> {
>     await Task.Delay(100);
>     return "ok";
> }
> ```

> [!question] 练习 4（并发组合）
> 有 10 个 URL 要抓取，要求：(a) 总耗时尽量短；(b) 任意时刻最多 3 个并发请求；(c) 支持整体取消；(d) 单个失败不影响其他。
> 请写出完整实现，并说明为什么不能用 `foreach + await`，也不能无限并发。

> [!question] 练习 5（取消语义）
> 你写了一个 `ReadAllAsync(stream, ct)`。请说明：当 `ct` 在读取中途被触发时，这个方法应该抛什么异常？为什么不能"返回 null 表示取消"？调用方应如何区分"用户取消"和"真正的错误"？

> [!question] 练习 6（ValueTask 选型）
> 一个 `ICache.GetAsync(string key)` 接口：95% 的调用命中内存缓存并同步返回。请说明是否应该返回 `ValueTask<T>`，并列出使用 `ValueTask<T>` 时必须遵守的三条纪律。

---

## 十七、FAQ

> [!question] FAQ 1：`await Task.Run(...)` 和直接 `await SomeAsync()` 有什么区别？
> `SomeAsync()` 是**本来就是异步**的操作（IO 由操作系统完成，不需要线程）；`Task.Run` 是**把同步工作搬到线程池**执行。
> IO 密集型操作套 `Task.Run` 只会多消耗一根线程池线程，纯属浪费；CPU 密集型操作才需要 `Task.Run`。

> [!question] FAQ 2：`Task.Delay(0)` 有什么用？
> `Task.Delay(0)` 返回一个**已完成的 Task**，用它 `await` 几乎不产生异步切换（走 `IsCompleted == true` 分支）。
> 想真正强制让出控制权，应该用 `await Task.Yield()`。想给 UI 一个重绘机会，两者都可，但 `Task.Yield` 语义更准确。

> [!question] FAQ 3：为什么我的异步方法测试不稳定？
> 常见原因有三个：
> 1. 被测代码是 `async void`，测试无法等待；
> 2. 测试方法本身是 `async void` 而不是 `async Task`（xUnit/NUnit 需要后者）；
> 3. 用了 `Task.Delay` 做"等待"而不是等待真正的完成信号。
>
> 另外，**几乎不要用 `Thread.Sleep` 做测试等待**，它会让测试既慢又不稳。

> [!question] FAQ 4：`SynchronizationContext` 和 `TaskScheduler` 是一回事吗？
> 不是。`SynchronizationContext` 是更早的、更通用的"环境抽象"（UI 消息循环）；`TaskScheduler` 是 TPL 的调度抽象。
> `await` 优先使用 `SynchronizationContext.Current`，为 `null` 时退化到 `TaskScheduler.Current`，两者都为 `null` 时才用线程池。

> [!question] FAQ 5：在 `Main` 方法里怎么调用异步代码？
> C# 7.1+ 支持 `static async Task Main()`，直接写就行。若无法改签名，用 `SomeAsync().GetAwaiter().GetResult()`——它至少不会把异常包成 `AggregateException`。

> [!question] FAQ 6：异步方法一定比同步快吗？
> **不。** 单次调用上，异步有状态机与调度开销，可能比同步**更慢**。
> 收益出现在**并发**场景：异步让同样的线程数服务更多请求。只有一两个并发操作、或者纯粹 CPU 计算时，异步没有优势。

---

## 十八、小结

| 你要做的事 | 正确写法 |
|---|---|
| 等待 IO | `await SomeIoAsync(ct)`，不加 `Task.Run` |
| 并行等待多个任务 | 先启动全部，再 `await Task.WhenAll(tasks)` |
| 只要最快的一个 | `await Task.WhenAny(...)`，注意处理剩下的任务 |
| 执行 CPU 密集计算 | `await Task.Run(() => Compute())` |
| 支持取消 | 一路传 `CancellationToken`，循环内 `ThrowIfCancellationRequested()` |
| 限制并发 | `SemaphoreSlim.WaitAsync()` + `finally` 中 `Release()` |
| 流式返回大量结果 | `IAsyncEnumerable<T>` + `await foreach` |
| 写类库 | 每个 `await` 加 `ConfigureAwait(false)` |
| 事件处理器 | `async void` + 方法体内完整 `try/catch` |
| 兜底观测丢失的异常 | `TaskScheduler.UnobservedTaskException` + 日志 |

---

## 相关笔记

- [[CSharp-04-委托事件与Lambda]] —— `async void` 与事件处理器的关系、`TaskCompletionSource` 如何桥接回调式 API
- [[CSharp-03-集合与LINQ]] —— `IAsyncEnumerable<T>` 与 `IEnumerable<T>` 的对照、EF Core 的异步查询
- [[操作系统]] —— 线程、上下文切换、线程池与 IO 多路复用的底层原理
- [[后端-03-ASPNET-Core]] —— ASP.NET Core 为何没有 `SynchronizationContext`，以及请求管线中的异步实践
- [[JavaScript-04-异步编程]] —— 事件循环与 Promise：与 C# 的 `Task` 模型对照阅读

## 参考来源

- [使用 async 和 await 进行异步编程（Microsoft Learn，中文）](https://learn.microsoft.com/zh-cn/dotnet/csharp/asynchronous-programming/)
- [基于任务的异步模式（TAP）（Microsoft Learn，中文）](https://learn.microsoft.com/zh-cn/dotnet/standard/asynchronous-programming-patterns/task-based-asynchronous-pattern-tap)
- [异步编程方案（Microsoft Learn，中文）](https://learn.microsoft.com/zh-cn/dotnet/csharp/asynchronous-programming/async-scenarios)
- [异步返回类型（Microsoft Learn，中文）](https://learn.microsoft.com/zh-cn/dotnet/csharp/asynchronous-programming/async-return-types)
- [取消托管线程中的操作（Microsoft Learn，中文）](https://learn.microsoft.com/zh-cn/dotnet/standard/threading/cancellation-in-managed-threads)
- [Task.ConfigureAwait 方法（Microsoft Learn，中文）](https://learn.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.task.configureawait)
- [TaskScheduler.UnobservedTaskException 事件（Microsoft Learn，中文）](https://learn.microsoft.com/zh-cn/dotnet/api/system.threading.tasks.taskscheduler.unobservedtaskexception)
- [SemaphoreSlim 类（Microsoft Learn，中文）](https://learn.microsoft.com/zh-cn/dotnet/api/system.threading.semaphoreslim)
- [IAsyncEnumerable&lt;T&gt; 接口（Microsoft Learn，中文）](https://learn.microsoft.com/zh-cn/dotnet/api/system.collections.generic.iasyncenumerable-1)
- [生成和使用异步流（Microsoft Learn，中文）](https://learn.microsoft.com/zh-cn/dotnet/csharp/whats-new/tutorials/generate-consume-asynchronous-stream)
- [在完成时处理多个异步任务（Microsoft Learn，中文）](https://learn.microsoft.com/zh-cn/dotnet/csharp/programming-guide/concepts/async/start-multiple-async-tasks-and-process-them-as-they-complete)
- [按时间跨度取消异步任务（Microsoft Learn，中文）](https://learn.microsoft.com/zh-cn/dotnet/csharp/programming-guide/concepts/async/cancel-async-tasks-after-a-period-of-time)
- [ConfigureAwait 常见问题（.NET 博客）](https://devblogs.microsoft.com/dotnet/configureawait-faq/)
- [.NET 5 中的 ValueTask 池化（.NET 博客）](https://devblogs.microsoft.com/dotnet/async-valuetask-pooling-in-net-5/)
