Asynchronous Programming in .NET
- 2. What is asynchronous programming - Unit of work running separately from its caller. - Common implementations: promises and callbacks.
- 3. Asynchronous == Parallelism? Yes. No. Well, sort of. Parallelism can happen with the TPL although itâs not the goal. Parallelism -> splitting a task into smaller pieces to execute them concurrently.
- 4. Task Parallel Library (TPL) â Includes asynchronous and parallelism APIs (Task, Parallel LINQ). â Gotcha: although being in the .NET CLR, F# uses a completely distinct implementation. â Mostly about Task and the underlying plumbing. â async/await is the language mechanism to generate the code around Tasks for continuations
- 5. In C# async Task<String> GetContent(String url) { return await _httpClient.GetAsync(url); } C# 5 .NET 4.5
- 6. F# Async Distinct implementation, predates the TPL. let sleep milliseconds message: WebPart = fun (x : HttpContext) -> async { do! Async.Sleep milliseconds return! OK message x }
- 7. Non blocking I/O - Non blocking I/O is commonly implied in .NET when talking about async/await and the TPL. - Similar to NodeJs, same purpose to run many requests on few threads - Many of the .NET async APIs use async IO, such as ADO.NET
- 8. Non blocking I/O in Operating systems â Known as overlapped I/O in Windows â Posix AIO in Linux â Socket AIO has arguably the most impact in web apps (database calls, HTTP, etc.)
- 9. Example: Dapper queries SqlConnection.Query() -> synchronous socket. Synchronous blocking SqlConnection.QueryAsync() -> asynchronous socket. Asynchrounous non blocking Task.Run(() => SqlConnection.Query() -> still a synchronous socket) Asynchrounous blocking. SqlConnection.QueryAsync().Result -> Asynchronous call and blocks the current thread
- 10. Why all the fuss about asynchronous anyway (Supposing asynchronous IO) â Scalability, handling many requests in parallel â Better handling of spikes. .NET throttle thread creation at 1 per half second. Async regardless of IO â Freeing the UI thread in a desktop application â Asynchronous flows
- 11. Async all the things
- 12. Not so fast - Need to propagate the async all the way up to the caller - Overhead on pure CPU code - Exception handling is tricky. - Not meant for fire and forget. Hard to debug, monitor, error handling.
- 13. You can block on async code. Donât. Task.Result -> Congratulations, itâs a deadlock (probably) Blocking -> the async IO is now synchronous. Frameworks such as ASP.NET force a request to continue on the same thread. Doesnât happen anymore in ASP.NET Core, no synchronization context.
- 14. State machine â The async/await is replaced with a state machine by the compiler â Async/await is a language construct -> doesnât exist in IL. â Could be done manually, lot of boilerplate
- 15. Quiz var tasks = Enumerable.Range(0, 100).Select(async _ => await Task.Delay(1000)).ToArray(); var tasks = Enumerable.Range(0, 100).Select(async _ => await Task.Run(() => Thread.Sleep(1000))).ToArray(); Task.WaitAll(tasks);
- 16. async _ => await Task.Delay(1000)
- 17. async _ => await Task.Run(() => Thread.Sleep(1000))
- 18. Beware of background processing Easy to fire and forget -> doesnât mean you should - Error handling is thrown out the window - No priority on what is executed - No way of cancelling anything - Hell to monitor/debug - Accessing thread scoped dependencies and all hell breaks loose. - Hangfire is a worthy alternative.
- 19. Cancellation â Cancellation token to cancel a task â Essentially throws an exception, bubbling up the call chain â Useful for cleanup of resources or stop intensive processing var tokenSource = new CancellationTokenSource(); var task = _httpClient..GetAsync("http://www.google.com", cts.Token); tokenSource.Cancel();
- 20. Takeaways â Non-blocking I/O is usually implied with async in .NET â Asynchronous programming has many benefits but shouldnât be used for all methods. â Blocking on async code essentially nullifies all gain, if youâre lucky. Use await! â If youâre not lucky, deadlock
Editor's Notes
- #3: Sending an email and doing something else while waiting for an answer.
- #14: Code that works in a console application but deadlocks in an ASP.NET application SynchronizationContext -> https://blog.stephencleary.com/2017/03/aspnetcore-synchronization-context.html
- #15: https://weblogs.asp.net/dixin/understanding-c-sharp-async-await-1-compilation
- #16: Around a second for Task.Delay Around 12 seconds Task.Run
- #19: The list goes on. At the very have an executor class so you can refactor later without having to hunt for all Task.Run calls. Memes: Jurassic Park, because you could doesnât mean you should Friends donât let each other Task.Run()
- #20: Cancellation token