using System;

using System.Threading.Tasks;

using System.Windows;

using MyComplicatedAsyncLibrary1;

using MyPluginLibrary;

​

namespace WpfApplication1

{

    /// <summary>

    /// Interaction logic for MainWindow.xaml

    /// </summary>

    public partial class MainWindow : Window, INewValueHandler

    {

        public MainWindow()

        {

            InitializeComponent();

        }

​

        //I have no access to this code!!!

        private void Button1_OnClick(object sender, RoutedEventArgs e)

        {

            try

            {

                //Here a plugin library is used

                var c2 = new ClassFromMyLibrary2(this);

​

                var v1 = c2.MethodFromLibrary2();

​

                Label2.Content = v1;

            }

            catch (Exception ex)

            {

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

                throw;

            }

        }

​

        //I have no access to this code!!!

        public Task<string> ActionToProcessNewValue(string s)

        {

            Label1.Content = s;

            return Task.FromResult(string.Format("test2{0}", s));

        }

    }

}

​

namespace MyPluginLibrary

{

    //I am creating a Plugin liblary that acts like an SYNCHRONOUS adapter from MyComplicatedAsyncLibrary1.

    //I can change its code as needed.

​

    public class ClassFromMyLibrary2

    {

        private readonly INewValueHandler _newValueHandler;

​

        public ClassFromMyLibrary2(INewValueHandler newValueHandler)

        {

            _newValueHandler = newValueHandler;

        }

​

        public string MethodFromLibrary2()

        {

            var c = new ClassFromMyLibrary1(_newValueHandler);

​

            var v1 = c.MethodFromMyLibrary1("test1").Result;

            return v1;

        }

    }

}

​

​

namespace MyComplicatedAsyncLibrary1

{

    //This is a very complicated library with tons of async methods calling each another.

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

​

    public class ClassFromMyLibrary1

    {

        private readonly INewValueHandler _newValueHandler;

​

        public ClassFromMyLibrary1(INewValueHandler newValueHandler)

        {

            _newValueHandler = newValueHandler;

        }

​

        public async Task<string> MethodFromMyLibrary1(string key)

        {

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

​

            //do some transformations of the value

            var newValue = string.Format("Remote-{0}", remoteValue);

​

            var processedValue = await _newValueHandler.ActionToProcessNewValue(newValue).ConfigureAwait(false);

​

            return string.Format("Processed-{0}", processedValue);

        }

​

        private async Task<string> GetValueByKey(string key)

        {

            //simulate time-consuming operation

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

​

            return string.Format("ValueFromRemoteLocationBy{0}", key);

        }

    }

​

    //This interface can have different implementations and some might need GUI context while other might not

    public interface INewValueHandler

    {

        Task<string> ActionToProcessNewValue(string s);

    }

}

​