1
// === 你写的 ===
2
async Task<int> FetchScoreAsync(string playerId)
3
{
4
    var player = await LoadPlayerAsync(playerId);   // 暂停点 1
5
    var stats = await LoadStatsAsync(player);         // 暂停点 2
6
    return stats.Score;
7
}
8

9
// === 编译器生成的（反编译简化） ===
10
[AsyncStateMachine(typeof(<FetchScoreAsync>d__0))]
11
Task<int> FetchScoreAsync(string playerId)
12
{
13
    var stateMachine = new <FetchScoreAsync>d__0();
14
    stateMachine.__this = this;
15
    stateMachine.playerId = playerId;
16
    stateMachine.__builder = AsyncTaskMethodBuilder<int>.Create();
17
    stateMachine.__state = -1;  // 初始状态
18
    stateMachine.__builder.Start(ref stateMachine);
19
    return stateMachine.__builder.Task;
20
}
21

22
struct <FetchScoreAsync>d__0 : IAsyncStateMachine
23
{
24
    public int __state;           // 状态机位置：-1=初始, 0=await1后, 1=await2后, -2=完成
25
    public AsyncTaskMethodBuilder<int> __builder;
26
    public string playerId;
27
    private Player __player;      // await 之间的局部变量变成字段！
28
    private Stats __stats;
29
    private TaskAwaiter<Player> __u1;  // 第一个 await 的等待器
30
    private TaskAwaiter<Stats> __u2;   // 第二个 await 的等待器
31

32
    public void MoveNext()
33
    {
34
        int result;
35
        try
36
        {
37
            switch (__state)
38
            {
39
                case 0:  // 从第一个 await 恢复
40
                    __state = -1;
41
                    __player = __u1.GetResult();       // 拿到 LoadPlayerAsync 的结果
42
                    __u2 = LoadStatsAsync(__player).GetAwaiter();  // 启动第二个异步操作
43
                    if (__u2.IsCompleted)
44
                        goto case 1;                   // 如果已完成，直接跳转
45
                    __state = 1;                       // 否则：标记状态，注册回调
46
                    __builder.AwaitUnsafeOnCompleted(ref __u2, ref this);
47
                    return;                            // 返回给调用方！
48

49
                case 1:  // 从第二个 await 恢复
50
                    __state = -1;
51
                    __stats = __u2.GetResult();
52
                    result = __stats.Score;
53
                    break;
54

55
                default:  // 首次进入
56
                    __u1 = LoadPlayerAsync(playerId).GetAwaiter();
57
                    if (__u1.IsCompleted)
58
                        goto case 0;
59
                    __state = 0;
60
                    __builder.AwaitUnsafeOnCompleted(ref __u1, ref this);
61
                    return;
62
            }
63
            __state = -2;
64
            __builder.SetResult(result);
65
        }
66
        catch (Exception ex)
67
        {
68
            __state = -2;
69
            __builder.SetException(ex);
70
        }
71
    }
72
}

1
// await 前后的线程由 SynchronizationContext.Current 决定
2
// 在 await 之前捕获 Current，在 await 之后通过它 Post 回原来的上下文
3

4
// 不同环境的 SynchronizationContext：
5
// 环境                   | SynchronizationContext.Current
6
// Console App            | null（默认线程池）
7
// WinForms / WPF         | WindowsFormsSynchronizationContext / DispatcherSynchronizationContext
8
//                         → Post 回到 UI 线程（Control.BeginInvoke / Dispatcher.BeginInvoke）
9
// ASP.NET Core           | null（无 SynchronizationContext）
10
// Unity                  | UnitySynchronizationContext
11
//                         → Post 回到主线程（通过 PlayerLoop 调度）
12

13
// 关键实验：
14
async Task TestContext()
15
{
16
    Console.WriteLine($"Before await: Thread {Thread.CurrentThread.ManagedThreadId}");
17
    // Unity: MainThread, WPF: UI Thread
18

19
    await Task.Delay(100);
20

21
    Console.WriteLine($"After await: Thread {Thread.CurrentThread.ManagedThreadId}");
22
    // 有 SynchronizationContext → 原线程
23
    // 没有 SynchronizationContext → 线程池线程（不一定是原来的）
24
}

1
// SynchronizationContext 的 Post 机制
2
// Unity 的 SynchronizationContext 大致等价于：
3
class UnitySynchronizationContext : SynchronizationContext
4
{
5
    public override void Post(SendOrPostCallback callback, object state)
6
    {
7
        // 把回调放入主线程的执行队列
8
        // 主线程在每一帧的 PlayerLoop 中处理这个队列
9
        MainThreadActions.Enqueue(() => callback(state));
10
    }
11
}
12

13
// 所以 await Task.Delay(100) 在 Unity 中的完整流程：
14
// 1. 主线程执行到 await，发现 Task.Delay(100) 未完成
15
// 2. 状态机挂起，捕获 SynchronizationContext.Current (= UnitySyncCtx)
16
// 3. 主线程继续执行游戏的 Update()，渲染帧
17
// 4. 100ms 后，Timer 回调在线程池触发
18
// 5. Task.Delay 的 Task 完成 → 触发 continuation
19
// 6. continuation 通过 UnitySyncCtx.Post() 被调度到主线程
20
// 7. 主线程在下一帧执行 continuation → 从 await 之后继续

1
// ConfigureAwait(false) 的含义：
2
// "恢复时不要回到原来的 SynchronizationContext，随便用线程池线程就行"
3

4
// 在服务器/库代码中，ConfigureAwait(false) 是最佳实践：
5
async Task<string> ReadFileAsync(string path)
6
{
7
    using var stream = File.OpenRead(path);
8
    var buffer = new byte[stream.Length];
9
    await stream.ReadAsync(buffer, 0, buffer.Length).ConfigureAwait(false);
10
    // ↑ 不回到原来的 SynchronizationContext，减少调度开销
11
    return Encoding.UTF8.GetString(buffer);
12
}
13

14
// ⚠️ 但在 Unity 中，下面这段代码是致命的：
15
async void LoadScene()
16
{
17
    var data = await LoadAssetAsync("scene.json").ConfigureAwait(false);
18
    //                                                  ^^^^^^^^^^^^^^^^
19
    // 之后的代码在线程池线程上执行！
20

21
    // ❌ Unity API 只能在主线程调用！
22
    GameObject.Instantiate(data.Prefab);  // → 崩溃或未定义行为
23
    SceneManager.LoadScene(data.SceneName);  // → 崩溃
24
}
25

26
// ✅ Unity 中永远不要用 ConfigureAwait(false)，除非你确定后面不调用 Unity API

1
// 状态机是 struct，以下情况触发装箱：
2
async Task<int> GetValueAsync()
3
{
4
    await Task.Delay(100);   // 未完成 → 需要挂起
5
    // ↑ 此时状态机被装箱到堆上（因为需要被回调持有）
6
    return 42;
7
}
8

9
async Task<int> GetCachedAsync()
10
{
11
    return 42;  // 同步完成 → 零装箱
12
}
13

14
// 热路径优化：如果你的异步方法经常同步完成
15
async ValueTask<int> GetValueOptimizedAsync()
16
{
17
    if (TryGetCached(out var value))
18
        return value;          // 同步路径：零装箱，零 Task 分配
19

20
    return await FetchAsync();  // 异步路径：ValueTask 包装
21
}
22
// ValueTask 是一个 struct 包装的"可能异步"结果
23
// 同步完成时：直接包含结果值，不分配 Task
24
// 异步完成时：包装一个 Task

1
// async void 的三个致命问题：
2
// 1. 调用方无法等待（没有 Task 可以 await）
3
// 2. 调用方无法捕获异常（异常直接抛到 SynchronizationContext 上，可能 crash 整个进程）
4
// 3. 无法知道何时完成（没有 Task 可以检查状态）
5

6
// ❌ 致命：
7
async void LoadScene()
8
{
9
    await LoadAssetsAsync();
10
    // 如果这里抛异常 → SynchronizationContext 直接收到 → 进程可能崩溃
11
}
12
LoadScene();  // 没有 Task 可以 await，不知道何时完成
13

14
// ✅ 正确：async Task
15
async Task LoadSceneAsync()
16
{
17
    await LoadAssetsAsync();
18
}
19
await LoadSceneAsync();  // 可以等待，可以 catch 异常
20

21
// ✅ async void 的唯一合法用途：UI 事件处理器
22
button.Click += async (sender, args) =>
23
{
24
    await LoadDataAsync();
25
    button.Text = "Done";
26
};
27
// 事件处理器的签名是 void，没办法返回 Task

1
// C# 的取消是"协作式"的——你请求取消，被取消的代码自己检查并响应
2
// 这不是 abort/terminate，不会强制终止线程
3

4
async Task LoadWithTimeout(string path, TimeSpan timeout)
5
{
6
    using var cts = new CancellationTokenSource(timeout);
7

8
    try
9
    {
10
        var data = await LoadAssetAsync(path, cts.Token);
11
        ProcessData(data);
12
    }
13
    catch (OperationCanceledException)
14
    {
15
        Console.WriteLine($"加载超时: {path}");
16
        // 清理半成品状态
17
    }
18
}
19

20
async Task<AssetData> LoadAssetAsync(string path, CancellationToken token)
21
{
22
    // 在每个可能长时间运行的操作前后检查取消
23
    token.ThrowIfCancellationRequested();
24

25
    var bytes = await File.ReadAllBytesAsync(path, token);
26
    // ↑ ReadAllBytesAsync 内部会检查 token
27

28
    token.ThrowIfCancellationRequested();
29
    return ParseAsset(bytes);
30
}

1
// 将 CancellationToken 传递给所有异步操作
2
async Task ProcessBatchAsync(IEnumerable<string> paths, CancellationToken token)
3
{
4
    foreach (var path in paths)
5
    {
6
        token.ThrowIfCancellationRequested();
7
        await ProcessFileAsync(path, token);
8
    }
9
}
10

11
// CancellationTokenSource 的三种创建方式：
12
var cts1 = new CancellationTokenSource(TimeSpan.FromSeconds(5));  // 超时取消
13
var cts2 = new CancellationTokenSource();
14
cts2.Cancel();  // 手动取消
15

16
// 组合取消源（任一取消即取消）
17
using var linked = CancellationTokenSource.CreateLinkedTokenSource(userToken, timeoutToken);

1
// 普通 IEnumerable 不适用于异步数据源
2
// IAsyncEnumerable 允许在每次 yield 之间 await
3

4
async IAsyncEnumerable<LogEntry> ReadLogsAsync(string filePath)
5
{
6
    using var reader = new StreamReader(filePath);
7
    while (!reader.EndOfStream)
8
    {
9
        var line = await reader.ReadLineAsync();  // 每次读取都是异步的
10
        yield return ParseLogEntry(line);          // 产出一条，不等待全部读完
11
    }
12
}
13

14
// 消费：await foreach
15
await foreach (var entry in ReadLogsAsync("server.log"))
16
{
17
    if (entry.Level == LogLevel.Error)
18
        Console.WriteLine(entry.Message);
19
    if (entry.Timestamp > cutoff)
20
        break;  // 提前终止 —— 后续行不会被读取
21
}
22

23
// 支持 CancellationToken
24
await foreach (var entry in ReadLogsAsync("server.log").WithCancellation(token))
25
{
26
    // ...
27
}

1
// ❌ 这段代码的异常你永远 catch 不到
2
try
3
{
4
    FireAndForget();  // async void！
5
}
6
catch (Exception)
7
{
8
    // 永远不会执行！async void 的异常不进入这个 catch
9
}
10

11
async void FireAndForget()
12
{
13
    await Task.Delay(100);
14
    throw new InvalidOperationException("Boom!");
15
    // 异常被 Post 到 SynchronizationContext → 在 Unity 中可能静默丢失
16
}

1
// ❌ 在有 SynchronizationContext 的环境中（WPF、Unity Editor），这会死锁
2
Task<int> task = FetchDataAsync();
3
int result = task.Result;  // 死锁！
4
//
5
// 死锁过程：
6
// 1. main 线程调用 task.Result → 阻塞等待 task 完成
7
// 2. FetchDataAsync 内部 await 完成后，需要 Post 到 main 线程继续执行
8
// 3. 但 main 线程在等 task 完成，不会处理 Post 的 continuation
9
// → 互相等待，死锁
10

11
// ✅ 方案一：一路 async 到底
12
int result = await FetchDataAsync();
13

14
// ✅ 方案二：确定不需要回到原上下文
15
int result = FetchDataAsync().GetAwaiter().GetResult();
16
// 仍然阻塞，但不会死锁？不，还是会死锁！
17
// 正确做法：在调用链内部用 ConfigureAwait(false)

1
// ❌ 编译器只给一个警告，异常无声无息
2
void Update()
3
{
4
    LoadAsync();  // ⚠️ CS4014: 因为没有 await，异步调用不会等待
5
    // LoadAsync 内部的异常会被静默丢弃（Task 被 GC 时 finalized）
6
}
7

8
// ✅ 如果确实不需要等待，至少要处理异常
9
async void Update()
10
{
11
    try
12
    {
13
        await LoadAsync();
14
    }
15
    catch (Exception ex)
16
    {
17
        Debug.LogError(ex);
18
    }
19
}

1
// Unity 中的场景异步加载
2
async Task LoadGameSceneAsync()
3
{
4
    // 显示加载界面
5
    loadingScreen.Show();
6

7
    // 异步加载场景（Unity 的 AsyncOperation 支持 await）
8
    var asyncLoad = SceneManager.LoadSceneAsync("GameLevel");
9
    asyncLoad.allowSceneActivation = false;  // 等待准备完成
10

11
    // 同时预加载资源
12
    var assetsTask = PreloadAssetsAsync();
13

14
    // 等待场景加载到 90%
15
    while (asyncLoad.progress < 0.9f)
16
    {
17
        loadingScreen.SetProgress(asyncLoad.progress);
18
        await Task.Yield();  // 让出这一帧，下一帧继续
19
    }
20

21
    // 等待资源加载完成
22
    await assetsTask;
23

24
    // 一切就绪，激活场景
25
    asyncLoad.allowSceneActivation = true;
26
    loadingScreen.Hide();
27
}

1
// 游戏中的网络请求：连接超时 + 用户取消
2
async Task<ServerList> FetchServerListAsync(CancellationToken userCancel)
3
{
4
    using var timeoutCts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
5
    using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(
6
        userCancel, timeoutCts.Token);
7

8
    try
9
    {
10
        using var client = new HttpClient();
11
        var response = await client.GetStringAsync(ServerListUrl, linkedCts.Token);
12
        return JsonSerializer.Deserialize<ServerList>(response);
13
    }
14
    catch (OperationCanceledException) when (timeoutCts.IsCancellationRequested)
15
    {
16
        // 超时：提示用户检查网络
17
        return ServerList.Empty;
18
    }
19
    catch (OperationCanceledException)
20
    {
21
        // 用户取消：静默返回
22
        return null;
23
    }
24
}

1
// 游戏启动时并行加载所有必需资源
2
async Task WarmupAsync()
3
{
4
    var tasks = new List<Task>
5
    {
6
        LoadTextureCacheAsync(),
7
        LoadAudioBankAsync("common.sound"),
8
        LoadConfigTablesAsync(),
9
        PrecompileShadersAsync()
10
    };
11

12
    // 等待所有任务完成（任一失败则全部取消）
13
    try
14
    {
15
        await Task.WhenAll(tasks);
16
        Debug.Log("预热完成");
17
    }
18
    catch (Exception ex)
19
    {
20
        Debug.LogError($"预热失败: {ex.Message}");
21
        // 优雅降级：用默认资源启动
22
    }
23
}