Calling async methods from non-async code

by

So I’m left with how to best call async methods in a synchronous way.

First, this is an OK thing to do. I’m stating this because it is common on Stack Overflow to point this out as a deed of the devil as a blanket statement without regard for the concrete case.

It is not required to be async all the way for correctness. Blocking on something async to make it sync has a performance cost that might matter or might be totally irrelevant. It depends on the concrete case.

Deadlocks come from two threads trying to enter the same single-threaded synchronization context at the same time. Any technique that avoids this reliably avoids deadlocks caused by blocking.

In your code snippet, all calls to .ConfigureAwait(false) are pointless because the return value is not awaited. ConfigureAwait returns a struct that, when awaited, exhibits the behavior that you requested. If that struct is simply dropped, it does nothing.

RunSynchronously is invalid to use because not all tasks can be processed that way. This method is meant for CPU-based tasks, and it can fail to work under certain circumstances.

.GetAwaiter().GetResult() is different from Result/Wait() in that it mimics the await exception propagation behavior. You need to decide if you want that or not. (So research what that behavior is; no need to repeat it here.) If your task contains a single exception then the await error behavior is usually convenient and has little downside. If there are multiple exceptions, for example from a failed Parallel loop where multiple tasks failed, then await will drop all exceptions but the first one. That makes debugging harder.

All these approaches have similar performance. They will allocate an OS event one way or another and block on it. That’s the expensive part. The other machinery is rather cheap compared to that. I don’t know which approach is absolutely cheapest.

In case an exception is being thrown, that is going to be the most expensive part. On .NET 5, exceptions are processed at a rate of at most 200,000 per second on a fast CPU. Deep stacks are slower, and the task machinery tends to rethrow exceptions multiplying their cost. There are ways of blocking on a task without the exception being rethrown, for example task.ContinueWith(_ => { }, TaskContinuationOptions.ExecuteSynchronously).Wait();.

I personally like the Task.Run(() => DoSomethingAsync()).Wait(); pattern because it avoids deadlocks categorically, it is simple and it does not hide some exceptions that GetResult() might hide. But you can use GetResult() as well with this.

More Related Contents:

  1. Calling async method synchronously
  2. Synchronous implementation of interface that returns Task
  3. Calling TaskCompletionSource.SetResult in a non blocking manner
  4. If async-await doesn’t create any additional threads, then how does it make applications responsive?
  5. Implement C# Generic Timeout
  6. When to use BlockingCollection and when ConcurrentBag instead of List?
  7. When should I use Async Controllers in ASP.NET MVC?
  8. Is it considered acceptable to not call Dispose() on a TPL Task object?
  9. Starting Tasks In foreach Loop Uses Value of Last Item [duplicate]
  10. Is Task.Run considered bad practice in an ASP .NET MVC Web Application?
  11. Best way in .NET to manage queue of tasks on a separate (single) thread
  12. Multiple Parallel.ForEach loops in .Net
  13. Proper way to implement a never ending task. (Timers vs Task)
  14. How to put a task to sleep (or delay) in C# 4.0?
  15. What’s the difference between returning void and returning a Task?
  16. “async Task then await Task” vs “Task then return task” [duplicate]
  17. ThreadPool.QueueUserWorkItem vs Task.Factory.StartNew
  18. Process queue with multithreading or tasks
  19. Calling async method on button click
  20. Is .GetAwaiter().GetResult(); safe for general use?
  21. ForEachAsync with Result
  22. C# Threading/Async: Running a task in the background while UI is interactable
  23. Async thread body loop, It just works, but how?
  24. Why CancellationToken is separate from CancellationTokenSource?
  25. Async WebApi Thread.CurrentCulture
  26. Faulted vs Canceled task status after CancellationToken.ThrowIfCancellationRequested
  27. Write to a file from multiple threads asynchronously c#
  28. call async method without await #2
  29. HttpClient.SendAsync using the thread-pool instead of async IO?
  30. Wrapping ManualResetEvent as awaitable task

Leave a Comment