Use Task.Run() in synchronous method to avoid deadlock waiting on async method?

by

It seems you understand the risks involved in your question so I’ll skip the lecture.

To answer your actual question: Yes, you can just use Task.Run to offload that work to a ThreadPool thread which doesn’t have a SynchronizationContext and so there’s no real risk for a deadlock.

However, using another thread just because it has no SC is somewhat of a hack and could be an expensive one since scheduling that work to be done on the ThreadPool has its costs.

A better and clearer solution IMO would be to simply remove the SC for the time being using SynchronizationContext.SetSynchronizationContext and restoring it afterwards. This can easily be encapsulated into an IDisposable so you can use it in a using scope:

public static class NoSynchronizationContextScope
{
    public static Disposable Enter()
    {
        var context = SynchronizationContext.Current;
        SynchronizationContext.SetSynchronizationContext(null);
        return new Disposable(context);
    }

    public struct Disposable : IDisposable
    {
        private readonly SynchronizationContext _synchronizationContext;

        public Disposable(SynchronizationContext synchronizationContext)
        {
            _synchronizationContext = synchronizationContext;
        }

        public void Dispose() =>
            SynchronizationContext.SetSynchronizationContext(_synchronizationContext);
    }
}

Usage:

private void MySynchronousMethodLikeDisposeForExample()
{
    using (NoSynchronizationContextScope.Enter())
    {
        MyAsyncMethod().Wait();
    }
}

More Related Contents:

  1. Running multiple async tasks and waiting for them all to complete
  2. Task sequencing and re-entracy
  3. Enforce an async method to be called once
  4. Executing tasks in parallel
  5. A pattern for self-cancelling and restarting task
  6. What is the correct way to cancel an async operation that doesn’t accept a CancellationToken?
  7. Converting async/await to Task.ContinueWith
  8. How and when to use ‘async’ and ‘await’
  9. Catch an exception thrown by an async void method
  10. Should I avoid ‘async void’ event handlers?
  11. Awaiting multiple Tasks with different results
  12. Using async/await for multiple tasks
  13. How do yield and await implement flow of control in .NET?
  14. Fire and forget async method in asp.net mvc
  15. Best way in .NET to manage queue of tasks on a separate (single) thread
  16. Is there anything like asynchronous BlockingCollection?
  17. Cancelling a pending task synchronously on the UI thread
  18. What is the use for Task.FromResult in C#
  19. Why use Async/await all the way down
  20. Different forms of the WCF service contract interface
  21. How does async works in C#?
  22. Should I worry about “This async method lacks ‘await’ operators and will run synchronously” warning
  23. Async thread body loop, It just works, but how?
  24. Horrible performance using SqlCommand Async methods with large data
  25. How to throttle multiple asynchronous tasks?
  26. Async and Await with For Loop [duplicate]
  27. Await and SynchronizationContext in a managed component hosted by an unmanaged app
  28. When is the best place to use Task.Result instead of awaiting Task
  29. How to implement Task.WhenAny() with a predicate
  30. Create a completed Task

Leave a Comment