Fix ErrorBoundary not rendering ErrorContent when multiple exceptions occur

src/Components/Components/src/ErrorBoundaryBase.cs

@@ -31,7 +31,7 @@ public abstract class ErrorBoundaryBase : ComponentBase, IErrorBoundary
     /// <summary>
     /// Gets the current exception, or null if there is no exception.
     /// </summary>
-    protected Exception? CurrentException { get; private set; }
+    protected internal Exception? CurrentException { get; private set; }
 
     /// <summary>
     /// Resets the error boundary to a non-errored state. If the error boundary is not

src/Components/Components/src/RenderTree/Renderer.cs

@@ -1169,7 +1169,12 @@ private void HandleExceptionViaErrorBoundary(Exception error, ComponentState? er
                 // Don't just trust the error boundary to dispose its subtree - force it to do so by
                 // making it render an empty fragment. Ensures that failed components don't continue to
                 // operate, which would be a whole new kind of edge case to support forever.
-                AddToRenderQueue(candidate.ComponentId, builder => { });
+                // However, if the error boundary already has an exception, don't queue an empty render
+                // as it would override the error content that should be displayed.
+                if (errorBoundary is not ErrorBoundaryBase { CurrentException: { } })
+                {
+                    AddToRenderQueue(candidate.ComponentId, builder => { });
+                }
 
                 try
                 {

src/Components/Components/test/RendererTest.cs

@@ -4779,6 +4779,47 @@ public async Task EventDispatchExceptionsCanBeHandledByClosestErrorBoundary_Afte
             component => Assert.Same(exception, component.ReceivedException));
     }
 
+    [Fact]
+    public void ErrorBoundaryHandlesMultipleExceptionsFromSameComponent()
+    {
+        // This test reproduces the issue where a component throws exceptions in both 
+        // parameter setting (lifecycle) and during rendering. The fix ensures that
+        // the ErrorBoundary can properly handle this scenario without empty content.
+
+        // Arrange
+        var renderer = new TestRenderer();
+        var parameterException = new InvalidOperationException("Error during parameter setting");
+        var renderException = new InvalidOperationException("Error during render");
+
+        var rootComponentId = renderer.AssignRootComponentId(new TestComponent(builder =>
+        {
+            builder.OpenComponent<MultiExceptionErrorBoundary>(0);
+            builder.AddComponentParameter(1, nameof(MultiExceptionErrorBoundary.ChildContent), (RenderFragment)(builder =>
+            {
+                builder.OpenComponent<ErrorThrowingComponent>(0);
+                builder.AddComponentParameter(1, nameof(ErrorThrowingComponent.ThrowDuringParameterSettingSync), parameterException);
+                builder.AddComponentParameter(2, nameof(ErrorThrowingComponent.ThrowDuringRender), renderException);
+                builder.CloseComponent();
+            }));
+            builder.CloseComponent();
+        }));
+
+        // Act
+        renderer.RenderRootComponent(rootComponentId);
+
+        // Assert
+        var batch = renderer.Batches.Single();
+        var errorBoundary = batch.GetComponentFrames<MultiExceptionErrorBoundary>().Single().Component as MultiExceptionErrorBoundary;
+
+        // The error boundary should have received at least one exception and be able to render properly
+        Assert.NotNull(errorBoundary.LastReceivedException);
+        Assert.True(errorBoundary.ExceptionCount > 0);
+
+        // The component should be disposed since it failed
+        var failedComponentId = batch.GetComponentFrames<ErrorThrowingComponent>().Single().ComponentId;
+        Assert.Contains(failedComponentId, batch.DisposedComponentIDs);
+    }
+
     [Fact]
     public async Task CanRemoveRootComponents()
     {
@@ -6046,6 +6087,33 @@ public async Task HandleEventAsync(EventCallbackWorkItem item, object arg)
         }
     }
 
+    private class MultiExceptionErrorBoundary : AutoRenderComponent, IErrorBoundary
+    {
+        public Exception LastReceivedException { get; private set; }
+        public int ExceptionCount { get; private set; }
+
+        [Parameter] public RenderFragment ChildContent { get; set; }
+
+        protected override void BuildRenderTree(RenderTreeBuilder builder)
+        {
+            if (LastReceivedException is not null)
+            {
+                builder.AddContent(0, $"Error: {LastReceivedException.Message}");
+            }
+            else
+            {
+                ChildContent(builder);
+            }
+        }
+
+        public void HandleException(Exception error)
+        {
+            LastReceivedException = error;
+            ExceptionCount++;
+            TriggerRender();
+        }
+    }
+
     private class CallbackDuringSetParametersAsyncComponent : AutoRenderComponent
     {
         public int RenderCount { get; private set; }

src/Components/test/E2ETest/Tests/ErrorBoundaryTest.cs

@@ -158,6 +158,20 @@ public void CanHandleMultipleAsyncErrorsFromDescendants()
         AssertGlobalErrorState(false);
     }
 
+    [Fact]
+    public void CanHandleTwoErrorsInSameComponent()
+    {
+        var container = Browser.Exists(By.Id("two-errors-test"));
+
+        // Trigger the component with two errors
+        container.FindElement(By.Id("show-two-errors-component")).Click();
+
+        // Should show error content, not be blank
+        Browser.Exists(By.ClassName("two-errors-error-content"));
+
+        AssertGlobalErrorState(false);
+    }
+
     void AssertGlobalErrorState(bool hasGlobalError)
     {
         var globalErrorUi = Browser.Exists(By.Id("blazor-error-ui"));

src/Components/test/testassets/BasicTestApp/ErrorBoundaryTest/ComponentWithTwoErrors.razor

@@ -0,0 +1,12 @@
+@{
+    throw new Exception("error2");
+}
+
+@code
+{
+    protected override async Task OnInitializedAsync()
+    {
+        await Task.Yield(); // Make it actually async
+        throw new Exception("error");
+    }
+}

src/Components/test/testassets/BasicTestApp/ErrorBoundaryTest/ErrorBoundaryCases.razor

@@ -99,6 +99,24 @@
     <button class="throw-in-children" @onclick="@(() => { multipleChildrenBeginDelayedError = true; })">Cause multiple errors</button>
 </div>
 
+<hr />
+<h2>Two different errors in same component</h2>
+<p>This tests the case where a component throws in both OnInitializedAsync and during rendering.</p>
+<div id="two-errors-test">
+    @if (showTwoErrorsComponent)
+    {
+        <ErrorBoundary>
+            <ChildContent>
+                <ComponentWithTwoErrors />
+            </ChildContent>
+            <ErrorContent>
+                <div class="two-errors-error-content" style="background: red">@context</div>
+            </ErrorContent>
+        </ErrorBoundary>
+    }
+    <button id="show-two-errors-component" @onclick="@(() => showTwoErrorsComponent = true)">Show component with two errors</button>
+</div>
+
 <hr />
 <h2>Dispatch exception to renderer</h2>
 <p>Use DispatchExceptionAsync to see if exceptions are correctly dispatched to the renderer.</p>
@@ -122,6 +140,7 @@
     private bool disposalTestRemoveErrorBoundary;
     private bool disposalTestBeginDelayedError;
     private bool multipleChildrenBeginDelayedError;
+    private bool showTwoErrorsComponent;
 
     void EventHandlerErrorSync()
         => throw new InvalidTimeZoneException("Synchronous error from event handler");