Terminate circuit on error

Fixes: #11845

See: #12857 for detailed notes.

Author: Ryan Nowak

src/Components/Components/src/Rendering/ComponentState.cs

@@ -75,16 +75,24 @@ public void RenderIntoBatch(RenderBatchBuilder batchBuilder, RenderFragment rend
             batchBuilder.UpdatedComponentDiffs.Append(diff);
         }
 
-        public void DisposeInBatch(RenderBatchBuilder batchBuilder)
+        public bool TryDisposeInBatch(RenderBatchBuilder batchBuilder, out Exception exception)
         {
             _componentWasDisposed = true;
+            exception = null;
 
-            // TODO: Handle components throwing during dispose. Shouldn't break the whole render batch.
-            if (Component is IDisposable disposable)
+            try
             {
-                disposable.Dispose();
+                if (Component is IDisposable disposable)
+                {
+                    disposable.Dispose();
+                }
+            }
+            catch (Exception ex)
+            {
+                exception = ex;
             }
 
+            // We don't expect these things to throw.
             RenderTreeDiffBuilder.DisposeFrames(batchBuilder, CurrentRenderTree.GetFrames());
 
             if (_hasAnyCascadingParameterSubscriptions)
@@ -93,13 +101,27 @@ public void DisposeInBatch(RenderBatchBuilder batchBuilder)
             }
 
             DisposeBuffers();
+
+            return exception == null;
         }
 
+        // Callers expect this method to always return a faulted task.
         public Task NotifyRenderCompletedAsync()
         {
             if (Component is IHandleAfterRender handlerAfterRender)
             {
-                return handlerAfterRender.OnAfterRenderAsync();
+                try
+                {
+                    return handlerAfterRender.OnAfterRenderAsync();
+                }
+                catch (OperationCanceledException cex)
+                {
+                    return Task.FromCanceled(cex.CancellationToken);
+                }
+                catch (Exception ex)
+                {
+                    return Task.FromException(ex);
+                }
             }
 
             return Task.CompletedTask;

src/Components/Components/src/Rendering/Renderer.cs

@@ -587,16 +587,31 @@ private void RenderInExistingBatch(RenderQueueEntry renderQueueEntry)
             Log.RenderingComponent(_logger, componentState);
             componentState.RenderIntoBatch(_batchBuilder, renderQueueEntry.RenderFragment);
 
+            List<Exception> exceptions = null;
+
             // Process disposal queue now in case it causes further component renders to be enqueued
             while (_batchBuilder.ComponentDisposalQueue.Count > 0)
             {
                 var disposeComponentId = _batchBuilder.ComponentDisposalQueue.Dequeue();
                 var disposeComponentState = GetRequiredComponentState(disposeComponentId);
                 Log.DisposingComponent(_logger, disposeComponentState);
-                disposeComponentState.DisposeInBatch(_batchBuilder);
+                if (!disposeComponentState.TryDisposeInBatch(_batchBuilder, out var exception))
+                {
+                    exceptions ??= new List<Exception>();
+                    exceptions.Add(exception);
+                }
                 _componentStateById.Remove(disposeComponentId);
                 _batchBuilder.DisposedComponentIds.Append(disposeComponentId);
             }
+
+            if (exceptions?.Count > 1)
+            {
+                HandleException(new AggregateException("Exceptions were encountered while disposing components.", exceptions));
+            }
+            else if (exceptions?.Count == 1)
+            {
+                HandleException(exceptions[0]);
+            }
         }
 
         private void RemoveEventHandlerIds(ArrayRange<ulong> eventHandlerIds, Task afterTaskIgnoreErrors)
@@ -681,6 +696,9 @@ private void UpdateRenderTreeToMatchClientState(ulong eventHandlerId, EventField
         /// <param name="disposing"><see langword="true"/> if this method is being invoked by <see cref="IDisposable.Dispose"/>, otherwise <see langword="false"/>.</param>
         protected virtual void Dispose(bool disposing)
         {
+            // It's important that we handle all exceptions here before reporting any of them.
+            // This way we can dispose all components before an error handler kicks in.
+            List<Exception> exceptions = null;
             foreach (var componentState in _componentStateById.Values)
             {
                 Log.DisposingComponent(_logger, componentState);
@@ -693,11 +711,21 @@ protected virtual void Dispose(bool disposing)
                     }
                     catch (Exception exception)
                     {
-                        HandleException(exception);
+                        exceptions ??= new List<Exception>();
+                        exceptions.Add(exception);
                     }
                 }
+            }
+
+            _batchBuilder.Dispose();
 
-                _batchBuilder.Dispose();
+            if (exceptions?.Count > 1)
+            {
+                HandleException(new AggregateException("Exceptions were encountered while disposing components.", exceptions));
+            }
+            else if (exceptions?.Count == 1)
+            {
+                HandleException(exceptions[0]);
             }
         }