[blazor] Add parameter to ErrorBoundary to let it render ChildContent

Author: Zacharias Neubauer

src/Components/Components/src/ComponentBase.cs

@@ -42,6 +42,11 @@ public ComponentBase()
         };
     }
 
+    /// <summary>
+    /// Nearest ErrorBoundaryBase component
+    /// </summary>
+    [CascadingParameter] internal IErrorBoundary? ErrorBoundary { get; set; }
+
     /// <summary>
     /// Gets the <see cref="Components.RendererInfo"/> the component is running on.
     /// </summary>
@@ -273,7 +278,23 @@ public virtual Task SetParametersAsync(ParameterView parameters)
 
     private async Task RunInitAndSetParametersAsync()
     {
-        OnInitialized();
+        try
+        {
+            OnInitialized();
+        }
+        catch(Exception err)
+        {
+            // If we are guarded by ErrorBoundary that should render ChildContent,
+            // even there was thrown one or more exceptions
+            if (ErrorBoundary?.RenderOnException == true)
+            {
+                _ = _renderHandle.DispatchExceptionAsync(err);
+            }
+            else
+            {
+                throw;
+            }
+        }
         var task = OnInitializedAsync();
 
         if (task.Status != TaskStatus.RanToCompletion && task.Status != TaskStatus.Canceled)
@@ -283,7 +304,7 @@ private async Task RunInitAndSetParametersAsync()
             // to defer calling StateHasChanged up until the first bit of async code happens or until
             // the end. Additionally, we want to avoid calling StateHasChanged if no
             // async work is to be performed.
-            if (task.Status != TaskStatus.Faulted)
+            if (task.Status != TaskStatus.Faulted || ErrorBoundary?.RenderOnException == true)
             {
                 StateHasChanged();
             }
@@ -312,7 +333,24 @@ private async Task RunInitAndSetParametersAsync()
 
     private Task CallOnParametersSetAsync()
     {
-        OnParametersSet();
+        try
+        {
+            OnParametersSet();
+        }
+        catch (Exception err)
+        {
+            // If we are guarded by ErrorBoundary that should render ChildContent,
+            // even there was thrown one or more exceptions
+            if (ErrorBoundary?.RenderOnException == true)
+            {
+                _ = _renderHandle.DispatchExceptionAsync(err);
+            }
+            else
+            {
+                throw;
+            }
+        }
+
         var task = OnParametersSetAsync();
         // If no async work is to be performed, i.e. the task has already ran to completion
         // or was canceled by the time we got to inspect it, avoid going async and re-invoking
@@ -322,7 +360,7 @@ private Task CallOnParametersSetAsync()
 
         // We always call StateHasChanged here as we want to trigger a rerender after OnParametersSet and
         // the synchronous part of OnParametersSetAsync has run.
-        if (task.Status != TaskStatus.Faulted)
+        if (task.Status != TaskStatus.Faulted || ErrorBoundary?.RenderOnException == true)
         {
             StateHasChanged();
         }

src/Components/Components/src/ErrorBoundaryBase.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Runtime.ExceptionServices;
+using Microsoft.AspNetCore.Components.Rendering;
 
 namespace Microsoft.AspNetCore.Components;
 
@@ -28,6 +29,9 @@ public abstract class ErrorBoundaryBase : ComponentBase, IErrorBoundary
     /// </summary>
     [Parameter] public int MaximumErrorCount { get; set; } = 100;
 
+    /// <inheritdoc/>
+    [Parameter] public virtual bool RenderOnException { get; set; }
+
     /// <summary>
     /// Gets the current exception, or null if there is no exception.
     /// </summary>
@@ -47,6 +51,21 @@ public void Recover()
         }
     }
 
+    /// <inheritdoc/>
+    protected override void BuildRenderTree(RenderTreeBuilder builder)
+    {
+        // Making this ErrorBoundary available as a CascadingParameter to ComponentBase
+        builder.OpenComponent<CascadingValue<IErrorBoundary>>(0);
+        builder.AddAttribute(1, nameof(CascadingValue<>.Value), this);
+
+        builder.AddAttribute(2, nameof(CascadingValue<>.ChildContent), (RenderFragment)((builder2) =>
+        {
+            builder2.AddContent(3, ChildContent);
+        }));
+
+        builder.CloseComponent();
+    }
+
     /// <summary>
     /// Invoked by the base class when an error is being handled. Typically, derived classes
     /// should log the exception from this method.

src/Components/Components/src/IErrorBoundary.cs

@@ -17,4 +17,8 @@ namespace Microsoft.AspNetCore.Components;
 internal interface IErrorBoundary
 {
     void HandleException(Exception error);
+    /// <summary>
+    /// Setting this to true will stop Renderer requeue rendering of the candidate component 
+    /// </summary>
+    bool RenderOnException { get; }
 }

src/Components/Components/src/PublicAPI.Unshipped.txt

@@ -1,4 +1,7 @@
 #nullable enable
+Microsoft.AspNetCore.Components.ComponentBase.ErrorBoundary.get -> Microsoft.AspNetCore.Components.ErrorBoundaryBase?
+Microsoft.AspNetCore.Components.ComponentBase.ErrorBoundary.set -> void
+override Microsoft.AspNetCore.Components.ErrorBoundaryBase.BuildRenderTree(Microsoft.AspNetCore.Components.Rendering.RenderTreeBuilder! builder) -> void
 static Microsoft.AspNetCore.Components.NavigationManagerExtensions.GetUriWithHash(this Microsoft.AspNetCore.Components.NavigationManager! navigationManager, string! hash) -> string!
 Microsoft.AspNetCore.Components.NavigationOptions.RelativeToCurrentUri.get -> bool
 Microsoft.AspNetCore.Components.NavigationOptions.RelativeToCurrentUri.init -> void
@@ -7,3 +10,5 @@ Microsoft.AspNetCore.Components.IComponentPropertyActivator.GetActivator(System.
 *REMOVED*Microsoft.AspNetCore.Components.ResourceAsset.ResourceAsset(string! url, System.Collections.Generic.IReadOnlyList<Microsoft.AspNetCore.Components.ResourceAssetProperty!>? properties) -> void
 *REMOVED*Microsoft.AspNetCore.Components.Routing.Router.PreferExactMatches.get -> bool
 *REMOVED*Microsoft.AspNetCore.Components.Routing.Router.PreferExactMatches.set -> void
+virtual Microsoft.AspNetCore.Components.ErrorBoundaryBase.RenderOnException.get -> bool
+virtual Microsoft.AspNetCore.Components.ErrorBoundaryBase.RenderOnException.set -> void

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

@@ -1185,17 +1185,27 @@ private void HandleExceptionViaErrorBoundary(Exception error, ComponentState? er
         {
             if (candidate.Component is IErrorBoundary errorBoundary)
             {
-                // 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 => { });
+                // Check if the error boundery do not allow to continue to render the component
+                // when one or more exceptions have been thrown
+                if (!errorBoundary.RenderOnException)
+                {
+                    // 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 => { });
+                }
 
                 try
                 {
                     errorBoundary.HandleException(error);
                 }
                 catch (Exception errorBoundaryException)
                 {
+                    if (errorBoundary.RenderOnException)
+                    {
+                        AddToRenderQueue(candidate.ComponentId, builder => { });
+                    }
+
                     // If *notifying* about an exception fails, it's OK for that to be fatal
                     HandleException(errorBoundaryException);
                 }

src/Components/Components/test/RendererTest.cs

@@ -6168,6 +6168,7 @@ private class TestErrorBoundary : AutoRenderComponent, IErrorBoundary
         public Task ReceivedErrorTask => receivedErrorTaskCompletionSource.Task;
 
         [Parameter] public RenderFragment ChildContent { get; set; }
+        public bool RenderOnException { get; }
 
         protected override void BuildRenderTree(RenderTreeBuilder builder)
             => ChildContent(builder);

src/Components/Samples/BlazorUnitedApp.Client/BlazorUnitedApp.Client.csproj

@@ -15,4 +15,8 @@
     <Folder Include="wwwroot\" />
   </ItemGroup>
 
+  <ItemGroup>
+    <None Include="ThrowExceptionsChild.razor.cs" />
+  </ItemGroup>
+
 </Project>

src/Components/Samples/BlazorUnitedApp.Client/ErrorBoundaryTest.cs

@@ -0,0 +1,15 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.AspNetCore.Components;
+using Microsoft.JSInterop;
+
+namespace BlazorUnitedApp.Client;
+
+public class ErrorBoundaryTest(IJSRuntime jSRuntime) : ErrorBoundaryBase
+{
+    protected override async Task OnErrorAsync(Exception exception)
+    {
+        await jSRuntime.InvokeVoidAsync("alert", $"An unknown error occurred: {exception.Message}");
+    }
+}

src/Components/Samples/BlazorUnitedApp.Client/ThrowExceptions.razor

@@ -0,0 +1,3 @@
+<ErrorBoundaryTest RenderOnException="true">
+    <ThrowExceptionsChild />
+</ErrorBoundaryTest>

src/Components/Samples/BlazorUnitedApp.Client/ThrowExceptionsChild.razor

@@ -0,0 +1,5 @@
+<h3>ThrowExceptionsChild</h3>
+
+<button @onclick="Save">
+    Test saving with exception
+</button>