Deadlock while blocking async HttpClient call within a task continuation

Question

I am trying to wrap my head around synchronously calling async functions and deadlock.

In the below example I am blocking an async call which internally uses ConfigureAwait(false) which as far as I can tell should prevent deadlock. The first call to the web service does not deadlock. However, the second one that happens within a continuation that syncs back to the UI thread deadlocks.

GetBlocking_Click is a click event in a WPF app so both the first and the second request happen on the UI thread.

      private void GetBlocking_Click(object sender, RoutedEventArgs e)
    {
        const string uri = "http://www.mywebservice.com";
        var example1 = GetAsync(uri).Result;

        Task.FromResult(true)
            .ContinueWith(t =>
            {
                var example2 = GetAsync(uri).Result;
            }, 
            TaskScheduler.FromCurrentSynchronizationContext()).Wait();
    }

    private async Task<string> GetAsync(string url)
    {
        using (var client = new HttpClient())
        {
            var responseMessage = await client.GetAsync(url).ConfigureAwait(false);

            return await responseMessage.Content.ReadAsStringAsync().ConfigureAwait(false);
        }
    }

Can you please explain what is the difference between these 2 calls?

Answer 1

You're in the UI thread. From that thread you call Task.FromResult and create a task. You then add a continuation to that task that needs to run in the UI thread. That continuation is added to the queue for the message pump to handle.

You then wait for that continuation to finish in the UI thread. That continuation is waiting for the UI to be available in order to even start the body of the continuation, which will end up calling GetAsync. This is a deadlock.

It doesn't even matter what the body of the continuation is; the following code deadlocks for the same reason:

private void GetBlocking_Click(object sender, RoutedEventArgs e)
{
    Task.FromResult(true)
        .ContinueWith(t =>{ }, 
            TaskScheduler.FromCurrentSynchronizationContext())
        .Wait();
}

As for the fix, you just shouldn't be synchronously waiting on asynchronous operations in the first place. Either make the whole thing asynchronous, or make it all synchronous.