What is a SynchronizationContext, which .NET app models have one, and how does it cause the classic async deadlock?

1. How await captures and resumes

await task (incomplete):
    ctx = SynchronizationContext.Current
    if (ctx != null && ctx.GetType() != typeof(SynchronizationContext))
        register continuation: on completion -> ctx.Post(MoveNext)
    else if (TaskScheduler.Current != TaskScheduler.Default)
        register continuation on that scheduler
    else
        register continuation to run on the pool (or inline on the completing thread when safe)

ConfigureAwait(false) skips the first two branches.

2. Reproducing the deadlock without a UI

The code example builds a tiny single-threaded SynchronizationContext (a queue processed by one thread), just like a UI message loop:

fake-ui thread runs callback:
    LoadAsync() -> await Task.Delay(100) captures fake-ui context
    .GetResult() blocks fake-ui thread
Delay completes -> Post(continuation) to fake-ui queue
fake-ui thread is blocked -> queue never processed -> deadlock

With avoidContext: true (ConfigureAwait(false)), the continuation runs on the pool, completes the task, and .GetResult() returns.

3. Send deadlocks too

// UI thread:
var t = Task.Run(() => uiContext.Send(_ => label.Text = "x", null));   // background thread waits for UI
t.Wait();                                                               // UI thread waits for background -> deadlock

Prefer Post / BeginInvoke / Dispatcher.InvokeAsync, or just await.

4. Why ASP.NET Core dropped it

• AspNetSynchronizationContext serialised continuations per request and carried HttpContext.Current, costing throughput and causing the deadlock class above.
• ASP.NET Core passes HttpContext explicitly (DI, parameters) or via IHttpContextAccessor (AsyncLocal).
• Without a context, continuations run on any pool thread; code must not assume thread affinity.

5. async void and the context

async void methods call OperationStarted / OperationCompleted on the context and post exceptions to it. On a UI thread, an exception from an async void handler goes to the dispatcher's unhandled-exception handler; with no context, it crashes the process.

6. Diagnosing in a dump

7. Test frameworks

xUnit v2 installs a context (to limit parallelism); some UI test harnesses install dispatcher contexts. Code that blocks on async may deadlock in one test runner and not another. Make tests async Task and await.

8. Version notes

9. Try it yourself

1. Run the code example with avoidContext: false to see "Deadlocked", then true to see "Completed".
2. In WPF, call .Result on an async method from a button click and observe the freeze; then make the handler async void and await.
3. Add ConfigureAwait(false) in the async method and confirm .Result no longer deadlocks (but still blocks the UI).
4. Print SynchronizationContext.Current?.GetType().Name in WPF, Blazor, ASP.NET Core and a console app.
5. Take a dump of the frozen WPF app and inspect the UI thread with clrstack and dumpasync.

using System.Threading;

// Simulate a UI-style single-threaded context to reproduce the deadlock in a console app.
var context = new SingleThreadContext();
var done = new ManualResetEventSlim();

context.Post(_ =>
{
    SynchronizationContext.SetSynchronizationContext(context);
    var task = LoadAsync(avoidContext: true); // set false to deadlock
    Console.WriteLine($"Result: {task.GetAwaiter().GetResult()}"); // blocks the context thread
    done.Set();
}, null);

Console.WriteLine(done.Wait(TimeSpan.FromSeconds(2)) ? "Completed" : "Deadlocked");

static async Task<string> LoadAsync(bool avoidContext)
{
    // continueOnCapturedContext: false is the same as ConfigureAwait(false).
    await Task.Delay(100).ConfigureAwait(continueOnCapturedContext: !avoidContext);
    return "settings";
}

// A minimal single-threaded SynchronizationContext, like a UI thread's.
public sealed class SingleThreadContext : SynchronizationContext
{
    private readonly System.Collections.Concurrent.BlockingCollection<(SendOrPostCallback, object?)> _queue = new();

    public SingleThreadContext()
    {
        var thread = new Thread(() =>
        {
            foreach (var (callback, state) in _queue.GetConsumingEnumerable()) callback(state);
        }) { IsBackground = true, Name = "fake-ui" };
        thread.Start();
    }

    public override void Post(SendOrPostCallback d, object? state) => _queue.Add((d, state));
}