This series has measured one thing at a time. This post puts the numbers together, because the interesting question is not "what does an await cost" but "when does any of it show up in my application". It is also the last post before .NET 11, where the runtime takes over and several of these numbers change. The two paths Everything reduces to a single distinction. An async method either completes without… [read more]

These two methods look equivalent: public Task<int> DoSomethingAsync() { return CallDependencyAsync(); } public async Task<int> DoSomethingAsync() { return await CallDependencyAsync(); } The first is called eliding the await. It is faster, and it is usually the wrong choice. This post is about what you actually trade. What eliding saves Without async, the method is an ordinary method that returns a value… [read more]

Once operations run concurrently, they start touching the same state. The synchronous answer is lock, and it does not work here: lock (_gate) { await LoadAsync(); // CS1996: Cannot await in the body of a lock statement } That is a compiler error, and it is protecting you from something worse than a compiler error. Why the compiler refuses lock compiles to Monitor.Enter and Monitor.Exit, and Monitor is… [read more]

Everything so far has been about a single operation. This post is about running several, which is where async stops being a syntax feature and starts changing what your program does. The mechanics are three combinators and one throttle, and each has an exception behaviour that is worth knowing before you meet it in production. Starting is what makes them concurrent Before the combinators, the thing they… [read more]

An async operation that cannot be stopped is a resource leak with good manners. CancellationToken is how .NET stops them, and it is cooperative: nothing is aborted, nothing is interrupted. The operation checks, and gives up. That cooperation is the part people underuse, and the details around it are the part people get wrong. The two halves CancellationTokenSource is the control. CancellationToken is the… [read more]

IDisposable.Dispose returns void. That is fine when cleanup means releasing a handle, and a problem when it means flushing a buffer to disk or sending a close frame over a socket. Those are I/O, and a void method has only two ways to do I/O: block a thread, or fire and forget. IAsyncDisposable exists to give cleanup somewhere to await. The interface public interface IAsyncDisposable { ValueTask… [read more]

An async method produces one value. An iterator produces many values but cannot await. IAsyncEnumerable<T> is what happens when you need both, and the compiler builds it by fusing the two state machines it already knows how to generate. The typical case is paging through an API: each page is a network call, and the caller should not have to know that pages exist. await foreach (var item in… [read more]

ValueTask<T> is the return type people reach for when they have heard that Task allocates, and then use everywhere. That is the wrong lesson. ValueTask solves one specific problem, it solves it very well, and it comes with rules that Task does not have. What it is ValueTask<T> is a struct holding one of three things: a TResult directly, for a synchronous success, a Task<TResult>, for the asynchronous… [read more]

The previous post covered ExecutionContext, which decides what state a continuation sees. This post is about the other thing await captures, which decides where the continuation runs. It is also the mechanism behind the single most famous bug in async C#: calling .Result and hanging forever. What a SynchronizationContext is A SynchronizationContext is an abstraction over "post this callback to the right… [read more]

The thread that resumes after an await is usually not the thread that started the method. That is the whole point, and it creates a problem: anything you attached to the thread is gone. [ThreadStatic] private static string? CurrentUser; CurrentUser = "alice"; await SomethingAsync(); // CurrentUser may be null here ExecutionContext is the mechanism that solves this. It is the thing that flows across an… [read more]