fix: resume interaction task handlers on the captured context (#4409)

## What kind of change does this PR introduce?

Bug fix.

## What is the new behavior?

`Interaction.RegisterHandler(Func<..., Task>)` now
resumes the async handler on the captured `SynchronizationContext`. A
handler registered from a UI thread runs its body back on that UI
context, so it can touch UI-only APIs without re-dispatching. The
handler still yields off the current scheduler trampoline before running
(see #4351).

## What is the current behavior?

After the interaction performance refactor, the overload awaited an
internal `YieldToCurrentContext()` with `.ConfigureAwait(false)`.
`Task.Yield()` posts the continuation back to the captured context, but
the outer `.ConfigureAwait(false)` discarded it, so the handler resumed
on a thread-pool thread. UI handlers then failed unless they manually
marshalled back to the UI thread. Closes #4393.

## What might this PR break?

None. The handler still yields before running, so the #4351
trampoline-avoidance behaviour is preserved; only the resumption thread
is corrected back to the captured context, matching the documented and
pre-refactor behaviour.

## Checklist

- [x] I have read the Contribute guide
- [x] Tests have been added or updated (for bug fixes / features)
- [ ] Docs have been added or updated (for bug fixes / features)
- [x] Changes target the `main` branch
- [x] PR title follows Conventional Commits

## Additional information

- Fix: `await Task.Yield()` directly instead of awaiting a
`Task`-returning helper. `Task.Yield()` yields off the trampoline while
resuming on the captured context; a bare `Task` await cannot use
`ConfigureAwait(false)` without re-introducing the bug (and awaiting a
`Task` without it trips the repo's ConfigureAwait analyzer). The
now-dead `YieldToCurrentContext` helper is removed.
- Verified by test, not reasoning: reintroducing
`.ConfigureAwait(false)` on the yield makes the new context test fail
(the handler observes a null / thread-pool context); the fix makes it
pass. The #4351 ordering test stays green in both, confirming the yield
is preserved.
- Coverage: `Interaction.cs` is at 100% line (58/58) and 100% branch
(8/8) coverage, measured across `ReactiveUI.Tests` (net9.0).
- The new tests install a single-threaded `SynchronizationContext` to
assert resumption on the captured context on Linux/CI; a real UI
dispatcher (WPF/WinUI) exhibits the same contract but is not exercised
directly here.

Author: glennawatson

src/ReactiveUI.Shared/Interactions/Interaction.cs

@@ -118,16 +118,17 @@ public IDisposable RegisterHandler(Func, Ta
 
         return RegisterHandlerCore(ContentHandler);
 
-        // Yield before invoking the async handler so it is not run inside the current scheduler
-        // trampoline (see #4351).
         IObservable<RxVoid> ContentHandler(IInteractionContext<TInput, TOutput> interaction) =>
             new TaskUnitObservable(InvokeAsync(interaction, handler));
 
         static async Task InvokeAsync(
             IInteractionContext<TInput, TOutput> interaction,
             Func<IInteractionContext<TInput, TOutput>, Task> asyncHandler)
         {
-            await YieldToCurrentContext().ConfigureAwait(false);
+            // Yield so the handler is not invoked inside the current scheduler trampoline (see #4351). Task.Yield
+            // resumes on the captured SynchronizationContext, so a handler registered from a UI thread runs back on
+            // that context instead of a thread-pool thread (see #4393); ConfigureAwait(false) here would discard it.
+            await Task.Yield();
             await asyncHandler(interaction).ConfigureAwait(false);
         }
     }
@@ -169,10 +170,6 @@ protected Func, IObservable>[] GetH
     protected virtual IOutputContext<TInput, TOutput> GenerateContext(TInput input) =>
         new InteractionContext<TInput, TOutput>(input);
 
-    /// Yields once so asynchronous handlers are not invoked inside the current scheduler trampoline.
-    /// A task that completes after the current context has yielded.
-    private static async Task YieldToCurrentContext() => await Task.Yield();
-
     /// Registers a normalized interaction handler that produces a  stream.
     /// The normalized handler.
     /// A disposable which unregisters the handler.

src/tests/ReactiveUI.Tests/InteractionsTest.cs

@@ -3,6 +3,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for full license information.
 
+using System.Collections.Concurrent;
 using ReactiveUI.Tests.Utilities.Schedulers;
 using TUnit.Core.Executors;
 
@@ -270,4 +271,117 @@ public async Task UnhandledInteractionsShouldCauseException()
             await Assert.That(ex.Input).IsEqualTo("bar");
         }
     }
+
+    /// 
+    /// A task-based handler registered while a  is installed resumes on that
+    /// captured context rather than on a thread-pool thread, so UI handlers run on the UI thread (see issue #4393).
+    /// 
+    /// A  representing the asynchronous operation.
+    [Test]
+    public async Task TaskHandlerResumesOnCapturedSynchronizationContext()
+    {
+        using var uiContext = new SingleThreadedSynchronizationContext();
+        var observedContext = new TaskCompletionSource<SynchronizationContext?>(TaskCreationOptions.RunContinuationsAsynchronously);
+        var completed = new TaskCompletionSource<RxVoid>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        uiContext.Post(
+            static state =>
+            {
+                var (observed, done) = ((TaskCompletionSource<SynchronizationContext?>, TaskCompletionSource<RxVoid>))state!;
+                var interaction = new Interaction<RxVoid, RxVoid>();
+                _ = interaction.RegisterHandler(async context =>
+                {
+                    _ = observed.TrySetResult(SynchronizationContext.Current);
+                    context.SetOutput(RxVoid.Default);
+                    await Task.CompletedTask;
+                });
+
+                _ = interaction.Handle(RxVoid.Default).Subscribe(
+                    _ => done.TrySetResult(RxVoid.Default),
+                    done.SetException);
+            },
+            (observedContext, completed));
+
+        var handlerContext = await observedContext.Task;
+        _ = await completed.Task;
+
+        await Assert.That(handlerContext).IsSameReferenceAs(uiContext);
+    }
+
+    /// 
+    /// A task-based handler yields before running, so it is not invoked inside the subscription that triggers the
+    /// interaction (see issue #4351); the handler only runs once the triggering call has unwound.
+    /// 
+    /// A  representing the asynchronous operation.
+    [Test]
+    public async Task TaskHandlerDoesNotRunInsideTriggeringSubscription()
+    {
+        const string afterSubscribeMarker = "after-subscribe";
+        const string handlerMarker = "handler";
+        const int expectedStepCount = 2;
+
+        using var uiContext = new SingleThreadedSynchronizationContext();
+        var order = new List<string>();
+        var completed = new TaskCompletionSource<IReadOnlyList<string>>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+        uiContext.Post(
+            static state =>
+            {
+                var (steps, done) = ((List<string>, TaskCompletionSource<IReadOnlyList<string>>))state!;
+                var interaction = new Interaction<RxVoid, string>();
+                _ = interaction.RegisterHandler(async context =>
+                {
+                    steps.Add(handlerMarker);
+                    context.SetOutput(ResultOutput);
+                    await Task.CompletedTask;
+                });
+
+                _ = interaction.Handle(RxVoid.Default).Subscribe(
+                    _ => done.TrySetResult(steps),
+                    done.SetException);
+
+                // Recorded before the yielded handler continuation is pumped, so it must precede the handler marker.
+                steps.Add(afterSubscribeMarker);
+            },
+            (order, completed));
+
+        var sequence = await completed.Task;
+
+        using (Assert.Multiple())
+        {
+            await Assert.That(sequence).Count().IsEqualTo(expectedStepCount);
+            await Assert.That(sequence[0]).IsEqualTo(afterSubscribeMarker);
+            await Assert.That(sequence[1]).IsEqualTo(handlerMarker);
+        }
+    }
+
+    /// A minimal single-threaded  backed by one pumped worker thread.
+    private sealed class SingleThreadedSynchronizationContext : SynchronizationContext, IDisposable
+    {
+        /// The queue of work items pumped on the worker thread in order.
+        private readonly BlockingCollection<Action> _queue = new();
+
+        /// Initializes a new instance of the  class.
+        public SingleThreadedSynchronizationContext()
+        {
+            var thread = new Thread(Run) { IsBackground = true, Name = "interaction-ui" };
+            thread.Start();
+        }
+
+        /// 
+        public override void Post(SendOrPostCallback d, object? state) => _queue.Add(() => d(state));
+
+        /// 
+        public void Dispose() => _queue.CompleteAdding();
+
+        /// Pumps queued work on the worker thread with this context installed as current.
+        private void Run()
+        {
+            SynchronizationContext.SetSynchronizationContext(this);
+            foreach (var work in _queue.GetConsumingEnumerable())
+            {
+                work();
+            }
+        }
+    }
 }