Change priority of re-execution handling and allow router to stream NotFound contents

src/Components/Components/src/NavigationManager.cs

@@ -54,15 +54,14 @@ 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;
 
     // The URI. Always represented an absolute URI.
     private string? _uri;
     private bool _isInitialized;
+    internal string NotFoundPageRoute { get; set; } = string.Empty;
 
     /// <summary>
     /// Gets or sets the current base URI. The <see cref="BaseUri" /> is always represented as an absolute URI in string form with trailing slash.
@@ -212,7 +211,7 @@ private void NotFoundCore()
         }
         else
         {
-            _notFound.Invoke(this, _notFoundEventArgs);
+            _notFound.Invoke(this, new NotFoundEventArgs(NotFoundPageRoute));
         }
     }
 

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

@@ -6,7 +6,8 @@ Microsoft.AspNetCore.Components.NavigationManager.OnNotFound -> System.EventHand
 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
 Microsoft.AspNetCore.Components.Routing.NotFoundEventArgs
-Microsoft.AspNetCore.Components.Routing.NotFoundEventArgs.NotFoundEventArgs() -> void
+Microsoft.AspNetCore.Components.Routing.NotFoundEventArgs.NotFoundEventArgs(string! url) -> void
+Microsoft.AspNetCore.Components.Routing.NotFoundEventArgs.Path.get -> string!
 Microsoft.AspNetCore.Components.Infrastructure.ComponentStatePersistenceManager.ComponentStatePersistenceManager(Microsoft.Extensions.Logging.ILogger<Microsoft.AspNetCore.Components.Infrastructure.ComponentStatePersistenceManager!>! logger, System.IServiceProvider! serviceProvider) -> void
 Microsoft.AspNetCore.Components.Infrastructure.ComponentStatePersistenceManager.SetPlatformRenderMode(Microsoft.AspNetCore.Components.IComponentRenderMode! renderMode) -> void
 Microsoft.AspNetCore.Components.Infrastructure.RegisterPersistentComponentStateServiceCollectionExtensions

src/Components/Components/src/Routing/NotFoundEventArgs.cs

@@ -8,9 +8,17 @@ namespace Microsoft.AspNetCore.Components.Routing;
 /// </summary>
 public sealed class NotFoundEventArgs : EventArgs
 {
+    /// <summary>
+    /// Gets the path of NotFoundPage.
+    /// </summary>
+    public string Path { get; }
+
     /// <summary>
     /// Initializes a new instance of <see cref="NotFoundEventArgs" />.
     /// </summary>
-    public NotFoundEventArgs()
-    { }
+    public NotFoundEventArgs(string url)
+    {
+        Path = url;
+    }
+
 }

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

@@ -155,6 +155,12 @@ public async Task SetParametersAsync(ParameterView parameters)
                 throw new InvalidOperationException($"The type {NotFoundPage.FullName} " +
                     $"does not have a {typeof(RouteAttribute).FullName} applied to it.");
             }
+
+            var routeAttribute = (RouteAttribute)routeAttributes[0];
+            if (routeAttribute.Template != null)
+            {
+                NavigationManager.NotFoundPageRoute = routeAttribute.Template;
+            }
         }
 
         if (!_onNavigateCalled)

src/Components/Endpoints/src/RazorComponentEndpointInvoker.cs

@@ -111,13 +111,6 @@ await _renderer.InitializeStandardComponentServicesAsync(
             ParameterView.Empty,
             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)
         {

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

@@ -1,9 +1,11 @@
 // 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.Builder;
 using Microsoft.AspNetCore.Components.Endpoints.Rendering;
 using Microsoft.AspNetCore.Components.Rendering;
 using Microsoft.AspNetCore.Components.RenderTree;
+using Microsoft.AspNetCore.Components.Routing;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.WebUtilities;
 using Microsoft.Extensions.DependencyInjection;
@@ -77,21 +79,26 @@ private Task ReturnErrorResponse(string detailedMessage)
             : Task.CompletedTask;
     }
 
-    private async Task SetNotFoundResponseAsync(string baseUri)
+    internal async Task SetNotFoundResponseAsync(string baseUri, NotFoundEventArgs args)
     {
-        if (_httpContext.Response.HasStarted)
+        if (_httpContext.Response.HasStarted ||
+            // POST waits for quiescence -> rendering the NotFoundPage would be queued for the next batch
+            // but we want to send the signal to the renderer to stop rendering future batches -> use client rendering
+            HttpMethods.IsPost(_httpContext.Request.Method))
         {
+            if (string.IsNullOrEmpty(_notFoundUrl))
+            {
+                _notFoundUrl = GetNotFoundUrl(baseUri, args);
+            }
             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);
+            HandleNotFoundAfterResponseStarted(bufferWriter, _httpContext, _notFoundUrl);
             await bufferWriter.FlushAsync();
         }
         else
         {
             _httpContext.Response.StatusCode = StatusCodes.Status404NotFound;
-            _httpContext.Response.ContentType = null;
         }
 
         // When the application triggers a NotFound event, we continue rendering the current batch.
@@ -100,6 +107,22 @@ private async Task SetNotFoundResponseAsync(string baseUri)
         SignalRendererToFinishRendering();
     }
 
+    private string GetNotFoundUrl(string baseUri, NotFoundEventArgs args)
+    {
+        string path = args.Path;
+        if (string.IsNullOrEmpty(path))
+        {
+            var pathFormat = _httpContext.Items[nameof(StatusCodePagesOptions)] as string;
+            if (string.IsNullOrEmpty(pathFormat))
+            {
+                throw new InvalidOperationException("The NotFoundPage route must be specified or re-execution middleware has to be set to render NotFoundPage when the response has started.");
+            }
+
+            path = pathFormat;
+        }
+        return $"{baseUri}{path.TrimStart('/')}";
+    }
+
     private async Task OnNavigateTo(string uri)
     {
         if (_httpContext.Response.HasStarted)

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

@@ -226,16 +226,27 @@ private static void HandleExceptionAfterResponseStarted(HttpContext httpContext,
         writer.Write("</template><blazor-ssr-end></blazor-ssr-end></blazor-ssr>");
     }
 
+    private static void HandleNotFoundAfterResponseStarted(TextWriter writer, HttpContext httpContext, string notFoundUrl)
+    {
+        writer.Write("<blazor-ssr><template type=\"not-found\"");
+        WriteResponseTemplate(writer, httpContext, notFoundUrl, useEnhancedNav: true);
+    }
+
     private static void HandleNavigationAfterResponseStarted(TextWriter writer, HttpContext httpContext, string destinationUrl)
     {
         writer.Write("<blazor-ssr><template type=\"redirection\"");
+        bool useEnhancedNav = IsProgressivelyEnhancedNavigation(httpContext.Request);
+        WriteResponseTemplate(writer, httpContext, destinationUrl, useEnhancedNav);
+    }
 
-        if (string.Equals(httpContext.Request.Method, "POST", StringComparison.OrdinalIgnoreCase))
+    private static void WriteResponseTemplate(TextWriter writer, HttpContext httpContext, string destinationUrl, bool useEnhancedNav)
+    {
+        if (HttpMethods.IsPost(httpContext.Request.Method))
         {
             writer.Write(" from=\"form-post\"");
         }
 
-        if (IsProgressivelyEnhancedNavigation(httpContext.Request))
+        if (useEnhancedNav)
         {
             writer.Write(" enhanced=\"true\"");
         }

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

@@ -52,6 +52,8 @@ internal partial class EndpointHtmlRenderer : StaticHtmlRenderer, IComponentPrer
     // wait for the non-streaming tasks (these ones), then start streaming until full quiescence.
     private readonly List<Task> _nonStreamingPendingTasks = new();
 
+    private string _notFoundUrl = string.Empty;
+
     public EndpointHtmlRenderer(IServiceProvider serviceProvider, ILoggerFactory loggerFactory)
         : base(serviceProvider, loggerFactory)
     {
@@ -62,7 +64,7 @@ public EndpointHtmlRenderer(IServiceProvider serviceProvider, ILoggerFactory log
 
     internal HttpContext? HttpContext => _httpContext;
 
-    private void SetHttpContext(HttpContext httpContext)
+    internal void SetHttpContext(HttpContext httpContext)
     {
         if (_httpContext is null)
         {
@@ -83,10 +85,10 @@ internal async Task InitializeStandardComponentServicesAsync(
         var navigationManager = httpContext.RequestServices.GetRequiredService<NavigationManager>();
         ((IHostEnvironmentNavigationManager)navigationManager)?.Initialize(GetContextBaseUri(httpContext.Request), GetFullUri(httpContext.Request), OnNavigateTo);
 
-        if (navigationManager != null)
+        navigationManager?.OnNotFound += (sender, args) =>
         {
-            navigationManager.OnNotFound += async (sender, args) => await SetNotFoundResponseAsync(navigationManager.BaseUri);
-        }
+            _ = GetErrorHandledTask(SetNotFoundResponseAsync(navigationManager.BaseUri, args));
+        };
 
         var authenticationStateProvider = httpContext.RequestServices.GetService<AuthenticationStateProvider>();
         if (authenticationStateProvider is IHostEnvironmentAuthenticationStateProvider hostEnvironmentAuthenticationStateProvider)

src/Components/Endpoints/test/EndpointHtmlRendererTest.cs

@@ -1,9 +1,11 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System;
 using System.Text.Encodings.Web;
 using System.Text.Json;
 using System.Text.RegularExpressions;
+using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Components.Endpoints.Forms;
 using Microsoft.AspNetCore.Components.Endpoints.Tests.TestComponents;
 using Microsoft.AspNetCore.Components.Forms;
@@ -12,6 +14,7 @@
 using Microsoft.AspNetCore.Components.Reflection;
 using Microsoft.AspNetCore.Components.Rendering;
 using Microsoft.AspNetCore.Components.RenderTree;
+using Microsoft.AspNetCore.Components.Routing;
 using Microsoft.AspNetCore.Components.Test.Helpers;
 using Microsoft.AspNetCore.Components.Web;
 using Microsoft.AspNetCore.DataProtection;
@@ -934,6 +937,26 @@ await renderer.PrerenderComponentAsync(
         Assert.Equal("http://localhost/redirect", ctx.Response.Headers.Location);
     }
 
+    [Fact]
+    public async Task Renderer_WhenNoNotFoundPathProvided_Throws()
+    {
+        // Arrange
+        var httpContext = GetHttpContext();
+        var responseMock = new Mock<IHttpResponseFeature>();
+        responseMock.Setup(r => r.HasStarted).Returns(true);
+        responseMock.Setup(r => r.Headers).Returns(new HeaderDictionary());
+        httpContext.Features.Set(responseMock.Object);
+        var renderer = GetEndpointHtmlRenderer();
+        httpContext.Items[nameof(StatusCodePagesOptions)] = null; // simulate missing re-execution route
+
+        var exception = await Assert.ThrowsAsync<InvalidOperationException>(async () =>
+            await renderer.SetNotFoundResponseAsync(httpContext, new NotFoundEventArgs(""))
+        );
+        string expectedError = "The NotFoundPage route must be specified or re-execution middleware has to be set to render NotFoundPage when the response has started.";
+
+        Assert.Equal(expectedError, exception.Message);
+    }
+
     [Fact]
     public async Task CanRender_AsyncComponent()
     {
@@ -1802,6 +1825,12 @@ protected override void ProcessPendingRender()
             _rendererIsStopped = true;
             base.SignalRendererToFinishRendering();
         }
+
+        public async Task SetNotFoundResponseAsync(HttpContext httpContext, NotFoundEventArgs args)
+        {
+            SetHttpContext(httpContext);
+            await SetNotFoundResponseAsync(httpContext.Request.PathBase, args);
+        }
     }
 
     private HttpContext GetHttpContext(HttpContext context = null)

src/Components/Web.JS/src/Rendering/StreamingRendering.ts

@@ -45,35 +45,16 @@ class BlazorStreamingUpdate extends HTMLElement {
             insertStreamingContentIntoDocument(componentId, node.content);
           }
         } else {
+          const isEnhancedNav = node.getAttribute('enhanced') === 'true';
           switch (node.getAttribute('type')) {
             case 'redirection':
-              // We use 'replace' here because it's closest to the non-progressively-enhanced behavior, and will make the most sense
-              // if the async delay was very short, as the user would not perceive having been on the intermediate page.
-              const destinationUrl = toAbsoluteUri(node.content.textContent!);
-              const isFormPost = node.getAttribute('from') === 'form-post';
-              const isEnhancedNav = node.getAttribute('enhanced') === 'true';
-              if (isEnhancedNav && isWithinBaseUriSpace(destinationUrl)) {
-                // At this point the destinationUrl might be an opaque URL so we don't know whether it's internal/external or
-                // whether it's even going to the same URL we're currently on. So we don't know how to update the history.
-                // Defer that until the redirection is resolved by performEnhancedPageLoad.
-                const treatAsRedirectionFromMethod = isFormPost ? 'post' : 'get';
-                const fetchOptions = undefined;
-                performEnhancedPageLoad(destinationUrl, /* interceptedLink */ false, fetchOptions, treatAsRedirectionFromMethod);
-              } else {
-                if (isFormPost) {
-                  // The URL is not yet updated. Push a whole new entry so that 'back' goes back to the pre-redirection location.
-                  // WARNING: The following check to avoid duplicating history entries won't work if the redirection is to an opaque URL.
-                  // We could change the server-side logic to return URLs in plaintext if they match the current request URL already,
-                  // but it's arguably easier to understand that history non-duplication only works for enhanced nav, which is also the
-                  // case for non-streaming responses.
-                  if (destinationUrl !== location.href) {
-                    location.assign(destinationUrl);
-                  }
-                } else {
-                  // The URL was already updated on the original link click. Replace so that 'back' goes to the pre-redirection location.
-                  location.replace(destinationUrl);
-                }
-              }
+              redirect(node, true, isEnhancedNav);
+              break;
+            case 'not-found':
+              // not-found template has enhanced nav set to true by default,
+              // check for the options to avoid overriding user settings
+              const useEnhancedNav = isEnhancedNav && enableDomPreservation;
+              redirect(node, false, useEnhancedNav);
               break;
             case 'error':
               // This is kind of brutal but matches what happens without progressive enhancement
@@ -86,6 +67,35 @@ class BlazorStreamingUpdate extends HTMLElement {
   }
 }
 
+function redirect(node: HTMLTemplateElement, changeUrl: boolean, isEnhancedNav: boolean): void {
+  // We use 'replace' here because it's closest to the non-progressively-enhanced behavior, and will make the most sense
+ // if the async delay was very short, as the user would not perceive having been on the intermediate page.
+ const destinationUrl = toAbsoluteUri(node.content.textContent!);
+ const isFormPost = node.getAttribute('from') === 'form-post';
+ if (isEnhancedNav && isWithinBaseUriSpace(destinationUrl)) {
+   // At this point the destinationUrl might be an opaque URL so we don't know whether it's internal/external or
+   // whether it's even going to the same URL we're currently on. So we don't know how to update the history.
+   // Defer that until the redirection is resolved by performEnhancedPageLoad.
+   const treatAsRedirectionFromMethod = isFormPost ? 'post' : 'get';
+   const fetchOptions = undefined;
+   performEnhancedPageLoad(destinationUrl, /* interceptedLink */ false, fetchOptions, treatAsRedirectionFromMethod, changeUrl);
+ } else {
+   if (isFormPost) {
+     // The URL is not yet updated. Push a whole new entry so that 'back' goes back to the pre-redirection location.
+     // WARNING: The following check to avoid duplicating history entries won't work if the redirection is to an opaque URL.
+     // We could change the server-side logic to return URLs in plaintext if they match the current request URL already,
+     // but it's arguably easier to understand that history non-duplication only works for enhanced nav, which is also the
+     // case for non-streaming responses.
+     if (destinationUrl !== location.href) {
+       location.assign(destinationUrl);
+     }
+   } else {
+     // The URL was already updated on the original link click. Replace so that 'back' goes to the pre-redirection location.
+     location.replace(destinationUrl);
+   }
+  }
+}
+
 function insertStreamingContentIntoDocument(componentIdAsString: string, docFrag: DocumentFragment): void {
   const markers = findStreamingMarkers(componentIdAsString);
   if (markers) {