fix: Task Scheduler Queue Task called when SychronizationContext disposed

src/Paramore.Brighter/Tasks/BrighterSynchronizationContext.cs

@@ -145,9 +145,9 @@ public override void Post(SendOrPostCallback callback, object? state)
 
             //just execute inline
             // current thread already owns the context, so just execute inline to prevent deadlocks
-            //if (BrighterSynchronizationHelper.Current == SynchronizationHelper)
-                //SynchronizationHelper.ExecuteImmediately(contextCallback, state);
-            //else
+            if (BrighterSynchronizationHelper.Current == SynchronizationHelper)
+                SynchronizationHelper.ExecuteImmediately(contextCallback, state);
+            else
                 base.Post(callback, state);
 
         }

src/Paramore.Brighter/Tasks/BrighterTaskScheduler.cs

@@ -18,6 +18,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Threading;
 using System.Threading.Tasks;
 
 namespace Paramore.Brighter.Tasks;
@@ -60,13 +61,14 @@ protected override void QueueTask(Task task)
 
        var queued = _synchronizationHelper.Enqueue((Task)task, false);
        if (!queued)
-   {
+       {
            Debug.IndentLevel = 1;
            Debug.WriteLine($"BrighterTaskScheduler: QueueTask Failed to queue task {task.ToString()} on {System.Threading.Thread.CurrentThread.ManagedThreadId}");
            Debug.IndentLevel = 0;
+           new Thread(TryExecuteNewThread) { IsBackground = true }.Start(task);
        }
     }
-
+    
     /// <summary>
     /// Attempts to execute the specified task on the current thread.
     /// </summary>
@@ -103,4 +105,28 @@ public void DoTryExecuteTask(Task task)
 
         TryExecuteTask(task);
     }
+
+    /// <summary>
+    /// In a new thread, attempts to execute the specified task.
+    /// </summary>
+    /// <remarks>
+    /// This is a little "Hail Mary" to try and execute a task that has failed to queue because we have already completed the synchronization context.
+    /// Seems to be caused by an Exection Context that has our scheduler as the default, as it fools ConfigureAwait
+    /// </remarks>
+    /// <param name="obj"></param>
+    /// <exception cref="ArgumentNullException"></exception>
+    private void TryExecuteNewThread(object? obj)
+    {
+        var task = obj as Task;
+        if (task  == null)
+        {
+            throw new ArgumentNullException(nameof(obj));
+        }
+
+        Debug.IndentLevel = 1;
+        Debug.WriteLine($"BrighterTaskScheduler: Use TryExecuteNewThread for {task} on thread {System.Threading.Thread.CurrentThread.ManagedThreadId}");
+        Debug.IndentLevel = 0;
+
+        TryExecuteTask(task);
+    }
 }

tests/Paramore.Brighter.Core.Tests/Tasks/BrighterSynchronizationContextsTests.cs

@@ -6,15 +6,13 @@
 #endregion
 
 using System;
-using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
 using FluentAssertions;
-using Paramore.Brighter.ServiceActivator;
 using Paramore.Brighter.Tasks;
 using Xunit;
 
-namespace Paramore.Brighter.Core.Tests.SynchronizationContext;
+namespace Paramore.Brighter.Core.Tests.Tasks;
 
 public class BrighterSynchronizationContextsTests
 {
@@ -123,6 +121,20 @@ public void Run_AsyncTaskWithResult_BlockingCode_Still_Ends()
         resumed.Should().BeTrue();
         result.Should().Be(17);
     }
+
+    [Fact]
+    public void Run_AsyncTaskWithResultAndConfigurateAwait_BlockingCode_Still_Ends()
+    {
+        bool resumed = false;
+        var result = BrighterSynchronizationHelper.Run(async () =>
+        {
+            await Task.Delay(50).ConfigureAwait(false);
+            resumed = true;
+            return 17;
+        });
+        resumed.Should().BeTrue();
+        result.Should().Be(17);
+    }
 
     [Fact]
     public void Run_AsyncTaskWithResult_ContainsMultipleAsyncTasks_Still_Ends()