Add NotFoundPage to Router

src/Components/Components/src/NavigationManager.cs

@@ -54,6 +54,8 @@ public event EventHandler<NotFoundEventArgs> OnNotFound
 
     private EventHandler<NotFoundEventArgs>? _notFound;
 
+    private static readonly NotFoundEventArgs _notFoundEventArgs = new NotFoundEventArgs();
+
     // For the baseUri it's worth storing as a System.Uri so we can do operations
     // on that type. System.Uri gives us access to the original string anyway.
     private Uri? _baseUri;
@@ -203,7 +205,15 @@ public virtual void Refresh(bool forceReload = false)
 
     private void NotFoundCore()
     {
-        _notFound?.Invoke(this, new NotFoundEventArgs());
+        if (_notFound == null)
+        {
+            // global router doesn't exist, no events were registered
+            return;
+        }
+        else
+        {
+            _notFound.Invoke(this, _notFoundEventArgs);
+        }
     }
 
     /// <summary>

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

@@ -1,4 +1,7 @@
 #nullable enable
+
+Microsoft.AspNetCore.Components.Routing.Router.NotFoundPage.get -> System.Type!
+Microsoft.AspNetCore.Components.Routing.Router.NotFoundPage.set -> void
 Microsoft.AspNetCore.Components.NavigationManager.OnNotFound -> System.EventHandler<Microsoft.AspNetCore.Components.Routing.NotFoundEventArgs!>!
 Microsoft.AspNetCore.Components.NavigationManager.NotFound() -> void
 Microsoft.AspNetCore.Components.Routing.IHostEnvironmentNavigationManager.Initialize(string! baseUri, string! uri, System.Func<string!, System.Threading.Tasks.Task!>! onNavigateTo) -> void

src/Components/Components/src/Routing/Router.cs

@@ -3,11 +3,13 @@
 
 #nullable disable warnings
 
+using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
 using System.Reflection.Metadata;
 using System.Runtime.ExceptionServices;
 using Microsoft.AspNetCore.Components.HotReload;
 using Microsoft.AspNetCore.Components.Rendering;
+using Microsoft.AspNetCore.Internal;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.DependencyInjection;
 
@@ -70,6 +72,13 @@ static readonly IReadOnlyDictionary<string, object> _emptyParametersDictionary
     [Parameter]
     public RenderFragment NotFound { get; set; }
 
+    /// <summary>
+    /// Gets or sets the page content to display when no match is found for the requested route.
+    /// </summary>
+    [Parameter]
+    [DynamicallyAccessedMembers(LinkerFlags.Component)]
+    public Type NotFoundPage { get; set; } = default!;
+
     /// <summary>
     /// Gets or sets the content to display when a match is found for the requested route.
     /// </summary>
@@ -132,6 +141,22 @@ public async Task SetParametersAsync(ParameterView parameters)
             throw new InvalidOperationException($"The {nameof(Router)} component requires a value for the parameter {nameof(Found)}.");
         }
 
+        if (NotFoundPage != null)
+        {
+            if (!typeof(IComponent).IsAssignableFrom(NotFoundPage))
+            {
+                throw new InvalidOperationException($"The type {NotFoundPage.FullName} " +
+                    $"does not implement {typeof(IComponent).FullName}.");
+            }
+
+            var routeAttributes = NotFoundPage.GetCustomAttributes(typeof(RouteAttribute), inherit: true);
+            if (routeAttributes.Length == 0)
+            {
+                throw new InvalidOperationException($"The type {NotFoundPage.FullName} " +
+                    $"does not have a {typeof(RouteAttribute).FullName} applied to it.");
+            }
+        }
+
         if (!_onNavigateCalled)
         {
             _onNavigateCalled = true;
@@ -327,7 +352,22 @@ private void OnNotFound(object sender, EventArgs args)
         if (_renderHandle.IsInitialized)
         {
             Log.DisplayingNotFound(_logger);
-            _renderHandle.Render(NotFound ?? DefaultNotFoundContent);
+            _renderHandle.Render(builder =>
+            {
+                if (NotFoundPage != null)
+                {
+                    builder.OpenComponent(0, NotFoundPage);
+                    builder.CloseComponent();
+                }
+                else if (NotFound != null)
+                {
+                    NotFound(builder);
+                }
+                else
+                {
+                    DefaultNotFoundContent(builder);
+                }
+            });
         }
     }
 

src/Components/Endpoints/src/Microsoft.AspNetCore.Components.Endpoints.csproj

@@ -40,6 +40,7 @@
     <Reference Include="Microsoft.AspNetCore.Antiforgery" />
     <Reference Include="Microsoft.AspNetCore.Components.Authorization" />
     <Reference Include="Microsoft.AspNetCore.Components.Web" />
+    <Reference Include="Microsoft.AspNetCore.Diagnostics" />
     <Reference Include="Microsoft.AspNetCore.Diagnostics.Abstractions" />
     <Reference Include="Microsoft.AspNetCore.DataProtection.Extensions" />
     <Reference Include="Microsoft.AspNetCore.Hosting.Abstractions" />

src/Components/Endpoints/src/RazorComponentEndpointInvoker.cs

@@ -39,12 +39,18 @@ private async Task RenderComponentCore(HttpContext context)
     {
         context.Response.ContentType = RazorComponentResultExecutor.DefaultContentType;
         var isErrorHandler = context.Features.Get<IExceptionHandlerFeature>() is not null;
+        var hasStatusCodePage = context.Features.Get<IStatusCodePagesFeature>() is not null;
+        var isReExecuted = context.Features.Get<IStatusCodeReExecuteFeature>() is not null;
         if (isErrorHandler)
         {
             Log.InteractivityDisabledForErrorHandling(_logger);
         }
-        _renderer.InitializeStreamingRenderingFraming(context, isErrorHandler);
-        EndpointHtmlRenderer.MarkAsAllowingEnhancedNavigation(context);
+        _renderer.InitializeStreamingRenderingFraming(context, isErrorHandler, isReExecuted);
+        if (!isReExecuted)
+        {
+            // re-executed pages have Headers already set up
+            EndpointHtmlRenderer.MarkAsAllowingEnhancedNavigation(context);
+        }
 
         var endpoint = context.GetEndpoint() ?? throw new InvalidOperationException($"An endpoint must be set on the '{nameof(HttpContext)}'.");
 
@@ -85,14 +91,23 @@ await _renderer.InitializeStandardComponentServicesAsync(
         await using var writer = new HttpResponseStreamWriter(context.Response.Body, Encoding.UTF8, defaultBufferSize, ArrayPool<byte>.Shared, ArrayPool<char>.Shared);
         using var bufferWriter = new BufferedTextWriter(writer);
 
+        bool isErrorHandlerOrReExecuted = isErrorHandler || isReExecuted;
+
         // Note that we always use Static rendering mode for the top-level output from a RazorComponentResult,
         // because you never want to serialize the invocation of RazorComponentResultHost. Instead, that host
         // component takes care of switching into your desired render mode when it produces its own output.
         var htmlContent = await _renderer.RenderEndpointComponent(
             context,
             rootComponent,
             ParameterView.Empty,
-            waitForQuiescence: result.IsPost || isErrorHandler);
+            waitForQuiescence: result.IsPost || isErrorHandlerOrReExecuted);
+
+        bool avoidStartingResponse = hasStatusCodePage && !isReExecuted && context.Response.StatusCode == StatusCodes.Status404NotFound;
+        if (avoidStartingResponse)
+        {
+            // the request is going to be re-executed, we should avoid writing to the response
+            return;
+        }
 
         Task quiesceTask;
         if (!result.IsPost)
@@ -145,7 +160,7 @@ await _renderer.InitializeStandardComponentServicesAsync(
         }
 
         // Emit comment containing state.
-        if (!isErrorHandler)
+        if (!isErrorHandlerOrReExecuted)
         {
             var componentStateHtmlContent = await _renderer.PrerenderPersistedStateAsync(context);
             componentStateHtmlContent.WriteTo(bufferWriter, HtmlEncoder.Default);
@@ -160,10 +175,11 @@ await _renderer.InitializeStandardComponentServicesAsync(
     private async Task<RequestValidationState> ValidateRequestAsync(HttpContext context, IAntiforgery? antiforgery)
     {
         var processPost = HttpMethods.IsPost(context.Request.Method) &&
-            // Disable POST functionality during exception handling.
+            // Disable POST functionality during exception handling and reexecution.
             // The exception handler middleware will not update the request method, and we don't
             // want to run the form handling logic against the error page.
-            context.Features.Get<IExceptionHandlerFeature>() == null;
+            context.Features.Get<IExceptionHandlerFeature>() == null &&
+            context.Features.Get<IStatusCodePagesFeature>() == null;
 
         if (processPost)
         {

src/Components/Endpoints/src/Rendering/EndpointHtmlRenderer.EventDispatch.cs

@@ -77,14 +77,27 @@ private Task ReturnErrorResponse(string detailedMessage)
             : Task.CompletedTask;
     }
 
-    private void SetNotFoundResponse(object? sender, EventArgs args)
+    private async Task SetNotFoundResponseAsync(string baseUri)
     {
         if (_httpContext.Response.HasStarted)
         {
-            throw new InvalidOperationException("Cannot set a NotFound response after the response has already started.");
+            var defaultBufferSize = 16 * 1024;
+            await using var writer = new HttpResponseStreamWriter(_httpContext.Response.Body, Encoding.UTF8, defaultBufferSize, ArrayPool<byte>.Shared, ArrayPool<char>.Shared);
+            using var bufferWriter = new BufferedTextWriter(writer);
+            var notFoundUri = $"{baseUri}not-found";
+            HandleNavigationAfterResponseStarted(bufferWriter, _httpContext, notFoundUri);
+            await bufferWriter.FlushAsync();
         }
-        _httpContext.Response.StatusCode = StatusCodes.Status404NotFound;
-        SignalRendererToFinishRendering();
+        else
+        {
+            _httpContext.Response.StatusCode = StatusCodes.Status404NotFound;
+            _httpContext.Response.ContentType = null;
+        }
+
+        // When the application triggers a NotFound event, we continue rendering the current batch.
+        // However, after completing this batch, we do not want to process any further UI updates,
+        // as we are going to return a 404 status and discard the UI updates generated so far.
+        SignalRendererToFinishRenderingAfterCurrentBatch();
     }
 
     private async Task OnNavigateTo(string uri)

src/Components/Endpoints/src/Rendering/EndpointHtmlRenderer.Prerendering.cs

@@ -8,6 +8,7 @@
 using Microsoft.AspNetCore.Components.Web.HtmlRendering;
 using Microsoft.AspNetCore.Html;
 using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Logging;
 using static Microsoft.AspNetCore.Internal.LinkerFlags;
 
 namespace Microsoft.AspNetCore.Components.Endpoints;
@@ -18,7 +19,7 @@ internal partial class EndpointHtmlRenderer
 
     protected override IComponent ResolveComponentForRenderMode([DynamicallyAccessedMembers(Component)] Type componentType, int? parentComponentId, IComponentActivator componentActivator, IComponentRenderMode renderMode)
     {
-        if (_isHandlingErrors)
+        if (_isHandlingErrors || _isReExecuted)
         {
             // Ignore the render mode boundary in error scenarios.
             return componentActivator.CreateInstance(componentType);
@@ -166,7 +167,50 @@ private async Task WaitForResultReady(bool waitForQuiescence, PrerenderedCompone
         }
         else if (_nonStreamingPendingTasks.Count > 0)
         {
-            await WaitForNonStreamingPendingTasks();
+            if (_isReExecuted)
+            {
+                HandleNonStreamingTasks();
+            }
+            else
+            {
+                await WaitForNonStreamingPendingTasks();
+            }
+        }
+    }
+
+    public void HandleNonStreamingTasks()
+    {
+        if (NonStreamingPendingTasksCompletion == null)
+        {
+            foreach (var task in _nonStreamingPendingTasks)
+            {
+                _ = GetErrorHandledTask(task);
+            }
+
+            // Clear the pending tasks since we are handling them
+            _nonStreamingPendingTasks.Clear();
+
+            NonStreamingPendingTasksCompletion = Task.CompletedTask;
+        }
+    }
+
+    private async Task GetErrorHandledTask(Task taskToHandle)
+    {
+        try
+        {
+            await taskToHandle;
+        }
+        catch (Exception ex)
+        {
+            // Ignore errors due to task cancellations.
+            if (!taskToHandle.IsCanceled)
+            {
+                _logger.LogError(
+                    ex,
+                    "An exception occurred during non-streaming rendering. " +
+                    "This exception will be ignored because the response " +
+                    "is being discarded and the request is being re-executed.");
+            }
         }
     }
 

src/Components/Endpoints/src/Rendering/EndpointHtmlRenderer.Streaming.cs

@@ -23,11 +23,13 @@ internal partial class EndpointHtmlRenderer
     private HashSet<int>? _visitedComponentIdsInCurrentStreamingBatch;
     private string? _ssrFramingCommentMarkup;
     private bool _isHandlingErrors;
+    private bool _isReExecuted;
 
-    public void InitializeStreamingRenderingFraming(HttpContext httpContext, bool isErrorHandler)
+    public void InitializeStreamingRenderingFraming(HttpContext httpContext, bool isErrorHandler, bool isReExecuted)
     {
         _isHandlingErrors = isErrorHandler;
-        if (IsProgressivelyEnhancedNavigation(httpContext.Request))
+        _isReExecuted = isReExecuted;
+        if (!isReExecuted && IsProgressivelyEnhancedNavigation(httpContext.Request))
         {
             var id = Guid.NewGuid().ToString();
             httpContext.Response.Headers.Add(_streamingRenderingFramingHeaderName, id);

src/Components/Endpoints/src/Rendering/EndpointHtmlRenderer.cs

@@ -44,6 +44,7 @@ internal partial class EndpointHtmlRenderer : StaticHtmlRenderer, IComponentPrer
     private HttpContext _httpContext = default!; // Always set at the start of an inbound call
     private ResourceAssetCollection? _resourceCollection;
     private bool _rendererIsStopped;
+    private readonly ILogger _logger;
 
     // The underlying Renderer always tracks the pending tasks representing *full* quiescence, i.e.,
     // when everything (regardless of streaming SSR) is fully complete. In this subclass we also track
@@ -56,6 +57,7 @@ public EndpointHtmlRenderer(IServiceProvider serviceProvider, ILoggerFactory log
     {
         _services = serviceProvider;
         _options = serviceProvider.GetRequiredService<IOptions<RazorComponentsServiceOptions>>().Value;
+        _logger = loggerFactory.CreateLogger("Microsoft.AspNetCore.Components.RenderTree.Renderer");
     }
 
     internal HttpContext? HttpContext => _httpContext;
@@ -83,7 +85,7 @@ internal async Task InitializeStandardComponentServicesAsync(
 
         if (navigationManager != null)
         {
-            navigationManager.OnNotFound += SetNotFoundResponse;
+            navigationManager.OnNotFound += async (sender, args) => await SetNotFoundResponseAsync(navigationManager.BaseUri);
         }
 
         var authenticationStateProvider = httpContext.RequestServices.GetService<AuthenticationStateProvider>();
@@ -163,6 +165,11 @@ protected override ComponentState CreateComponentState(int componentId, ICompone
 
     protected override void AddPendingTask(ComponentState? componentState, Task task)
     {
+        if (_isReExecuted)
+        {
+            return;
+        }
+
         var streamRendering = componentState is null
             ? false
             : ((EndpointComponentState)componentState).StreamRendering;
@@ -176,12 +183,28 @@ protected override void AddPendingTask(ComponentState? componentState, Task task
         base.AddPendingTask(componentState, task);
     }
 
-    protected override void SignalRendererToFinishRendering()
+    private void SignalRendererToFinishRenderingAfterCurrentBatch()
     {
+        // sets a deferred stop on the renderer, which will have an effect after the current batch is completed
         _rendererIsStopped = true;
+    }
+
+    protected override void SignalRendererToFinishRendering()
+    {
+        SignalRendererToFinishRenderingAfterCurrentBatch();
+        // sets a hard stop on the renderer, which will have an effect immediately
         base.SignalRendererToFinishRendering();
     }
 
+    protected override void ProcessPendingRender()
+    {
+        if (_rendererIsStopped)
+        {
+            return;
+        }
+        base.ProcessPendingRender();
+    }
+
     // For tests only
     internal Task? NonStreamingPendingTasksCompletion;
 

src/Components/Endpoints/src/Results/RazorComponentResultExecutor.cs

@@ -48,7 +48,8 @@ private static Task RenderComponentToResponse(
         return endpointHtmlRenderer.Dispatcher.InvokeAsync(async () =>
         {
             var isErrorHandler = httpContext.Features.Get<IExceptionHandlerFeature>() is not null;
-            endpointHtmlRenderer.InitializeStreamingRenderingFraming(httpContext, isErrorHandler);
+            var isReExecuted = httpContext.Features.Get<IStatusCodeReExecuteFeature>() is not null;
+            endpointHtmlRenderer.InitializeStreamingRenderingFraming(httpContext, isErrorHandler, isReExecuted);
             EndpointHtmlRenderer.MarkAsAllowingEnhancedNavigation(httpContext);
 
             // We could pool these dictionary instances if we wanted, and possibly even the ParameterView