SynchronizationContext, ConfigureAwait and deadlocks

using System.Collections.Concurrent;

// Where does the rest of a method run after an await? The SynchronizationContext decides.
Console.WriteLine("Under a context that runs its callbacks on one thread, as a UI thread does:");
OneThreadContext.Run(ShowAsync);

Console.WriteLine("In a plain console app, with no context:");
await ShowAsync();

static async Task ShowAsync()
{
    int before = Environment.CurrentManagedThreadId;
    Console.WriteLine($"  before await: {Describe()}");
    await Task.Delay(50); // not finished yet, so the method stops here and resumes later
    string same = Environment.CurrentManagedThreadId == before ? "the same thread" : "another thread";
    Console.WriteLine($"  after await:  {Describe()}, {same}");
}

static string Describe()
{
    string thread = Thread.CurrentThread.IsThreadPoolThread ? "a pool thread" : "the main thread";
    string context = SynchronizationContext.Current?.GetType().Name ?? "none";
    return $"{thread}, context {context}";
}

// A context that queues every callback and runs them one at a time on the thread that called Run,
// the way a UI thread runs its message loop.
sealed class OneThreadContext : SynchronizationContext
{
    private readonly BlockingCollection<(SendOrPostCallback Callback, object? State)> queue = new();

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

    public static void Run(Func<Task> work)
    {
        var context = new OneThreadContext();
        SynchronizationContext? previous = Current;
        SetSynchronizationContext(context);
        try
        {
            Task task = work();
            task.ContinueWith(_ => context.queue.CompleteAdding(), TaskScheduler.Default);
            foreach (var (callback, state) in context.queue.GetConsumingEnumerable())
            {
                callback(state);
            }

            task.GetAwaiter().GetResult();
        }
        finally
        {
            SetSynchronizationContext(previous);
        }
    }
}

Under a context that runs its callbacks on one thread, as a UI thread does:
  before await: the main thread, context OneThreadContext
  after await:  the main thread, context OneThreadContext, the same thread
In a plain console app, with no context:
  before await: the main thread, context none
  after await:  a pool thread, context none, another thread

using System.Collections.Concurrent;

// The click handler of a desktop app runs on the UI thread, whose context runs callbacks one at a time.
var ui = new OneThreadContext();
SynchronizationContext.SetSynchronizationContext(ui);

Task<decimal>? price = null;
var watchdog = new Thread(() =>
{
    Thread.Sleep(2000); // a real app would hang here for ever; this one is stopped after 2 seconds
    Console.WriteLine($"watchdog: after 2000 ms the price task is {price?.Status}");
    Console.WriteLine($"watchdog: callbacks waiting for the UI thread: {ui.Waiting}");
    Environment.Exit(1);
}) { IsBackground = true };
watchdog.Start();

Console.WriteLine("the handler calls GetPriceAsync");
price = GetPriceAsync("ABC");
Console.WriteLine($"GetPriceAsync returned a task that is {price.Status}");
Console.WriteLine("the handler blocks on .Result");
decimal value = price.Result; // the UI thread waits here, so it can never run the rest of GetPriceAsync
Console.WriteLine($"price: {value}");

static async Task<decimal> GetPriceAsync(string code)
{
    await Task.Delay(100); // captures the UI context: the rest of the method must run on the UI thread
    Console.WriteLine($"the rest of GetPriceAsync runs for {code}");
    return 412.50m;
}

// A context that queues every callback for its one thread; nothing runs them until that thread asks.
sealed class OneThreadContext : SynchronizationContext
{
    private readonly BlockingCollection<(SendOrPostCallback Callback, object? State)> queue = new();

    public int Waiting => queue.Count;

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

the handler calls GetPriceAsync
GetPriceAsync returned a task that is WaitingForActivation
the handler blocks on .Result
watchdog: after 2000 ms the price task is WaitingForActivation
watchdog: callbacks waiting for the UI thread: 1

using System.Collections.Concurrent;

// The handler of deadlock.cs, fixed in two ways, under the same kind of one-thread context.
OneThreadContext.Run(async () =>
{
    // Fix 1, async all the way: the handler awaits, so the UI thread stays free to run the rest of GetPriceAsync.
    decimal price = await GetPriceAsync("ABC");
    Console.WriteLine($"fix 1, the handler awaits: {price}; the handler resumes on {Describe()}");
});

OneThreadContext.Run(() =>
{
    // Fix 2, the library captures no context: the handler still blocks, but nothing needs the UI thread.
    decimal price = GetPriceNoContextAsync("ABC").Result;
    Console.WriteLine($"fix 2, the handler blocks on a library that uses ConfigureAwait(false): {price}");
    return Task.CompletedTask;
});

static async Task<decimal> GetPriceAsync(string code)
{
    await Task.Delay(100);
    Console.WriteLine($"  GetPriceAsync({code}) resumes on {Describe()}");
    return 412.50m;
}

static async Task<decimal> GetPriceNoContextAsync(string code)
{
    await Task.Delay(100).ConfigureAwait(false);
    Console.WriteLine($"  GetPriceNoContextAsync({code}) resumes on {Describe()}");
    return 412.50m;
}

static string Describe()
{
    string thread = Thread.CurrentThread.IsThreadPoolThread ? "a pool thread" : "the main thread";
    string context = SynchronizationContext.Current?.GetType().Name ?? "none";
    return $"{thread}, context {context}";
}

// A context that queues every callback and runs them one at a time on the thread that called Run.
sealed class OneThreadContext : SynchronizationContext
{
    private readonly BlockingCollection<(SendOrPostCallback Callback, object? State)> queue = new();

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

    public static void Run(Func<Task> work)
    {
        var context = new OneThreadContext();
        SynchronizationContext? previous = Current;
        SetSynchronizationContext(context);
        try
        {
            Task task = work();
            task.ContinueWith(_ => context.queue.CompleteAdding(), TaskScheduler.Default);
            foreach (var (callback, state) in context.queue.GetConsumingEnumerable())
            {
                callback(state);
            }

            task.GetAwaiter().GetResult();
        }
        finally
        {
            SetSynchronizationContext(previous);
        }
    }
}

  GetPriceAsync(ABC) resumes on the main thread, context OneThreadContext
fix 1, the handler awaits: 412.50; the handler resumes on the main thread, context OneThreadContext
  GetPriceNoContextAsync(ABC) resumes on a pool thread, context none
fix 2, the handler blocks on a library that uses ConfigureAwait(false): 412.50