Update ExceptionHandler middleware pipenline construction to reinvoke UseRouting in error branch

Author: John Luo

src/DefaultBuilder/src/WebApplicationBuilder.cs

@@ -167,7 +167,13 @@ private void ConfigureApplication(WebHostBuilderContext context, IApplicationBui
                 if (targetRouteBuilder is null)
                 {
                     // The app defined endpoints without calling UseRouting() explicitly, so call UseRouting() implicitly.
-                    app.UseRouting();
+                    app.UseRouting(overrideEndpointRouteBuilder: false);
+
+                    // Copy the endpoint route builder to the built application
+                    foreach (var item in app.Properties)
+                    {
+                        _builtApplication.Properties[item.Key] = item.Value;
+                    }
 
                     // An implicitly created IEndpointRouteBuilder was addeded to app.Properties by the UseRouting() call above.
                     targetRouteBuilder = GetEndpointRouteBuilder(app)!;

src/Http/Routing/src/Builder/EndpointRoutingApplicationBuilderExtensions.cs

@@ -42,10 +42,56 @@ public static IApplicationBuilder UseRouting(this IApplicationBuilder builder)
                 throw new ArgumentNullException(nameof(builder));
             }
 
+            return UseRouting(builder, true);
+        }
+
+        /// <summary>
+        /// Adds a <see cref="EndpointRoutingMiddleware"/> middleware to the specified <see cref="IApplicationBuilder"/>.
+        /// </summary>
+        /// <param name="builder">The <see cref="IApplicationBuilder"/> to add the middleware to.</param>
+        /// <param name="overrideEndpointRouteBuilder">Whether a new <see cref="EndpointRouteBuilder"/> should be created.</param>
+        /// <returns>A reference to this instance after the operation has completed.</returns>
+        /// <remarks>
+        /// <para>
+        /// A call to <see cref="UseRouting(IApplicationBuilder)"/> must be followed by a call to
+        /// <see cref="UseEndpoints(IApplicationBuilder, Action{IEndpointRouteBuilder})"/> for the same <see cref="IApplicationBuilder"/>
+        /// instance.
+        /// </para>
+        /// <para>
+        /// The <see cref="EndpointRoutingMiddleware"/> defines a point in the middleware pipeline where routing decisions are
+        /// made, and an <see cref="Endpoint"/> is associated with the <see cref="HttpContext"/>. The <see cref="EndpointMiddleware"/>
+        /// defines a point in the middleware pipeline where the current <see cref="Endpoint"/> is executed. Middleware between
+        /// the <see cref="EndpointRoutingMiddleware"/> and <see cref="EndpointMiddleware"/> may observe or change the
+        /// <see cref="Endpoint"/> associated with the <see cref="HttpContext"/>.
+        /// </para>
+        /// </remarks>
+        public static IApplicationBuilder UseRouting(this IApplicationBuilder builder, bool overrideEndpointRouteBuilder)
+        {
+            if (builder == null)
+            {
+                throw new ArgumentNullException(nameof(builder));
+            }
+
             VerifyRoutingServicesAreRegistered(builder);
 
-            var endpointRouteBuilder = new DefaultEndpointRouteBuilder(builder);
-            builder.Properties[EndpointRouteBuilder] = endpointRouteBuilder;
+            IEndpointRouteBuilder endpointRouteBuilder;
+            if (overrideEndpointRouteBuilder)
+            {
+                endpointRouteBuilder = new DefaultEndpointRouteBuilder(builder);
+                builder.Properties[EndpointRouteBuilder] = endpointRouteBuilder;
+            }
+            else
+            {
+                if (builder.Properties.TryGetValue(EndpointRouteBuilder, out var routeBuilder))
+                {
+                    endpointRouteBuilder = (IEndpointRouteBuilder)routeBuilder!;
+                }
+                else
+                {
+                    endpointRouteBuilder = new DefaultEndpointRouteBuilder(builder);
+                    builder.Properties[EndpointRouteBuilder] = endpointRouteBuilder;
+                }
+            }
 
             return builder.UseMiddleware<EndpointRoutingMiddleware>(endpointRouteBuilder);
         }

src/Middleware/Diagnostics/src/ExceptionHandler/ExceptionHandlerExtensions.cs

@@ -2,8 +2,12 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Diagnostics;
 using Microsoft.AspNetCore.Diagnostics;
 using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 
 namespace Microsoft.AspNetCore.Builder
@@ -95,7 +99,22 @@ public static IApplicationBuilder UseExceptionHandler(this IApplicationBuilder a
                 throw new ArgumentNullException(nameof(options));
             }
 
-            return app.UseMiddleware<ExceptionHandlerMiddleware>(Options.Create(options));
+            return app.Use(next =>
+            {
+                var loggerFactory = app.ApplicationServices.GetRequiredService<ILoggerFactory>();
+                var diagnosticListener = app.ApplicationServices.GetRequiredService<DiagnosticListener>();
+                var endpointDataSource = app.ApplicationServices.GetRequiredService<EndpointDataSource>();
+
+                if (!string.IsNullOrEmpty(options.ExceptionHandlingPath) && options.ExceptionHandler is null)
+                {
+                    var errorBuilder = app.New();
+                    errorBuilder.UseRouting(overrideEndpointRouteBuilder: false);
+                    errorBuilder.Run(next);
+                    options.ExceptionHandler = errorBuilder.Build();
+                }
+
+                return new ExceptionHandlerMiddleware(next, loggerFactory, Options.Create(options), diagnosticListener).Invoke;
+            });
         }
     }
 }