mainthread for requests

src/Shiny.Mediator.Maui/MauiMediatorExtensions.cs

@@ -8,6 +8,11 @@ namespace Shiny.Mediator;
 
 public static class MauiMediatorExtensions
 {
+    /// <summary>
+    /// Fire & Forget task pattern that logs errors
+    /// </summary>
+    /// <param name="task"></param>
+    /// <param name="errorLogger"></param>
     public static void RunInBackground(this Task task, ILogger errorLogger)
         => task.ContinueWith(x =>
         {
@@ -28,7 +33,7 @@ public static ShinyConfigurator UseMaui(this ShinyConfigurator cfg, bool include
         if (includeStandardMiddleware)
         {
             cfg.AddEventExceptionHandlingMiddleware();
-            cfg.AddMainThreadEventMiddleware();
+            cfg.AddMainThreadMiddleware();
 
             cfg.AddUserNotificationExceptionMiddleware();
             cfg.AddTimedMiddleware();
@@ -46,12 +51,17 @@ public static ShinyConfigurator AddTimedMiddleware(this ShinyConfigurator cfg)
 
     public static ShinyConfigurator AddEventExceptionHandlingMiddleware(this ShinyConfigurator cfg)
         => cfg.AddOpenEventMiddleware(typeof(ExceptionHandlerEventMiddleware<>));
-
 
-    public static ShinyConfigurator AddMainThreadEventMiddleware(this ShinyConfigurator cfg)
-        => cfg.AddOpenEventMiddleware(typeof(MainTheadEventMiddleware<>));
-
-
+
+    public static ShinyConfigurator AddMainThreadMiddleware(this ShinyConfigurator cfg)
+    {
+        cfg.AddOpenEventMiddleware(typeof(MainTheadEventMiddleware<>));
+        cfg.AddOpenRequestMiddleware(typeof(MainThreadRequestHandler<,>));
+
+        return cfg;
+    }
+
+
     public static ShinyConfigurator AddOfflineAvailabilityMiddleware(this ShinyConfigurator cfg)
     {
         cfg.Services.TryAddSingleton(Connectivity.Current);

src/Shiny.Mediator.Maui/Middleware/MainThreadRequestHandler.cs

@@ -0,0 +1,40 @@
+namespace Shiny.Mediator.Middleware;
+
+
+public class MainThreadRequestHandler<TRequest, TResult> : IRequestMiddleware<TRequest, TResult> where TRequest : IRequest<TResult>
+{
+    public async Task<TResult> Process(
+        TRequest request, 
+        RequestHandlerDelegate<TResult> next, 
+        IRequestHandler requestHandler,
+        CancellationToken cancellationToken
+    )
+    {
+        var attr = requestHandler.GetHandlerHandleMethodAttribute<TRequest, MainThreadAttribute>();
+        TResult result = default!;
+
+        if (attr != null)
+        {
+            var tcs = new TaskCompletionSource<TResult>();
+            MainThread.BeginInvokeOnMainThread(async () =>
+            {
+                try
+                {
+                    var nextResult = await next().ConfigureAwait(false);
+                    tcs.SetResult(nextResult);
+                }
+                catch (Exception ex)
+                {
+                    tcs.SetException(ex);
+                }
+            });
+            result = await tcs.Task.ConfigureAwait(false);
+        }
+        else
+        {
+            result = await next().ConfigureAwait(false);
+        }
+
+        return result;
+    }
+}