gircore · badcel · May 14, 2023 · May 13, 2023
diff --git a/src/Libs/GLib-2.0/Internal/MainLoopSynchronizationContext.cs b/src/Libs/GLib-2.0/Internal/MainLoopSynchronizationContext.cs
@@ -0,0 +1,35 @@
+using System;
+using System.Threading;
+
+namespace GLib.Internal;
+
+public sealed class MainLoopSynchronizationContext : SynchronizationContext
+{
+    public override SynchronizationContext CreateCopy()
+        => new MainLoopSynchronizationContext();
+
+    public override void Post(SendOrPostCallback d, object? state)
+        => ScheduleAction(() => d(state));
+
+    public override void Send(SendOrPostCallback d, object? state)
+        => throw new NotImplementedException();
+
+    private static void ScheduleAction(Action action)
+    {
+        var proxy = new SourceFuncNotifiedHandler(() =>
+        {
+            try
+            {
+                action();
+            }
+            catch (Exception ex)
+            {
+                UnhandledException.Raise(ex);
+            }
+
+            return false;
+        });
+
+        Functions.IdleAdd(Constants.PRIORITY_DEFAULT_IDLE, proxy.NativeCallback, IntPtr.Zero, proxy.DestroyNotify);
+    }
+}
diff --git a/src/Libs/GLib-2.0/Public/MainLoop.cs b/src/Libs/GLib-2.0/Public/MainLoop.cs
@@ -1,4 +1,6 @@
-namespace GLib;
+using System.Threading;
+
+namespace GLib;
 
 public sealed partial class MainLoop
 {
@@ -21,5 +23,21 @@ public MainContext GetContext()
 
     public void Run() => Internal.MainLoop.Run(Handle);
 
+    public void RunWithSynchronizationContext()
+    {
+        var original = SynchronizationContext.Current;
+
+        SynchronizationContext.SetSynchronizationContext(new Internal.MainLoopSynchronizationContext());
+
+        try
+        {
+            Run();
+        }
+        finally
+        {
+            SynchronizationContext.SetSynchronizationContext(original);
+        }
+    }
+
     public void Quit() => Internal.MainLoop.Quit(Handle);
 }
diff --git a/src/Libs/Gio-2.0/Public/Application.cs b/src/Libs/Gio-2.0/Public/Application.cs
@@ -1,4 +1,6 @@
-namespace Gio;
+using System.Threading;
+
+namespace Gio;
 
 public partial class Application
 {
@@ -11,4 +13,20 @@ public int Run()
     {
         return Internal.Application.Run(Handle, 0, new string[0]);
     }
+
+    public int RunWithSynchronizationContext()
+    {
+        var original = SynchronizationContext.Current;
+
+        SynchronizationContext.SetSynchronizationContext(new GLib.Internal.MainLoopSynchronizationContext());
+
+        try
+        {
+            return Run();
+        }
+        finally
+        {
+            SynchronizationContext.SetSynchronizationContext(original);
+        }
+    }
 }
diff --git a/src/Tests/Libs/GLib-2.0.Tests/SynchronizationContextTest.cs b/src/Tests/Libs/GLib-2.0.Tests/SynchronizationContextTest.cs
@@ -0,0 +1,68 @@
+using System;
+using System.Threading.Tasks;
+using FluentAssertions;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace GLib.Tests;
+
+[TestClass, TestCategory("IntegrationTest")]
+public class SynchronizationContextTest : Test
+{
+    [TestMethod]
+    public void AsyncMethodIsExecutedOnMainLoopThread()
+    {
+        var mainLoop = new MainLoop();
+        var context = mainLoop.GetContext();
+        var source = Functions.TimeoutSourceNew(1);
+        source.Attach(context);
+
+        int? resumeThread = null;
+        source.SetCallback(() =>
+        {
+            AsyncMethod(() =>
+            {
+                resumeThread = System.Threading.Thread.CurrentThread.ManagedThreadId;
+                mainLoop.Quit();
+            });
+            return false;
+        });
+
+        mainLoop.RunWithSynchronizationContext();
+
+        resumeThread.Should().Be(System.Threading.Thread.CurrentThread.ManagedThreadId);
+    }
+
+    [TestMethod]
+    public void ExceptionInAsyncMethodCanBeHandledViaUnhandledExceptionHandler()
+    {
+        var mainLoop = new MainLoop();
+        var context = mainLoop.GetContext();
+        var source = Functions.TimeoutSourceNew(1);
+        source.Attach(context);
+        source.SetCallback(() =>
+        {
+            AsyncMethod(() =>
+            {
+                throw new Exception();
+            });
+            return false;
+        });
+
+        var exceptionCaught = false;
+        UnhandledException.SetHandler(e =>
+        {
+            exceptionCaught = true;
+            mainLoop.Quit();
+        });
+
+        mainLoop.RunWithSynchronizationContext();
+
+        exceptionCaught.Should().BeTrue();
+    }
+
+    private static async void AsyncMethod(Action finish)
+    {
+        await Task.Delay(1);
+        finish();
+    }
+}