Interactive NotFound event + SSR status code.

Author: ilonatommy

src/Components/Components/src/NavigationManager.cs

@@ -35,6 +35,29 @@ public event EventHandler<LocationChangedEventArgs> LocationChanged
 
     private CancellationTokenSource? _locationChangingCts;
 
+    /// <summary>
+    /// An event that fires when the page is not found.
+    /// </summary>
+    public event EventHandler<NotFoundEventArgs> NotFoundEvent
+    {
+        add
+        {
+            AssertInitialized();
+            _notFound += value;
+        }
+        remove
+        {
+            AssertInitialized();
+            _notFound -= value;
+        }
+    }
+
+    private EventHandler<NotFoundEventArgs>? _notFound;
+
+    private readonly List<Func<NotFoundContext, ValueTask>> _notFoundHandlers = new();
+
+    private CancellationTokenSource? _notFoundCts;
+
     // 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;
@@ -177,6 +200,16 @@ protected virtual void NavigateToCore([StringSyntax(StringSyntaxAttribute.Uri)]
     public virtual void Refresh(bool forceReload = false)
         => NavigateTo(Uri, forceLoad: true, replace: true);
 
+    /// <summary>
+    /// TODO
+    /// </summary>
+    public virtual void NotFound() => NotFoundCore();
+
+    /// <summary>
+    /// TODO
+    /// </summary>
+    protected virtual void NotFoundCore() => throw new NotImplementedException();
+
     /// <summary>
     /// Called to initialize BaseURI and current URI before these values are used for the first time.
     /// Override <see cref="EnsureInitialized" /> and call this method to dynamically calculate these values.
@@ -308,6 +341,26 @@ protected void NotifyLocationChanged(bool isInterceptedLink)
         }
     }
 
+    /// <summary>
+    /// Triggers the <see cref="NotFound"/> event with the current URI value.
+    /// </summary>
+    protected void NotifyNotFound(bool isInterceptedLink)
+    {
+        try
+        {
+            _notFound?.Invoke(
+                this,
+                new NotFoundEventArgs(isInterceptedLink)
+                {
+                    HistoryEntryState = HistoryEntryState
+                });
+        }
+        catch (Exception ex)
+        {
+            throw new NotFoundRenderingException("An exception occurred while dispatching a NotFound event.", ex);
+        }
+    }
+
     /// <summary>
     /// Notifies the registered handlers of the current location change.
     /// </summary>
@@ -433,12 +486,135 @@ protected async ValueTask<bool> NotifyLocationChangingAsync(string uri, string?
             cts.Dispose();
 
             if (_locationChangingCts == cts)
-            {
+        {
                 _locationChangingCts = null;
             }
         }
     }
 
+    /// <summary>
+    /// Notifies the registered handlers of the current ot found event.
+    /// </summary>
+    /// <param name="isNavigationIntercepted">Whether this not found was intercepted from a link.</param>
+    /// <returns>A <see cref="ValueTask{TResult}"/> representing the completion of the operation. If the result is <see langword="true"/>, the navigation should continue.</returns>
+    protected async ValueTask<bool> NotifyNotFoundAsync(bool isNavigationIntercepted)
+    {
+        _notFoundCts?.Cancel();
+        _notFoundCts = null;
+
+        var handlerCount = _notFoundHandlers.Count;
+
+        if (handlerCount == 0)
+        {
+            return true;
+        }
+
+        var cts = new CancellationTokenSource();
+
+        _notFoundCts = cts;
+
+        var cancellationToken = cts.Token;
+        var context = new NotFoundContext
+        {
+            // HistoryEntryState = state,
+            IsNavigationIntercepted = isNavigationIntercepted,
+            CancellationToken = cancellationToken,
+        };
+
+        try
+        {
+            if (handlerCount == 1)
+            {
+                var handlerTask = InvokeNotFoundHandlerAsync(_notFoundHandlers[0], context);
+
+                if (handlerTask.IsFaulted)
+                {
+                    await handlerTask;
+                    return false; // Unreachable because the previous line will throw.
+                }
+
+                if (context.DidPreventRendering)
+                {
+                    return false;
+                }
+
+                if (!handlerTask.IsCompletedSuccessfully)
+                {
+                    await handlerTask.AsTask().WaitAsync(cancellationToken);
+                }
+            }
+            else
+            {
+                var notFoundHandlersCopy = ArrayPool<Func<NotFoundContext, ValueTask>>.Shared.Rent(handlerCount);
+
+                try
+                {
+                    _notFoundHandlers.CopyTo(notFoundHandlersCopy);
+
+                    var notFoundTasks = new HashSet<Task>();
+
+                    for (var i = 0; i < handlerCount; i++)
+                    {
+                        var handlerTask = InvokeNotFoundHandlerAsync(notFoundHandlersCopy[i], context);
+
+                        if (handlerTask.IsFaulted)
+                        {
+                            await handlerTask;
+                            return false; // Unreachable because the previous line will throw.
+                        }
+
+                        if (context.DidPreventRendering)
+                        {
+                            return false;
+                        }
+
+                        notFoundTasks.Add(handlerTask.AsTask());
+                    }
+
+                    while (notFoundTasks.Count != 0)
+                    {
+                        var completedHandlerTask = await Task.WhenAny(notFoundTasks).WaitAsync(cancellationToken);
+
+                        if (completedHandlerTask.IsFaulted)
+                        {
+                            await completedHandlerTask;
+                            return false; // Unreachable because the previous line will throw.
+                        }
+
+                        notFoundTasks.Remove(completedHandlerTask);
+                    }
+                }
+                finally
+                {
+                    ArrayPool<Func<NotFoundContext, ValueTask>>.Shared.Return(notFoundHandlersCopy);
+                }
+            }
+
+            return !context.DidPreventRendering;
+        }
+        catch (TaskCanceledException ex)
+        {
+            if (ex.CancellationToken == cancellationToken)
+            {
+                // This navigation was in progress when a successive navigation occurred.
+                // We treat this as a canceled navigation.
+                return false;
+            }
+
+            throw;
+        }
+        finally
+        {
+            cts.Cancel();
+            cts.Dispose();
+
+            if (_notFoundCts == cts)
+        {
+                _notFoundCts = null;
+            }
+        }
+    }
+
     private async ValueTask InvokeLocationChangingHandlerAsync(Func<LocationChangingContext, ValueTask> handler, LocationChangingContext context)
     {
         try
@@ -455,6 +631,22 @@ private async ValueTask InvokeLocationChangingHandlerAsync(Func<LocationChanging
         }
     }
 
+    private async ValueTask InvokeNotFoundHandlerAsync(Func<NotFoundContext, ValueTask> handler, NotFoundContext context)
+    {
+        try
+        {
+            await handler(context);
+        }
+        catch (OperationCanceledException)
+        {
+            // Ignore exceptions caused by cancellations.
+        }
+        catch (Exception ex)
+        {
+            HandleNotFoundHandlerException(ex, context);
+        }
+    }
+
     /// <summary>
     /// Handles exceptions thrown in location changing handlers.
     /// </summary>
@@ -463,6 +655,14 @@ private async ValueTask InvokeLocationChangingHandlerAsync(Func<LocationChanging
     protected virtual void HandleLocationChangingHandlerException(Exception ex, LocationChangingContext context)
         => throw new InvalidOperationException($"To support navigation locks, {GetType().Name} must override {nameof(HandleLocationChangingHandlerException)}");
 
+    /// <summary>
+    /// Handles exceptions thrown in NotFound rendering handlers.
+    /// </summary>
+    /// <param name="ex">The exception to handle.</param>
+    /// <param name="context">The context passed to the handler.</param>
+    protected virtual void HandleNotFoundHandlerException(Exception ex, NotFoundContext context)
+        => throw new InvalidOperationException($"To support not found rendering locks, {GetType().Name} must override {nameof(HandleNotFoundHandlerException)}");
+
     /// <summary>
     /// Sets whether navigation is currently locked. If it is, then implementations should not update <see cref="Uri"/> and call
     /// <see cref="NotifyLocationChanged(bool)"/> until they have first confirmed the navigation by calling

src/Components/Components/src/NotFoundRenderingException.cs

@@ -0,0 +1,20 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.AspNetCore.Components;
+
+/// <summary>
+/// Exception thrown when an <see cref="NavigationManager"/> is not able to render not found page.
+/// </summary>
+public class NotFoundRenderingException : Exception
+{
+        /// <summary>
+    /// Creates a new instance of <see cref="NotFoundRenderingException"/>.
+    /// </summary>
+    /// <param name="message">The exception message.</param>
+    /// <param name="innerException">The inner exception.</param>
+    public NotFoundRenderingException(string message, Exception innerException)
+        : base(message, innerException)
+    {
+    }
+}

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

@@ -1 +1,21 @@
 #nullable enable
+
+virtual Microsoft.AspNetCore.Components.NavigationManager.NotFound() -> void
+virtual Microsoft.AspNetCore.Components.NavigationManager.NotFoundCore() -> void
+Microsoft.AspNetCore.Components.NavigationManager.NotFoundEvent -> System.EventHandler<Microsoft.AspNetCore.Components.Routing.NotFoundEventArgs!>!
+Microsoft.AspNetCore.Components.Routing.NotFoundEventArgs
+Microsoft.AspNetCore.Components.Routing.NotFoundEventArgs.NotFoundEventArgs(bool isNavigationIntercepted) -> void
+Microsoft.AspNetCore.Components.Routing.NotFoundEventArgs.IsNavigationIntercepted.get -> bool
+Microsoft.AspNetCore.Components.Routing.NotFoundEventArgs.HistoryEntryState.get -> string?
+Microsoft.AspNetCore.Components.Routing.NotFoundContext
+Microsoft.AspNetCore.Components.Routing.NotFoundContext.NotFoundContext() -> void
+Microsoft.AspNetCore.Components.Routing.NotFoundContext.CancellationToken.get -> System.Threading.CancellationToken
+Microsoft.AspNetCore.Components.Routing.NotFoundContext.CancellationToken.init -> void
+Microsoft.AspNetCore.Components.Routing.NotFoundContext.IsNavigationIntercepted.get -> bool
+Microsoft.AspNetCore.Components.Routing.NotFoundContext.IsNavigationIntercepted.init -> void
+Microsoft.AspNetCore.Components.Routing.NotFoundContext.PreventRendering() -> void
+Microsoft.AspNetCore.Components.NavigationManager.NotifyNotFound(bool isInterceptedLink) -> void
+Microsoft.AspNetCore.Components.NavigationManager.NotifyNotFoundAsync(bool isNavigationIntercepted) -> System.Threading.Tasks.ValueTask<bool>
+virtual Microsoft.AspNetCore.Components.NavigationManager.HandleNotFoundHandlerException(System.Exception! ex, Microsoft.AspNetCore.Components.Routing.NotFoundContext! context) -> void
+Microsoft.AspNetCore.Components.NotFoundRenderingException
+Microsoft.AspNetCore.Components.NotFoundRenderingException.NotFoundRenderingException(string! message, System.Exception! innerException) -> void

src/Components/Components/src/Routing/NotFoundContext.cs

@@ -0,0 +1,32 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.AspNetCore.Components.Routing;
+
+/// <summary>
+/// Contains context for a change to the browser's current location.
+/// </summary>
+public sealed class NotFoundContext
+{
+    internal bool DidPreventRendering { get; private set; }
+
+    /// <summary>
+    /// Gets a <see cref="System.Threading.CancellationToken"/> that can be used to determine if this navigation was canceled
+    /// (for example, because the user has triggered a different navigation).
+    /// </summary>
+    public CancellationToken CancellationToken { get; init; }
+
+    /// <summary>
+    /// Gets whether this navigation was intercepted from a link.
+    /// </summary>
+    public bool IsNavigationIntercepted { get; init; }
+
+    /// <summary>
+    /// Prevents this navigation from continuing.
+    /// </summary>
+    public void PreventRendering()
+    {
+        DidPreventRendering = true;
+    }
+
+}

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

@@ -0,0 +1,29 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.AspNetCore.Components.Routing;
+
+/// <summary>
+/// <see cref="EventArgs" /> for <see cref="NavigationManager.NotFound" />.
+/// </summary>
+public class NotFoundEventArgs : EventArgs
+{
+    /// <summary>
+    /// Initializes a new instance of <see cref="NotFoundEventArgs" />.
+    /// </summary>
+    /// <param name="isNavigationIntercepted">A value that determines if navigation for the link was intercepted.</param>
+    public NotFoundEventArgs(bool isNavigationIntercepted)
+    {
+        IsNavigationIntercepted = isNavigationIntercepted;
+    }
+
+    /// <summary>
+    /// Gets a value that determines if navigation to NotFound page was intercepted.
+    /// </summary>
+    public bool IsNavigationIntercepted { get; }
+
+    /// <summary>
+    /// Gets the state associated with the current history entry.
+    /// </summary>
+    public string? HistoryEntryState { get; internal init; }
+}

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

@@ -105,6 +105,7 @@ public void Attach(RenderHandle renderHandle)
         _baseUri = NavigationManager.BaseUri;
         _locationAbsolute = NavigationManager.Uri;
         NavigationManager.LocationChanged += OnLocationChanged;
+        NavigationManager.NotFoundEvent += OnNotFound;
         RoutingStateProvider = ServiceProvider.GetService<IRoutingStateProvider>();
 
         if (HotReloadManager.Default.MetadataUpdateSupported)
@@ -146,6 +147,7 @@ public async Task SetParametersAsync(ParameterView parameters)
     public void Dispose()
     {
         NavigationManager.LocationChanged -= OnLocationChanged;
+        NavigationManager.NotFoundEvent -= OnNotFound;
         if (HotReloadManager.Default.MetadataUpdateSupported)
         {
             HotReloadManager.Default.OnDeltaApplied -= ClearRouteCaches;
@@ -320,6 +322,15 @@ private void OnLocationChanged(object sender, LocationChangedEventArgs args)
         }
     }
 
+    private void OnNotFound(object sender, NotFoundEventArgs args)
+    {
+        if (_renderHandle.IsInitialized)
+        {
+            Log.DisplayingNotFound(_logger);
+            _renderHandle.Render(NotFound ?? DefaultNotFoundContent);
+        }
+    }
+
     async Task IHandleAfterRender.OnAfterRenderAsync()
     {
         if (!_navigationInterceptionEnabled)
@@ -340,6 +351,9 @@ private static partial class Log
         [LoggerMessage(1, LogLevel.Debug, $"Displaying {nameof(NotFound)} because path '{{Path}}' with base URI '{{BaseUri}}' does not match any component route", EventName = "DisplayingNotFound")]
         internal static partial void DisplayingNotFound(ILogger logger, string path, string baseUri);
 
+        [LoggerMessage(1, LogLevel.Debug, $"Displaying {nameof(NotFound)} on request", EventName = "DisplayingNotFoundOnRequest")]
+        internal static partial void DisplayingNotFound(ILogger logger);
+
         [LoggerMessage(2, LogLevel.Debug, "Navigating to component {ComponentType} in response to path '{Path}' with base URI '{BaseUri}'", EventName = "NavigatingToComponent")]
         internal static partial void NavigatingToComponent(ILogger logger, Type componentType, string path, string baseUri);