Don't release SemaphoreSlim when it is canceled (#12818)

ajaybhargavb · web-flow · commit c605d6cf6387 · 2019-08-14T12:40:44.000-07:00
* Don't release SemaphoreSlim when it is cancelled

* fixed tests

* Rebased

* Updated ref

* mark test as flaky
diff --git a/src/Components/Components/ref/Microsoft.AspNetCore.Components.netcoreapp3.0.cs b/src/Components/Components/ref/Microsoft.AspNetCore.Components.netcoreapp3.0.cs
@@ -97,6 +97,7 @@ protected void StateHasChanged() { }
     public abstract partial class Dispatcher
     {
         protected Dispatcher() { }
+        public void AssertAccess() { }
         public abstract bool CheckAccess();
         public static Microsoft.AspNetCore.Components.Dispatcher CreateDefault() { throw null; }
         public abstract System.Threading.Tasks.Task InvokeAsync(System.Action workItem);
diff --git a/src/Components/Components/ref/Microsoft.AspNetCore.Components.netstandard2.0.cs b/src/Components/Components/ref/Microsoft.AspNetCore.Components.netstandard2.0.cs
@@ -97,6 +97,7 @@ protected void StateHasChanged() { }
     public abstract partial class Dispatcher
     {
         protected Dispatcher() { }
+        public void AssertAccess() { }
         public abstract bool CheckAccess();
         public static Microsoft.AspNetCore.Components.Dispatcher CreateDefault() { throw null; }
         public abstract System.Threading.Tasks.Task InvokeAsync(System.Action workItem);
diff --git a/src/Components/Components/src/Dispatcher.cs b/src/Components/Components/src/Dispatcher.cs
@@ -23,6 +23,20 @@ public abstract class Dispatcher
         /// </summary>
         internal event UnhandledExceptionEventHandler UnhandledException;
 
+        /// <summary>
+        /// Validates that the currently executing code is running inside the dispatcher.
+        /// </summary>
+        public void AssertAccess()
+        {
+            if (!CheckAccess())
+            {
+                throw new InvalidOperationException(
+                    "The current thread is not associated with the Dispatcher. " +
+                    "Use InvokeAsync() to switch execution to the Dispatcher when " +
+                    "triggering rendering or component state.");
+            }
+        }
+
         /// <summary>
         /// Returns a value that determines whether using the dispatcher to invoke a work item is required
         /// from the current context.
diff --git a/src/Components/Components/src/Rendering/Renderer.cs b/src/Components/Components/src/Rendering/Renderer.cs
@@ -209,7 +209,7 @@ private ComponentState AttachAndInitComponent(IComponent component, int parentCo
         /// </returns>
         public virtual Task DispatchEventAsync(ulong eventHandlerId, EventFieldInfo fieldInfo, EventArgs eventArgs)
         {
-            EnsureSynchronizationContext();
+            Dispatcher.AssertAccess();
 
             if (!_eventBindings.TryGetValue(eventHandlerId, out var callback))
             {
@@ -337,7 +337,7 @@ internal void AssignEventHandlerId(ref RenderTreeFrame frame)
         /// <param name="renderFragment">A <see cref="RenderFragment"/> that will supply the updated UI contents.</param>
         internal void AddToRenderQueue(int componentId, RenderFragment renderFragment)
         {
-            EnsureSynchronizationContext();
+            Dispatcher.AssertAccess();
 
             var componentState = GetOptionalComponentState(componentId);
             if (componentState == null)
@@ -374,21 +374,6 @@ private ulong FindLatestEventHandlerIdInChain(ulong eventHandlerId)
             return eventHandlerId;
         }
 
-        private void EnsureSynchronizationContext()
-        {
-            // Render operations are not thread-safe, so they need to be serialized by the dispatcher.
-            // Plus, any other logic that mutates state accessed during rendering also
-            // needs not to run concurrently with rendering so should be dispatched to
-            // the renderer's sync context.
-            if (!Dispatcher.CheckAccess())
-            {
-                throw new InvalidOperationException(
-                    "The current thread is not associated with the Dispatcher. " +
-                    "Use Invoke() or InvokeAsync() to switch execution to the Dispatcher when " +
-                    "triggering rendering or modifying any state accessed during rendering.");
-            }
-        }
-
         private ComponentState GetRequiredComponentState(int componentId)
             => _componentStateById.TryGetValue(componentId, out var componentState)
                 ? componentState
@@ -414,7 +399,7 @@ protected virtual void ProcessPendingRender()
 
         private void ProcessRenderQueue()
         {
-            EnsureSynchronizationContext();
+            Dispatcher.AssertAccess();
 
             if (_isBatchInProgress)
             {
diff --git a/src/Components/Server/src/Circuits/CircuitHost.cs b/src/Components/Server/src/Circuits/CircuitHost.cs
@@ -18,7 +18,6 @@ namespace Microsoft.AspNetCore.Components.Server.Circuits
 {
     internal class CircuitHost : IAsyncDisposable
     {
-        private readonly SemaphoreSlim HandlerLock = new SemaphoreSlim(1);
         private readonly IServiceScope _scope;
         private readonly CircuitOptions _options;
         private readonly CircuitHandler[] _circuitHandlers;
@@ -187,143 +186,113 @@ private async Task OnCircuitOpenedAsync(CancellationToken cancellationToken)
         {
             Log.CircuitOpened(_logger, Circuit.Id);
 
-            await HandlerLock.WaitAsync(cancellationToken);
+            Renderer.Dispatcher.AssertAccess();
 
-            try
-            {
-                List<Exception> exceptions = null;
+            List<Exception> exceptions = null;
 
-                for (var i = 0; i < _circuitHandlers.Length; i++)
+            for (var i = 0; i < _circuitHandlers.Length; i++)
+            {
+                var circuitHandler = _circuitHandlers[i];
+                try
                 {
-                    var circuitHandler = _circuitHandlers[i];
-                    try
-                    {
-                        await circuitHandler.OnCircuitOpenedAsync(Circuit, cancellationToken);
-                    }
-                    catch (Exception ex)
-                    {
-                        Log.CircuitHandlerFailed(_logger, circuitHandler, nameof(CircuitHandler.OnCircuitOpenedAsync), ex);
-                        exceptions ??= new List<Exception>();
-                        exceptions.Add(ex);
-                    }
+                    await circuitHandler.OnCircuitOpenedAsync(Circuit, cancellationToken);
                 }
-
-                if (exceptions != null)
+                catch (Exception ex)
                 {
-                    throw new AggregateException("Encountered exceptions while executing circuit handlers.", exceptions);
+                    Log.CircuitHandlerFailed(_logger, circuitHandler, nameof(CircuitHandler.OnCircuitOpenedAsync), ex);
+                    exceptions ??= new List<Exception>();
+                    exceptions.Add(ex);
                 }
             }
-            finally
+
+            if (exceptions != null)
             {
-                HandlerLock.Release();
+                throw new AggregateException("Encountered exceptions while executing circuit handlers.", exceptions);
             }
         }
 
         public async Task OnConnectionUpAsync(CancellationToken cancellationToken)
         {
             Log.ConnectionUp(_logger, Circuit.Id, Client.ConnectionId);
 
-            await HandlerLock.WaitAsync(cancellationToken);
+            Renderer.Dispatcher.AssertAccess();
+            
+            List<Exception> exceptions = null;
 
-            try
+            for (var i = 0; i < _circuitHandlers.Length; i++)
             {
-                List<Exception> exceptions = null;
-
-                for (var i = 0; i < _circuitHandlers.Length; i++)
+                var circuitHandler = _circuitHandlers[i];
+                try
                 {
-                    var circuitHandler = _circuitHandlers[i];
-                    try
-                    {
-                        await circuitHandler.OnConnectionUpAsync(Circuit, cancellationToken);
-                    }
-                    catch (Exception ex)
-                    {
-                        Log.CircuitHandlerFailed(_logger, circuitHandler, nameof(CircuitHandler.OnConnectionUpAsync), ex);
-                        exceptions ??= new List<Exception>();
-                        exceptions.Add(ex);
-                    }
+                    await circuitHandler.OnConnectionUpAsync(Circuit, cancellationToken);
                 }
-
-                if (exceptions != null)
+                catch (Exception ex)
                 {
-                    throw new AggregateException("Encountered exceptions while executing circuit handlers.", exceptions);
+                    Log.CircuitHandlerFailed(_logger, circuitHandler, nameof(CircuitHandler.OnConnectionUpAsync), ex);
+                    exceptions ??= new List<Exception>();
+                    exceptions.Add(ex);
                 }
             }
-            finally
+
+            if (exceptions != null)
             {
-                HandlerLock.Release();
+                throw new AggregateException("Encountered exceptions while executing circuit handlers.", exceptions);
             }
         }
 
         public async Task OnConnectionDownAsync(CancellationToken cancellationToken)
         {
             Log.ConnectionDown(_logger, Circuit.Id, Client.ConnectionId);
 
-            await HandlerLock.WaitAsync(cancellationToken);
+            Renderer.Dispatcher.AssertAccess();
+            
+            List<Exception> exceptions = null;
 
-            try
+            for (var i = 0; i < _circuitHandlers.Length; i++)
             {
-                List<Exception> exceptions = null;
-
-                for (var i = 0; i < _circuitHandlers.Length; i++)
+                var circuitHandler = _circuitHandlers[i];
+                try
                 {
-                    var circuitHandler = _circuitHandlers[i];
-                    try
-                    {
-                        await circuitHandler.OnConnectionDownAsync(Circuit, cancellationToken);
-                    }
-                    catch (Exception ex)
-                    {
-                        Log.CircuitHandlerFailed(_logger, circuitHandler, nameof(CircuitHandler.OnConnectionDownAsync), ex);
-                        exceptions ??= new List<Exception>();
-                        exceptions.Add(ex);
-                    }
+                    await circuitHandler.OnConnectionDownAsync(Circuit, cancellationToken);
                 }
-
-                if (exceptions != null)
+                catch (Exception ex)
                 {
-                    throw new AggregateException("Encountered exceptions while executing circuit handlers.", exceptions);
+                    Log.CircuitHandlerFailed(_logger, circuitHandler, nameof(CircuitHandler.OnConnectionDownAsync), ex);
+                    exceptions ??= new List<Exception>();
+                    exceptions.Add(ex);
                 }
             }
-            finally
+
+            if (exceptions != null)
             {
-                HandlerLock.Release();
+                throw new AggregateException("Encountered exceptions while executing circuit handlers.", exceptions);
             }
         }
 
         private async Task OnCircuitDownAsync(CancellationToken cancellationToken)
         {
             Log.CircuitClosed(_logger, Circuit.Id);
 
-            await HandlerLock.WaitAsync(cancellationToken);
+            List<Exception> exceptions = null;
 
-            try
+            for (var i = 0; i < _circuitHandlers.Length; i++)
             {
-                List<Exception> exceptions = null;
-
-                for (var i = 0; i < _circuitHandlers.Length; i++)
+                var circuitHandler = _circuitHandlers[i];
+                try
                 {
-                    var circuitHandler = _circuitHandlers[i];
-                    try
-                    {
-                        await circuitHandler.OnCircuitClosedAsync(Circuit, cancellationToken);
-                    }
-                    catch (Exception ex)
-                    {
-                        Log.CircuitHandlerFailed(_logger, circuitHandler, nameof(CircuitHandler.OnCircuitClosedAsync), ex);
-                        exceptions ??= new List<Exception>();
-                        exceptions.Add(ex);
-                    }
+                    await circuitHandler.OnCircuitClosedAsync(Circuit, cancellationToken);
                 }
-
-                if (exceptions != null)
+                catch (Exception ex)
                 {
-                    throw new AggregateException("Encountered exceptions while executing circuit handlers.", exceptions);
+                    Log.CircuitHandlerFailed(_logger, circuitHandler, nameof(CircuitHandler.OnCircuitClosedAsync), ex);
+                    exceptions ??= new List<Exception>();
+                    exceptions.Add(ex);
                 }
             }
-            finally
+
+            if (exceptions != null)
             {
-                HandlerLock.Release();
+                throw new AggregateException("Encountered exceptions while executing circuit handlers.", exceptions);
             }
         }
 
diff --git a/src/Components/Server/test/Circuits/CircuitRegistryTest.cs b/src/Components/Server/test/Circuits/CircuitRegistryTest.cs
@@ -270,46 +270,6 @@ public async Task Connect_WhileDisconnectIsInProgress()
             Assert.False(registry.DisconnectedCircuits.TryGetValue(circuitHost.CircuitId, out _));
         }
 
-        [Fact]
-        public async Task Connect_WhileDisconnectIsInProgress_SeriallyExecutesCircuitHandlers()
-        {
-            // Arrange
-            var circuitIdFactory = TestCircuitIdFactory.CreateTestFactory();
-
-            var registry = new TestCircuitRegistry(circuitIdFactory);
-            registry.BeforeDisconnect = new ManualResetEventSlim();
-            // This verifies that connection up \ down events on a circuit handler are always invoked serially.
-            var circuitHandler = new SerialCircuitHandler();
-            var tcs = new TaskCompletionSource<int>();
-
-            var circuitHost = TestCircuitHost.Create(circuitIdFactory.CreateCircuitId(), handlers: new[] { circuitHandler });
-            registry.Register(circuitHost);
-            var client = Mock.Of<IClientProxy>();
-            var newId = "new-connection";
-
-            // Act
-            var disconnect = Task.Run(() =>
-            {
-                var task = registry.DisconnectAsync(circuitHost, circuitHost.Client.ConnectionId);
-                tcs.SetResult(0);
-                return task;
-            });
-            var connect = Task.Run(async () =>
-            {
-                registry.BeforeDisconnect.Set();
-                await tcs.Task;
-                await registry.ConnectAsync(circuitHost.CircuitId, client, newId, default);
-            });
-            await Task.WhenAll(disconnect, connect);
-
-            // Assert
-            Assert.Single(registry.ConnectedCircuits.Values);
-            Assert.False(registry.DisconnectedCircuits.TryGetValue(circuitHost.CircuitId, out _));
-
-            Assert.True(circuitHandler.OnConnectionDownExecuted, "OnConnectionDownAsync should have been executed.");
-            Assert.True(circuitHandler.OnConnectionUpExecuted, "OnConnectionUpAsync should have been executed.");
-        }
-
         [Fact]
         public async Task DisconnectWhenAConnectIsInProgress()
         {
@@ -444,37 +404,5 @@ private static CircuitRegistry CreateRegistry(CircuitIdFactory factory = null)
                 NullLogger<CircuitRegistry>.Instance,
                 factory ?? TestCircuitIdFactory.CreateTestFactory());
         }
-
-        private class SerialCircuitHandler : CircuitHandler
-        {
-            private readonly SemaphoreSlim _sempahore = new SemaphoreSlim(1);
-
-            public bool OnConnectionUpExecuted { get; private set; }
-            public bool OnConnectionDownExecuted { get; private set; }
-
-            public override async Task OnConnectionUpAsync(Circuit circuit, CancellationToken cancellationToken)
-            {
-                Assert.True(await _sempahore.WaitAsync(0), "This should be serialized and consequently without contention");
-                await Task.Delay(10);
-
-                Assert.False(OnConnectionUpExecuted);
-                Assert.True(OnConnectionDownExecuted);
-                OnConnectionUpExecuted = true;
-
-                _sempahore.Release();
-            }
-
-            public override async Task OnConnectionDownAsync(Circuit circuit, CancellationToken cancellationToken)
-            {
-                Assert.True(await _sempahore.WaitAsync(0), "This should be serialized and consequently without contention");
-                await Task.Delay(10);
-
-                Assert.False(OnConnectionUpExecuted);
-                Assert.False(OnConnectionDownExecuted);
-                OnConnectionDownExecuted = true;
-
-                _sempahore.Release();
-            }
-        }
     }
 }
diff --git a/src/Components/test/E2ETest/ServerExecutionTests/InteropReliabilityTests.cs b/src/Components/test/E2ETest/ServerExecutionTests/InteropReliabilityTests.cs
@@ -264,6 +264,7 @@ await Client.InvokeDotNetMethod(
         }
 
         [Fact]
+        [Flaky("https://github.com/aspnet/AspNetCore/issues/13086", FlakyOn.AzP.Windows)]
         public async Task ContinuesWorkingAfterInvalidAsyncReturnCallback()
         {
             // Arrange
diff --git a/src/Components/test/E2ETest/ServerExecutionTests/ServerComponentRenderingTest.cs b/src/Components/test/E2ETest/ServerExecutionTests/ServerComponentRenderingTest.cs
@@ -33,7 +33,7 @@ public void ThrowsIfRenderIsRequestedOutsideSyncContext()
             appElement.FindElement(By.Id("run-without-dispatch")).Click();
 
             Browser.Contains(
-                $"{typeof(InvalidOperationException).FullName}: The current thread is not associated with the Dispatcher. Use Invoke() or InvokeAsync() to switch execution to the Dispatcher when triggering rendering or modifying any state accessed during rendering.",
+                $"{typeof(InvalidOperationException).FullName}: The current thread is not associated with the Dispatcher. Use InvokeAsync() to switch execution to the Dispatcher when triggering rendering or component state.",
                 () => result.Text);
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -97,6 +97,7 @@ protected void StateHasChanged() { }`
`97`	`97`	`public abstract partial class Dispatcher`
`98`	`98`	`{`
`99`	`99`	`protected Dispatcher() { }`
	`100`	`+ public void AssertAccess() { }`
`100`	`101`	`public abstract bool CheckAccess();`
`101`	`102`	`public static Microsoft.AspNetCore.Components.Dispatcher CreateDefault() { throw null; }`
`102`	`103`	`public abstract System.Threading.Tasks.Task InvokeAsync(System.Action workItem);`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,6 @@ namespace Microsoft.AspNetCore.Components.Server.Circuits`
`18`	`18`	`{`
`19`	`19`	`internal class CircuitHost : IAsyncDisposable`
`20`	`20`	`{`
`21`		`- private readonly SemaphoreSlim HandlerLock = new SemaphoreSlim(1);`
`22`	`21`	`private readonly IServiceScope _scope;`
`23`	`22`	`private readonly CircuitOptions _options;`
`24`	`23`	`private readonly CircuitHandler[] _circuitHandlers;`
`@@ -187,143 +186,113 @@ private async Task OnCircuitOpenedAsync(CancellationToken cancellationToken)`
`187`	`186`	`{`
`188`	`187`	`Log.CircuitOpened(_logger, Circuit.Id);`
`189`	`188`
`190`		`- await HandlerLock.WaitAsync(cancellationToken);`
	`189`	`+ Renderer.Dispatcher.AssertAccess();`
`191`	`190`
`192`		`- try`
`193`		`- {`
`194`		`- List<Exception> exceptions = null;`
	`191`	`+ List<Exception> exceptions = null;`
`195`	`192`
`196`		`- for (var i = 0; i < _circuitHandlers.Length; i++)`
	`193`	`+ for (var i = 0; i < _circuitHandlers.Length; i++)`
	`194`	`+ {`
	`195`	`+ var circuitHandler = _circuitHandlers[i];`
	`196`	`+ try`
`197`	`197`	`{`
`198`		`- var circuitHandler = _circuitHandlers[i];`
`199`		`- try`
`200`		`- {`
`201`		`- await circuitHandler.OnCircuitOpenedAsync(Circuit, cancellationToken);`
`202`		`- }`
`203`		`- catch (Exception ex)`
`204`		`- {`
`205`		`- Log.CircuitHandlerFailed(_logger, circuitHandler, nameof(CircuitHandler.OnCircuitOpenedAsync), ex);`
`206`		`- exceptions ??= new List<Exception>();`
`207`		`- exceptions.Add(ex);`
`208`		`- }`
	`198`	`+ await circuitHandler.OnCircuitOpenedAsync(Circuit, cancellationToken);`
`209`	`199`	`}`
`210`		`-`
`211`		`- if (exceptions != null)`
	`200`	`+ catch (Exception ex)`
`212`	`201`	`{`
`213`		`- throw new AggregateException("Encountered exceptions while executing circuit handlers.", exceptions);`
	`202`	`+ Log.CircuitHandlerFailed(_logger, circuitHandler, nameof(CircuitHandler.OnCircuitOpenedAsync), ex);`
	`203`	`+ exceptions ??= new List<Exception>();`
	`204`	`+ exceptions.Add(ex);`
`214`	`205`	`}`
`215`	`206`	`}`
`216`		`- finally`
	`207`	`+`
	`208`	`+ if (exceptions != null)`
`217`	`209`	`{`
`218`		`- HandlerLock.Release();`
	`210`	`+ throw new AggregateException("Encountered exceptions while executing circuit handlers.", exceptions);`
`219`	`211`	`}`
`220`	`212`	`}`
`221`	`213`
`222`	`214`	`public async Task OnConnectionUpAsync(CancellationToken cancellationToken)`
`223`	`215`	`{`
`224`	`216`	`Log.ConnectionUp(_logger, Circuit.Id, Client.ConnectionId);`
`225`	`217`
`226`		`- await HandlerLock.WaitAsync(cancellationToken);`
	`218`	`+ Renderer.Dispatcher.AssertAccess();`
	`219`	`+`
	`220`	`+ List<Exception> exceptions = null;`
`227`	`221`
`228`		`- try`
	`222`	`+ for (var i = 0; i < _circuitHandlers.Length; i++)`
`229`	`223`	`{`
`230`		`- List<Exception> exceptions = null;`
`231`		`-`
`232`		`- for (var i = 0; i < _circuitHandlers.Length; i++)`
	`224`	`+ var circuitHandler = _circuitHandlers[i];`
	`225`	`+ try`
`233`	`226`	`{`
`234`		`- var circuitHandler = _circuitHandlers[i];`
`235`		`- try`
`236`		`- {`
`237`		`- await circuitHandler.OnConnectionUpAsync(Circuit, cancellationToken);`
`238`		`- }`
`239`		`- catch (Exception ex)`
`240`		`- {`
`241`		`- Log.CircuitHandlerFailed(_logger, circuitHandler, nameof(CircuitHandler.OnConnectionUpAsync), ex);`
`242`		`- exceptions ??= new List<Exception>();`
`243`		`- exceptions.Add(ex);`
`244`		`- }`
	`227`	`+ await circuitHandler.OnConnectionUpAsync(Circuit, cancellationToken);`
`245`	`228`	`}`
`246`		`-`
`247`		`- if (exceptions != null)`
	`229`	`+ catch (Exception ex)`
`248`	`230`	`{`
`249`		`- throw new AggregateException("Encountered exceptions while executing circuit handlers.", exceptions);`
	`231`	`+ Log.CircuitHandlerFailed(_logger, circuitHandler, nameof(CircuitHandler.OnConnectionUpAsync), ex);`
	`232`	`+ exceptions ??= new List<Exception>();`
	`233`	`+ exceptions.Add(ex);`
`250`	`234`	`}`
`251`	`235`	`}`
`252`		`- finally`
	`236`	`+`
	`237`	`+ if (exceptions != null)`
`253`	`238`	`{`
`254`		`- HandlerLock.Release();`
	`239`	`+ throw new AggregateException("Encountered exceptions while executing circuit handlers.", exceptions);`
`255`	`240`	`}`
`256`	`241`	`}`
`257`	`242`
`258`	`243`	`public async Task OnConnectionDownAsync(CancellationToken cancellationToken)`
`259`	`244`	`{`
`260`	`245`	`Log.ConnectionDown(_logger, Circuit.Id, Client.ConnectionId);`
`261`	`246`
`262`		`- await HandlerLock.WaitAsync(cancellationToken);`
	`247`	`+ Renderer.Dispatcher.AssertAccess();`
	`248`	`+`
	`249`	`+ List<Exception> exceptions = null;`
`263`	`250`
`264`		`- try`
	`251`	`+ for (var i = 0; i < _circuitHandlers.Length; i++)`
`265`	`252`	`{`
`266`		`- List<Exception> exceptions = null;`
`267`		`-`
`268`		`- for (var i = 0; i < _circuitHandlers.Length; i++)`
	`253`	`+ var circuitHandler = _circuitHandlers[i];`
	`254`	`+ try`
`269`	`255`	`{`
`270`		`- var circuitHandler = _circuitHandlers[i];`
`271`		`- try`
`272`		`- {`
`273`		`- await circuitHandler.OnConnectionDownAsync(Circuit, cancellationToken);`
`274`		`- }`
`275`		`- catch (Exception ex)`
`276`		`- {`
`277`		`- Log.CircuitHandlerFailed(_logger, circuitHandler, nameof(CircuitHandler.OnConnectionDownAsync), ex);`
`278`		`- exceptions ??= new List<Exception>();`
`279`		`- exceptions.Add(ex);`
`280`		`- }`
	`256`	`+ await circuitHandler.OnConnectionDownAsync(Circuit, cancellationToken);`
`281`	`257`	`}`
`282`		`-`
`283`		`- if (exceptions != null)`
	`258`	`+ catch (Exception ex)`
`284`	`259`	`{`
`285`		`- throw new AggregateException("Encountered exceptions while executing circuit handlers.", exceptions);`
	`260`	`+ Log.CircuitHandlerFailed(_logger, circuitHandler, nameof(CircuitHandler.OnConnectionDownAsync), ex);`
	`261`	`+ exceptions ??= new List<Exception>();`
	`262`	`+ exceptions.Add(ex);`
`286`	`263`	`}`
`287`	`264`	`}`
`288`		`- finally`
	`265`	`+`
	`266`	`+ if (exceptions != null)`
`289`	`267`	`{`
`290`		`- HandlerLock.Release();`
	`268`	`+ throw new AggregateException("Encountered exceptions while executing circuit handlers.", exceptions);`
`291`	`269`	`}`
`292`	`270`	`}`
`293`	`271`
`294`	`272`	`private async Task OnCircuitDownAsync(CancellationToken cancellationToken)`
`295`	`273`	`{`
`296`	`274`	`Log.CircuitClosed(_logger, Circuit.Id);`
`297`	`275`
`298`		`- await HandlerLock.WaitAsync(cancellationToken);`
	`276`	`+ List<Exception> exceptions = null;`
`299`	`277`
`300`		`- try`
	`278`	`+ for (var i = 0; i < _circuitHandlers.Length; i++)`
`301`	`279`	`{`
`302`		`- List<Exception> exceptions = null;`
`303`		`-`
`304`		`- for (var i = 0; i < _circuitHandlers.Length; i++)`
	`280`	`+ var circuitHandler = _circuitHandlers[i];`
	`281`	`+ try`
`305`	`282`	`{`
`306`		`- var circuitHandler = _circuitHandlers[i];`
`307`		`- try`
`308`		`- {`
`309`		`- await circuitHandler.OnCircuitClosedAsync(Circuit, cancellationToken);`
`310`		`- }`
`311`		`- catch (Exception ex)`
`312`		`- {`
`313`		`- Log.CircuitHandlerFailed(_logger, circuitHandler, nameof(CircuitHandler.OnCircuitClosedAsync), ex);`
`314`		`- exceptions ??= new List<Exception>();`
`315`		`- exceptions.Add(ex);`
`316`		`- }`
	`283`	`+ await circuitHandler.OnCircuitClosedAsync(Circuit, cancellationToken);`
`317`	`284`	`}`
`318`		`-`
`319`		`- if (exceptions != null)`
	`285`	`+ catch (Exception ex)`
`320`	`286`	`{`
`321`		`- throw new AggregateException("Encountered exceptions while executing circuit handlers.", exceptions);`
	`287`	`+ Log.CircuitHandlerFailed(_logger, circuitHandler, nameof(CircuitHandler.OnCircuitClosedAsync), ex);`
	`288`	`+ exceptions ??= new List<Exception>();`
	`289`	`+ exceptions.Add(ex);`
`322`	`290`	`}`
`323`	`291`	`}`
`324`		`- finally`
	`292`	`+`
	`293`	`+ if (exceptions != null)`
`325`	`294`	`{`
`326`		`- HandlerLock.Release();`
	`295`	`+ throw new AggregateException("Encountered exceptions while executing circuit handlers.", exceptions);`
`327`	`296`	`}`
`328`	`297`	`}`
`329`	`298`
Original file line number	Diff line number	Diff line change
`@@ -264,6 +264,7 @@ await Client.InvokeDotNetMethod(`
`264`	`264`	`}`
`265`	`265`
`266`	`266`	`[Fact]`
	`267`	`+ [Flaky("https://github.com/aspnet/AspNetCore/issues/13086", FlakyOn.AzP.Windows)]`
`267`	`268`	`public async Task ContinuesWorkingAfterInvalidAsyncReturnCallback()`
`268`	`269`	`{`
`269`	`270`	`// Arrange`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ public void ThrowsIfRenderIsRequestedOutsideSyncContext()`
`33`	`33`	`appElement.FindElement(By.Id("run-without-dispatch")).Click();`
`34`	`34`
`35`	`35`	`Browser.Contains(`
`36`		`- $"{typeof(InvalidOperationException).FullName}: The current thread is not associated with the Dispatcher. Use Invoke() or InvokeAsync() to switch execution to the Dispatcher when triggering rendering or modifying any state accessed during rendering.",`
	`36`	`+ $"{typeof(InvalidOperationException).FullName}: The current thread is not associated with the Dispatcher. Use InvokeAsync() to switch execution to the Dispatcher when triggering rendering or component state.",`
`37`	`37`	`() => result.Text);`
`38`	`38`	`}`
`39`	`39`	`}`