Best practice to call ConfigureAwait for all server-side code
asp.net-web-api, async-await, c#, task-parallel-library
Solution
Update: ASP.NET Core does not have a `SynchronizationContext`. If you are on ASP.NET Core, it does not matter whether you use `ConfigureAwait(false)` or not.
For ASP.NET "Full" or "Classic" or whatever, the rest of this answer still applies.
Original post (for non-Core ASP.NET):
This video by the ASP.NET team has the best information on using `async` on ASP.NET.
I had read that it is more performant since it doesn't have to switch thread contexts back to the original thread context.
This is true with UI applications, where there is only one UI thread that you have to "sync" back to.
In ASP.NET, the situation is a bit more complex. When an `async` method resumes execution, it grabs a thread from the ASP.NET thread pool. If you disable the context capture using `ConfigureAwait(false)`, then the thread just continues executing the method directly. If you do not disable the context capture, then the thread will re-enter the request context and then continue to execute the method.
So `ConfigureAwait(false)` does not save you a thread jump in ASP.NET; it does save you the re-entering of the request context, but this is normally very fast. `ConfigureAwait(false)` could be useful if you're trying to do a small amount of parallel processing of a request, but really TPL is a better fit for most of those scenarios.
However, with ASP.NET Web Api, if your request is coming in on one thread, and you await some function and call ConfigureAwait(false) that could potentially put you on a different thread when you are returning the final result of your ApiController function.
Actually, just doing an `await` can do that. Once your `async` method hits an `await`, the method is blocked but the thread returns to the thread pool. When the method is ready to continue, any thread is snatched from the thread pool and used to resume the method.
The only difference `ConfigureAwait` makes in ASP.NET is whether that thread enters the request context when resuming the method.
I have more background information in my MSDN article on `SynchronizationContext` and my `async` intro blog post.
Problem
When you have server-side code (i.e. some `ApiController`) and your functions are asynchronous - so they return `Task<SomeObject>` - is it considered best practice that any time you await functions that you call `ConfigureAwait(false)`? I had read that it is more performant since it doesn't have to switch thread contexts back to the original thread context. However, with ASP.NET Web Api, if your request is coming in on one thread, and you await some function and call `ConfigureAwait(false)` that could potentially put you on a different thread when you are returning the final result of your `ApiController` function. I've typed up an example of what I am talking about below: ``` public class CustomerController : ApiController { public async Task<Customer> Get(int id) { // you are on a particular thread here var customer = await GetCustomerAsync(id).ConfigureAwait(false); // now you are on a different thread! will that cause problems? return customer; } } ```