All 20 Asynchronous Programming questions
More in Asynchronous Programming
What are async streams in C#, and how does IAsyncEnumerable<T> differ from a regular IEnumerable<T> for handling large or slow data sources? Why can .Result or .Wait() deadlock, and what's the fix? How do you design for scalability and avoid thread-pool starvation? How does CancellationToken propagate cancellation requests through a chain of async method calls? What is ValueTask<T> and when should you use it instead of Task<T> for performance? How do IAsyncEnumerable<T> and 'await foreach' let you consume an asynchronous stream of values one at a time? How do you correctly implement a producer-consumer pattern using System.Threading.Channels for asynchronous data pipelines? What is the difference between Task and Thread in C#, and when would you deliberately choose one over the other? What is ValueTask<T> in C#, and when does it actually provide a meaningful performance benefit over Task<T>? How does async/await work under the hood in C#, and what specifically happens when execution reaches an 'await'?
Advertisement
Back to results for “Performance”
C# › Asynchronous Programming

How does the compiler transform an async method into a state machine, and why does this matter for understanding performance?

Advanced

Answer

The compiler rewrites an async method into a compiler-generated struct or class implementing IAsyncStateMachine, with a numeric state field tracking progress and each 'await' becoming a suspend/resume point — this transformation has real allocation costs (especially for a class-based state machine when the method captures local variables or is a class-based async method), which is why hot-path async methods sometimes prefer ValueTask over Task to reduce allocations.
// Conceptual illustration of what the compiler generates behind the scenes:
// class MethodNameStateMachine : IAsyncStateMachine {
//   int state;
//   TaskAwaiter awaiter;
//   void MoveNext() { /* resumes execution from the last await point */ }
// }
Real-world example Understanding why a hot-path async method with many local variables can have measurably higher allocation overhead than an equivalent synchronous one.

Common follow-ups: Under what conditions does the compiler generate a STRUCT-based state machine instead of a class-based one, and why does that matter for allocations?

Memory & Garbage Collection
All 20 Asynchronous Programming questions