ConfigureAwait Pushes The Continuation To A Pool Thread

Answer :

Why ConfigureAwait pro-actively pushes the await continuation to a pool thread here?

It doesn't "push it to a thread pool thread" as much as say "don't force myself to come back to the previous SynchronizationContext".

If you don't capture the existing context, then the continuation which handles the code after that await will just run on a thread pool thread instead, since there is no context to marshal back into.

Now, this is subtly different than "push to a thread pool", since there isn't a guarantee that it will run on a thread pool when you do ConfigureAwait(false). If you call:

await FooAsync().ConfigureAwait(false);

It is possible that FooAsync() will execute synchronously, in which case, you will never leave the current context. In that case, ConfigureAwait(false) has no real effect, since the state machine created by the await feature will short circuit and just run directly.

If you want to see this in action, make an async method like so:

static Task FooAsync(bool runSync)
{
   if (!runSync)
       await Task.Delay(100);
}

If you call this like:

await FooAsync(true).ConfigureAwait(false);

You'll see that you stay on the main thread (provided that was the current context prior to the await), since there is no actual async code executing in the code path. The same call with FooAsync(false).ConfigureAwait(false); will cause it to jump to thread pool thread after execution, however.

Here is the explanation of this behavior based on digging the .NET Reference Source.

If ConfigureAwait(true) is used, the continuation is done via TaskSchedulerAwaitTaskContinuation which uses SynchronizationContextTaskScheduler, everything is clear with this case.

If ConfigureAwait(false) is used (or if there's no sync. context to capture), it is done via AwaitTaskContinuation, which tries to inline the continuation task first, then uses ThreadPool to queue it if inlining is not possible.

Inlining is determined by IsValidLocationForInlining, which never inlines the task on a thread with a custom synchronization context. It however does the best to inline it on the current pool thread. That explains why we're pushed on a pool thread in the first case, and stay on the same pool thread in the second case (with Task.Delay(100)).

I think it's easiest to think of this in a slightly different way.

Let's say you have:

await task.ConfigureAwait(false);

First, if task is already completed, then as Reed pointed out, the ConfigureAwait is actually ignored and the execution continues (synchronously, on the same thread).

Otherwise, await will pause the method. In that case, when await resumes and sees that ConfigureAwait is false, there is special logic to check whether the code has a SynchronizationContext and to resume on a thread pool if that is the case. This is undocumented but not improper behavior. Because it's undocumented, I recommend that you not depend on the behavior; if you want to run something on the thread pool, use Task.Run. ConfigureAwait(false) quite literally means "I don't care what context this method resumes in."

Note that ConfigureAwait(true) (the default) will continue the method on the current SynchronizationContext or TaskScheduler. While ConfigureAwait(false) will continue the method on any thread except for one with a SynchronizationContext. They're not quite the opposite of each other.