Different behavior when using ContinueWith or Async-Await

Question

When I use an async-await method (as the example below) in a HttpClient call, this code causes a deadlock. Replacing the async-await method with a t.C

Answer 1

An explanation on why your await deadlocks

Your first line:

 var user = _authService.GetUserAsync(username).Result;

blocks that thread and the current context while it waits for the result of GetUserAsync.

When using await it attempts to run any remaining statements back on the original context after the task being waited on finishes, which causes deadlocks if the original context is blocked (which is is because of the .Result). It looks like you attempted to preempt this problem by using .ConfigureAwait(false) in GetUserAsync, however by the time that that await is in effect it's too late because another await is encountered first. The actual execution path looks like this:

_authService.GetUserAsync(username)
_httpClientWrp.GetStringAsync(url)   // not actually awaiting yet (it needs a result before it can be awaited)
await _client.GetStringAsync(url)    // here's the first await that takes effect

When _client.GetStringAsync finishes, the rest of the code can't continue on the original context because that context is blocked.

Why ContinueWith behaves differently

ContinueWith doesn't try to run the other block on the original context (unless you tell it to with an additional parameter) and thus does not suffer from this problem.

This is the difference in behavior that you noticed.

A solution with async

If you still want to use async instead of ContinueWith, you can add the .ConfigureAwait(false) to the first encountered async:

string result = await _client.GetStringAsync(url).ConfigureAwait(false);

which as you most likely already know, tells await not to try to run the remaining code on the original context.

Note for the future

Whenever possible, attempt to not use blocking methods when using async/await. See Preventing a deadlock when calling an async method without using await for avoiding this in the future.