关于IAwaiter等4组件协作及IAsyncMethodBuilder多awaiter关联的问询

Great question—this is one of those parts of async/await that feels opaque at first, but clicks once you peek at what the compiler actually generates. Let’s break this down step by step, focusing specifically on your example of two sequential await calls:

var a = await MyMethod();
var b = await MyMethod();

First: Quick Roles of Each Component #

Let’s start with a high-level overview to set the stage:

• IAwaitable: The "thing" you can await (like Task<T>). It exposes a GetAwaiter() method that returns an IAwaiter.
• IAwaiter: Handles the low-level waiting logic—tracks if the operation is complete, fetches the final result, and triggers the continuation when done.
• IAsyncStateMachine: The compiler-generated struct/class that represents the "state" of your async method. It runs your code in chunks as each await completes, keeping track of where it left off.
• IAsyncMethodBuilder: The coordinator that ties everything together. It initializes the state machine, handles exception propagation, and manages the link between awaiters and the state machine.

Why Only One Awaiter in the State Machine? #

Here’s the core insight: Your state machine only needs one awaiter field because it never waits on two operations at the same time (in your sequential scenario). Let’s walk through exactly what happens:

1. Initial Method Call: When you invoke your async method, the compiler creates an instance of the state machine and initializes the corresponding IAsyncMethodBuilder (e.g., AsyncTaskMethodBuilder<T> for methods returning Task<T>).

2. First await Execution:

   • The state machine’s MoveNext() method runs for the first time. It calls MyMethod() to get an IAwaitable (a Task), then calls GetAwaiter() on it to grab an IAwaiter.
   • This awaiter is stored in the single awaiter field on the state machine.
   • The state machine calls the builder’s AwaitUnsafeOnCompleted() method, which links the awaiter to the state machine. This tells the awaiter: "When you’re done, trigger the state machine’s MoveNext() again."
   • The state machine pauses here until the first MyMethod() completes.

3. First Await Completes:

   • The awaiter signals it’s finished, which triggers MoveNext() to run again.
   • The state machine calls the awaiter’s GetResult() to get the value of a, then that awaiter is no longer needed and gets overwritten soon after.

4. Second await Execution:

   • The state machine moves to its next state, calls the second MyMethod() to get a new IAwaitable, and calls GetAwaiter() on it.
   • This new awaiter overwrites the same single awaiter field on the state machine.
   • Again, it uses the builder to link this new awaiter to the state machine, pausing until the second operation finishes.

5. Second Await Completes:

   • MoveNext() runs one last time, calls GetResult() to get b, then tells the builder to mark the entire async method as complete with SetResult().

The Builder’s Role Here #

The IAsyncMethodBuilder doesn’t hold onto awaiters itself—it just provides the infrastructure to connect each awaiter to the state machine. Its job is to ensure that when an awaiter finishes, the state machine picks up where it left off. It doesn’t need to track multiple awaiters because the state machine only ever works with one at a time.

What If We Had Parallel Awaits? #

If you used something like await Task.WhenAll(MyMethod(), MyMethod()), the state machine would still only use one awaiter—but that awaiter would be the one returned by Task.WhenAll(), which internally tracks both operations. The core idea remains: at any given time, the state machine is only waiting on one awaitable.

Recap of the Full Collaboration #

To tie it all together:

• The compiler transforms your async method into a state machine that tracks execution progress.
• Each await in your code translates to the state machine fetching an awaiter, storing it in its single awaiter field, and using the builder to link the awaiter to itself.
• When an awaiter completes, it triggers the state machine to resume, process the result, and move to the next state (possibly fetching a new awaiter).
• The builder manages the lifecycle of the async operation (setting results, handling exceptions) and ensures the state machine is properly awakened.

内容的提问来源于stack exchange，提问作者Bercovici Adrian