C# 迭代器与 async/await 原理:编译器生成的状态机

2337 字
12 分钟
C# 迭代器与 async/await 原理:编译器生成的状态机

本文只讲 C# 语言层面的原理。在 Unity 中如何使用协程、Task、UniTask,见 Unity 异步编程。

一、共同的核心:状态机#

yield return 和 await 有一个共同的能力:方法执行到一半,可以暂停,之后从暂停的地方继续。

普通方法做不到这一点:方法返回后,栈帧就销毁了,局部变量也没了。C# 编译器的做法是,把这类方法改写成一个状态机对象:

  • 局部变量变成对象的字段,所以暂停后依然保存着。
  • 用一个 state 字段记录执行到了哪一步。
  • 方法体被拆成若干段,放进一个 MoveNext() 方法里,根据 state 跳到对应的段继续执行。

理解了这一点,迭代器和 async 的原理就都清楚了。

二、迭代器:yield return#

写法#

IEnumerator<int> Count()
{
Console.WriteLine("开始");
yield return 1;
Console.WriteLine("继续");
yield return 2;
Console.WriteLine("结束");
}

编译后(简化)#

IEnumerator<int> Count() => new CountStateMachine(); // 调用时只是创建对象,一行代码都不执行
sealed class CountStateMachine : IEnumerator<int>
{
int _state = 0;
int _current;
public int Current => _current;
public bool MoveNext()
{
switch (_state)
{
case 0:
Console.WriteLine("开始");
_current = 1; _state = 1;
return true; // 第一次 yield,暂停
case 1:
Console.WriteLine("继续");
_current = 2; _state = 2;
return true; // 第二次 yield,暂停
case 2:
Console.WriteLine("结束");
_state = -1;
return false; // 结束
}
return false;
}
// Reset、Dispose 省略
}

几个关键点:

  • 延迟执行:调用 Count() 时只是创建了状态机对象,方法体中的代码一行都没执行。直到第一次调用 MoveNext() 才开始执行。
  • 由调用方驱动:每调用一次 MoveNext(),就执行到下一个 yield return 并暂停,Current 就是 yield 出来的值。foreach 本质上就是不断调用 MoveNext()。
  • 状态机是一个类:每次调用迭代器方法都会在堆上分配一个对象。
  • 局部变量、参数、this 都会被保存为状态机的字段。

返回 IEnumerable<T> 的迭代器方法也是类似的,生成的类同时实现 IEnumerable<T> 和 IEnumerator<T>。

Unity 协程就是迭代器#

Unity 的协程方法返回 IEnumerator,StartCoroutine 拿到这个状态机对象后,由 Unity 每帧根据情况调用它的 MoveNext(),并根据 Current(yield 出来的 null、WaitForSeconds 等)决定什么时候再调用下一次。所以协程不是线程,也不是 C# 的语言特性,而是 Unity 利用迭代器实现的调度机制。

限制#

  • yield return 不能放在带 catch 的 try 块中,也不能放在 finally 块中。这导致协程中很难对跨越 yield 的代码做异常处理。
  • 迭代器方法的参数不能是 ref、out、in(原因见 参数修饰符)。

三、async / await#

写法#

async Task<int> LoadAsync()
{
Console.WriteLine("开始");
string text = await File.ReadAllTextAsync("a.txt");
Console.WriteLine("读完了");
return text.Length;
}

编译后(简化)#

Task<int> LoadAsync()
{
var sm = new LoadStateMachine(); // 结构体
sm._builder = AsyncTaskMethodBuilder<int>.Create();
sm._state = -1;
sm._builder.Start(ref sm); // 立即同步执行 MoveNext,直到第一个未完成的 await
return sm._builder.Task;
}
struct LoadStateMachine : IAsyncStateMachine
{
public int _state;
public AsyncTaskMethodBuilder<int> _builder;
TaskAwaiter<string> _awaiter;
string _text; // 跨越 await 的局部变量变成字段
public void MoveNext()
{
try
{
if (_state == -1)
{
Console.WriteLine("开始");
_awaiter = File.ReadAllTextAsync("a.txt").GetAwaiter();
if (!_awaiter.IsCompleted)
{
_state = 0;
// 注册回调:操作完成后再调用一次 MoveNext。这里会把状态机装箱到堆上
_builder.AwaitUnsafeOnCompleted(ref _awaiter, ref this);
return; // 暂停,把控制权还给调用方
}
}
// _state == 0:从这里继续
_text = _awaiter.GetResult(); // 取结果,有异常会在这里重新抛出
Console.WriteLine("读完了");
_builder.SetResult(_text.Length); // 完成 Task
}
catch (Exception e)
{
_builder.SetException(e); // 异常保存到 Task 中
}
}
}

和迭代器的区别#

迭代器async
谁来推进状态机调用方主动调用 MoveNext()(拉)等待的操作完成后回调 MoveNext()(推)
开始执行的时机第一次 MoveNext() 时调用时立即同步执行,直到第一个未完成的 await
产出多个值一个结果(或者没有结果)
状态机类型类,总在堆上Release 编译下是结构体,只有真正暂停时才被装箱到堆上
异常直接从 MoveNext() 抛给调用方保存在 Task 中,await 它时重新抛出

注意”调用时立即同步执行”:async 方法在遇到第一个未完成的 await 之前,都是在调用方的线程上同步执行的。如果一路上等待的操作都已经完成,整个方法就同步执行完了,没有任何暂停。

awaiter 模式#

await 后面不一定是 Task,任何满足以下模式的类型都可以被 await:

// 1. 有 GetAwaiter() 方法(可以是扩展方法)
// 2. 返回的 awaiter 具备:
bool IsCompleted { get; } // 是否已经完成
void OnCompleted(Action continuation); // 未完成时,注册完成后的回调(INotifyCompletion)
T GetResult(); // 获取结果或抛出异常

Unity 的 AsyncOperation、UniTask、Unity 2023 的 Awaitable 能被 await,就是因为实现了这个模式。

内存分配#

  • 状态机本身是结构体。如果所有 await 都已经同步完成,状态机不会被装箱。
  • 遇到未完成的 await 需要暂停时,状态机要在堆上保存下来,第一次暂停时会装箱。
  • 返回的 Task<T> 本身是一个对象,通常要分配(少数常见结果有缓存)。

这就是为什么在每帧都要执行的游戏代码中频繁使用 Task 会产生 GC 压力,也是 ValueTask 和 UniTask 这类基于结构体的方案存在的原因。

async void#

async void OnClick() { await ...; }
  • 调用方无法 await 它,无法知道它什么时候完成。
  • 它抛出的异常没有 Task 可以保存,会直接抛到同步上下文中。
  • 只应该用于事件处理函数这种签名必须返回 void 的地方,其他情况都返回 Task(或 UniTask)。

四、await 之后在哪个线程继续#

SynchronizationContext#

await 一个未完成的操作时,默认会捕获当前的同步上下文(SynchronizationContext.Current)。操作完成后,后续代码通过这个上下文调度执行。

  • 有同步上下文的线程(UI 线程、Unity 主线程):后续代码会回到这个线程上执行。
  • 没有同步上下文(比如线程池线程):后续代码在线程池的某个线程上执行。

Unity 在主线程上安装了自己的 UnitySynchronizationContext,所以在主线程中 await 之后,代码会在之后某一帧回到主线程继续执行,可以安全地调用 Unity API。

ConfigureAwait(false)#

await SomeIOAsync().ConfigureAwait(false);
// 这之后可能在线程池线程上,不能调用 Unity API

表示”不需要回到原来的上下文”。在通用类库中常用,可以减少线程切换。在 Unity 的游戏逻辑中,之后要访问 Unity API 的话不要使用。

五、异步不等于多线程#

这是面试中最常被答错的一点。

async Task Foo()
{
await Task.Delay(1000); // 不占用任何线程:注册一个计时器,到时间后回调
Bar(); // 在 Unity 主线程上,Delay 结束后回到主线程执行
}
  • async/await 本身不创建任何线程。它只是让方法在等待时不阻塞当前线程:注册一个回调就返回,等操作完成后再继续。等待网络、磁盘、计时器时,根本没有线程在”等”。
  • 真正把工作放到其他线程上的是 Task.Run,它把委托交给线程池执行:
int result = await Task.Run(() => HeavyCompute()); // HeavyCompute 在线程池线程上执行

总结:

场景用什么
等待一个操作(网络、加载、计时)async/await,不需要额外线程
计算一个耗时任务,不想卡住主线程Task.Run 放到线程池,或者 Unity 的 Job System

常见追问#

yield return 的原理是什么? 编译器把迭代器方法改写成一个实现 IEnumerator 的状态机类:局部变量变成字段,state 字段记录执行到哪,MoveNext() 根据 state 跳到对应位置继续执行,到下一个 yield 时保存状态并返回。

Unity 协程的原理是什么? 协程方法是一个迭代器。StartCoroutine 拿到迭代器对象后,Unity 每帧根据 yield 出的对象(null、WaitForSeconds 等)判断是否到时间,再调用 MoveNext() 推进。它运行在主线程上,不是多线程。

async/await 的原理是什么? 编译器生成实现 IAsyncStateMachine 的状态机。方法先同步执行,遇到未完成的 await 时注册回调并返回;操作完成后回调再次调用 MoveNext(),从中断处继续。结果和异常保存在返回的 Task 中。

迭代器和 async 状态机有什么区别? 迭代器由调用方主动调用 MoveNext 推进,可以产出多个值;async 由等待的操作完成后回调推进,产出一个结果。迭代器状态机是类;async 状态机是结构体,只在真正暂停时装箱。

async/await 会开新线程吗? 不会。它只是在等待时不阻塞当前线程。真正使用其他线程的是 Task.Run 等。

await 之后的代码在哪个线程执行? 取决于 await 时捕获的同步上下文。Unity 主线程有 UnitySynchronizationContext,所以会回到主线程;用了 ConfigureAwait(false) 或在线程池中则不一定。

为什么不推荐 async void? 调用方无法等待它完成,异常也无法被调用方捕获。只用于事件处理函数。

任何类型都能被 await 吗? 只要实现了 awaiter 模式:有 GetAwaiter(),返回的对象有 IsCompleted、OnCompleted、GetResult。

文章分享

如果这篇文章对你有帮助,欢迎分享给更多人!

C# 迭代器与 async/await 原理:编译器生成的状态机
https://xslab.cloud/posts/csharp/keywords/iterator-and-async/
作者
LuxFire
发布于
2026-10-12
许可协议
CC BY-NC-SA 4.0
相关文章 智能推荐
1
C# 关键字速查
C#底层/关键字 按类别整理 C# 常用关键字,每个一两句话说明用途和要点,复杂的关键字链接到专题文章。适合复习时快速过一遍。
2
C# 访问修饰符与类型修饰符
C#底层/关键字 六种访问级别的可见范围对比,protected internal 与 private protected 的区别,各种成员的默认访问级别;以及 static、sealed、abstract、partial 修饰类型时的含义和限制,附 Unity 中 asmdef 与静态字段的注意点。
3
C# 常量与只读:const、readonly 与 static readonly
C#底层/关键字 const 与 readonly 的本质区别(编译期常量与运行时只读),为什么修改 const 要重新编译引用方,readonly 引用类型字段的误区,readonly struct、readonly 成员与防御性复制,以及 init 访问器。
4
C# 继承与多态关键字:virtual、override、new、abstract、sealed
C#底层/关键字 virtual 与 override 如何实现运行时多态,override 与 new 的本质区别,abstract 与 sealed 的用法,base 和 this,构造函数的执行顺序与构造函数中调用虚方法的陷阱,以及 Unity 中 Awake、Update 等消息方法的继承写法。
5
C# 委托、事件与 Lambda:原理、区别与闭包陷阱
C#底层/关键字 委托的本质是什么,多播委托的调用顺序、返回值与异常;事件在委托之上加了哪些限制,委托与事件的对比;Lambda 与闭包编译后的样子,循环中捕获变量的经典陷阱;以及委托在 Unity 中的 GC 开销、事件导致的内存泄漏和 UnityEvent。
随机文章 随机推荐
Profile Image of the Author
LuxFire
Hello, I'm LuxFire.
公告
欢迎来到我的博客!这是一则示例公告。
音乐
封面

音乐

暂未播放

0:00 0:00
暂无歌词
分类
标签
站点统计
文章
60
分类
6
标签
164
总字数
171,869
运行时长
0 天
最后活动
0 天前

文章目录