using System;

using System.Threading;

using System.Threading.Tasks;

using System.Collections.Concurrent;

​

public class UISynchronizationContext : SynchronizationContext

{

    private readonly BlockingCollection<(SendOrPostCallback, object)> _queue = new BlockingCollection<(SendOrPostCallback, object)>();

​

    public override void Post(SendOrPostCallback d, object state)

    {

        _queue.Add((d, state));

    }

​

    public override void Send(SendOrPostCallback d, object state)

    {

        d(state);

    }

​

    public void RunMessageLoop()

    {

        foreach (var (callback, state) in _queue.GetConsumingEnumerable())

        {

            callback(state);

        }

    }

     public async Task RunMessageLoopAsync()

    {

        foreach (var (callback, state) in _queue.GetConsumingEnumerable())

        {

            callback(state);

            await Task.Yield(); // Yield to allow other tasks to run

        }

    }

​

    public void StopMessageLoop()

    {

        _queue.CompleteAdding();

    }

}

​

public class AsyncHelper

{

    public static T RunSynchronously<T>(Func<Task<T>> callable)

    {

        // Capture the current synchronization context

        var currentContext = SynchronizationContext.Current;

        Console.WriteLine($"RunSynchronously context {currentContext} saved");

        try

        {

            SynchronizationContext tempContext = null;

            //tempContext = currentContext; // UNCOMMENT THIS TO EXPERIENCE THE DEADLOCK

            // Set the synchronization context to null to avoid deadlocks

            SynchronizationContext.SetSynchronizationContext(tempContext);

            Console.WriteLine($"Before callable tid {System.Environment.CurrentManagedThreadId}"); 

            // Execute the async method and get the result

            var task = callable().ConfigureAwait(false);

            Console.WriteLine($"After callable started tid {System.Environment.CurrentManagedThreadId}");          

            var result = task.GetAwaiter().GetResult();

            Console.WriteLine($"Returning callable result tid {System.Environment.CurrentManagedThreadId}");          

            return result;

        }

        finally

        {

            // Restore the original synchronization context

            Console.WriteLine($"RunSynchronously context {currentContext} restored");

            SynchronizationContext.SetSynchronizationContext(currentContext);

        }

    }

}

​

// Example usage

public class Program

{

    public static async Task Delay(int ms){

                      Console.WriteLine($"Before Delay tid {System.Environment.CurrentManagedThreadId}"); 

         await Task.Delay(ms); // Simulate async work

                          Console.WriteLine($"After Delay tid {System.Environment.CurrentManagedThreadId}"); 

    }

    public static async Task<int> AsyncMethod()

    {

                  Console.WriteLine($"Before await tid {System.Environment.CurrentManagedThreadId}"); 

        await Delay(1000); 

                  Console.WriteLine($"Await continuation tid {System.Environment.CurrentManagedThreadId}"); 

        return 42;

    }

​

     public static async Task Main(string[] args)

    {

        var uiContext = new UISynchronizationContext();

        SynchronizationContext.SetSynchronizationContext(uiContext);

​

        var task = AsyncMethod();

​

        var messageLoopTask = uiContext.RunMessageLoopAsync();

​

        int result = await task;

        Console.WriteLine($"Async Result: {result}");

         Console.WriteLine($"Sync Result: {AsyncHelper.RunSynchronously(AsyncMethod)}");

        uiContext.StopMessageLoop();

        await messageLoopTask;

    }

​

    public static async Task  Main2()

    {

        var uiContext = new UISynchronizationContext();

        SynchronizationContext.SetSynchronizationContext(uiContext);

        uiContext.RunMessageLoop();

            Console.WriteLine($"Getting the result by awaiting: {await AsyncMethod()} \n###########\n");

        // now try to run it synchronously                        

        int result = AsyncHelper.RunSynchronously(AsyncMethod);

        Console.WriteLine($"Result: {result}");

            uiContext.StopMessageLoop();

    }

}