//--------------------------------------------------------------------

​

    //Below is WPF application that is built on plugin architecture. I have no access to its code.

    public partial class MainWindow : Window, IPgrogressHandler

    {

        public MainWindow()

        {

            InitializeComponent();

        }

​

        private void Button1_OnClick(object sender, RoutedEventArgs e)

        {

            try

            {

                var plugin = ResolvePluginFromDiContainer();

                var something = plugin.RequestSomething();

                Label2.Content = something;

            }

            catch (Exception ex)

            {

                System.Diagnostics.Trace.TraceError("{0}", ex);

                throw;

            }

        }

​

        private IPlugin ResolvePluginFromDiContainer()

        {

            //Suppose this instance is resolved externally by DI

            return new SyncAdapterPlugin(this);

        }

​

        bool IPgrogressHandler.NotifyNewValueProgress(string s)

        {

            Label1.Content = s;

            return true;

        }

    }

​

    //This interface is part of the application. I have no access to its code.

    public interface IPlugin

    {

        string RequestSomething();

    }

​

    //This interface is part of the application. I have no access to its code.

    public interface IPgrogressHandler

    {

        bool NotifyNewValueProgress(string s);

    }

​

    //--------------------------------------------------------------------

​

    //I am creating a Plugin liblary that acts like a SYNCHRONOUS adapter from ClassFromMyLibrary1 to IPlugin.

    //I can change its code as needed.

    public class SyncAdapterPlugin : IPlugin, IProgressAsyncHandler

    {

        private readonly IPgrogressHandler _syncProgressHandler;

        private TaskScheduler _context;

​

        public SyncAdapterPlugin(IPgrogressHandler syncProgressHandler)

        {

            _syncProgressHandler = syncProgressHandler;

        }

​

        //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();

        }

    }

​

    //----------------------------------------------------------------------

​

    //Below is a very complicated library with tons of async methods calling each other.

    //Theoretically I can change its code but since it's large I'd avoid doing so.

    public class ClassFromMyLibrary1

    {

        private readonly IProgressAsyncHandler _newValueHandler;

​

        public ClassFromMyLibrary1(IProgressAsyncHandler newValueHandler)

        {

            _newValueHandler = newValueHandler;

        }

​

        public async Task<string> MethodFromAsyncLibrary(string key)

        {

            if (!await _newValueHandler.NotifyNewValueProgressAsync($"Getting remote value by key '{key}'").ConfigureAwait(false))

                throw new OperationCanceledException("operation interrupted");

​

            var remoteValue = await GetRemoteValueByKey(key).ConfigureAwait(false);

​

            //do some transformations of the value

            var newValue = $"Transformed-{remoteValue}";

​

            if (!await _newValueHandler.NotifyNewValueProgressAsync($"New value received: '{newValue}'").ConfigureAwait(false))

                throw new OperationCanceledException("operation interrupted");

​

            return newValue;

        }

​

        private async Task<string> GetRemoteValueByKey(string key)

        {

            //simulate time-consuming operation

            await Task.Delay(2000).ConfigureAwait(false);

            return $"ValueFromRemoteLocationBy{key}";

        }

    }

​

    //This interface is part of the async library.

    public interface IProgressAsyncHandler

    {

        Task<bool> NotifyNewValueProgressAsync(string message);

    }

​