Sync to async dispatch: how can I avoid deadlock?

Question

I'm trying to create a class that has synchronous methods and calls some other library methods which are asynchronous. For that reason I use Task.Result to wait for the async operation to finish. My methods are called by WPF app in synchronous way. This leads to a deadlock. I know that the best way is to make all my methods asynchronous but my situation requires them to be synchronous. From the other hand they use other library which is asynchronous.

My question is: How can I avoid the deadlock in such situation?

Steps to reproduce:

1. User hits a button in the app (method Button1_OnClick)

2. This method creates an instance of IPlugin and then calls its method RequestSomething()

3. This method then calls async library this way: asyncTarget.MethodFromAsyncLibrary("HelloFromPlugin").Result

4. The library calls back its method NotifyNewValueProgressAsync()

5. NotifyNewValueProgressAsync() delegates the call back to the WPF application

6. Since the UI context is blocked by this line asyncTarget.MethodFromAsyncLibrary("HelloFromPlugin").Result the callback in step 5 leads to a deadlock.

See code example below and related comments:

public class SyncAdapterPlugin : IPlugin, IProgressAsyncHandler
{
    //Constructor and fields are omitted here

    //This method is called from UI context by WPF application and it delegates synchronous call to asynchronous method
    string IPlugin.RequestSomething()
    {
        //In order to be able to run the callback I need to capture current UI context
        _context = TaskScheduler.FromCurrentSynchronizationContext();

        var asyncTarget = new ClassFromMyLibrary1(this);
        var resultFromAsyncLibrary = asyncTarget.MethodFromAsyncLibrary("HelloFromPlugin").Result; //Deadlock here!
        return resultFromAsyncLibrary;
    }

    //This method does opposite, it delegates asynchronous callback to synchronous
    async Task<bool> IProgressAsyncHandler.NotifyNewValueProgressAsync(string message)
    {
        //NotifyNewValueProgress method is implemented by WPF application and will update UI elements.
        //That's why it's needed to run the callback on captured UI context.
        Func<bool> work = () => _syncProgressHandler.NotifyNewValueProgress(message);
        if (_context != null)
        {
            return await
                Task.Factory.StartNew(work, CancellationToken.None, TaskCreationOptions.None, _context)
                .ConfigureAwait(false);
        }
        return work();
    }
}

Complete code example is here https://dotnetfiddle.net/i48sRc.

FYI, Some background on this issue you can also find in this SO question.

Answer 1

The plugin framework is fundamentally flawed. In particular, it requires a synchronous RequestSomething that expects to be able to call NotifyNewValueProgressAsync to update the UI. However, it's not possible to display a UI update while the UI thread is running a synchronous method.

This forces you to use one of the most dangerous and evil sync-over-async hacks: the nested message loop hack (as briefly described in my article on brownfield async). Since this is a WPF app, you'd use a nested dispatcher frame. The main pain with this hack is that it introduces reentrancy across your entire UI layer, which is the most subtle and difficult kind of concurrency problem.