Use single threaded dispatcher to make sure pausing does not happen concurently with disposal.

Author: ilonatommy

src/Components/Server/src/Circuits/CircuitPersistenceManager.cs

@@ -21,31 +21,34 @@ internal partial class CircuitPersistenceManager(
 {
     public async Task PauseCircuitAsync(CircuitHost circuit, bool saveStateToClient = false, CancellationToken cancellation = default)
     {
-        if (circuit.IsDisposed())
+        await circuit.Renderer.Dispatcher.InvokeAsync(async () =>
         {
-            return;
-        }
+            if (circuit.IsDisposed())
+            {
+                return;
+            }
 
-        var renderer = circuit.Renderer;
-        var persistenceManager = circuit.Services.GetRequiredService<ComponentStatePersistenceManager>();
-        var collector = new CircuitPersistenceManagerCollector(circuitOptions, serverComponentSerializer, circuit.Renderer);
-        using var subscription = persistenceManager.State.RegisterOnPersisting(
-            collector.PersistRootComponents,
-            RenderMode.InteractiveServer);
+            var renderer = circuit.Renderer;
+            var persistenceManager = circuit.Services.GetRequiredService<ComponentStatePersistenceManager>();
+            var collector = new CircuitPersistenceManagerCollector(circuitOptions, serverComponentSerializer, circuit.Renderer);
+            using var subscription = persistenceManager.State.RegisterOnPersisting(
+                collector.PersistRootComponents,
+                RenderMode.InteractiveServer);
 
-        await persistenceManager.PersistStateAsync(collector, renderer);
+            await persistenceManager.PersistStateAsync(collector, renderer);
 
-        if (saveStateToClient)
-        {
-            await SaveStateToClient(circuit, collector.PersistedCircuitState, cancellation);
-        }
-        else
-        {
-            await circuitPersistenceProvider.PersistCircuitAsync(
-                circuit.CircuitId,
-                collector.PersistedCircuitState,
-                cancellation);
-        }
+            if (saveStateToClient)
+            {
+                await SaveStateToClient(circuit, collector.PersistedCircuitState, cancellation);
+            }
+            else
+            {
+                await circuitPersistenceProvider.PersistCircuitAsync(
+                    circuit.CircuitId,
+                    collector.PersistedCircuitState,
+                    cancellation);
+            }
+        });
     }
 
     internal async Task SaveStateToClient(CircuitHost circuit, PersistedCircuitState state, CancellationToken cancellation = default)