Add dynamic controller/page routes

Adds infrastructure for a common IRouter-based pattern. In this pattern,
an extender subclasses Route to post-process the route values before MVC
action selection run. The new infrastructure duplicates this kind of
experience but based on endpoint routing.

The approach in this PR starts at the bottom... meaning that this is the
most-focused and least-invasive way to implement a feature like this.
Similar to fallback routing, this is a pattern built with matcher
policies and metadata rather than a built-in feature of routing.

It's valuable to point out that this approach uses IActionConstraint to
disambiguate between actions. The other way we could go would be to make
the *other* matcher policy implementations able to do this. This would
mean that whenever you have a dynamic endpoint, you will not by using
the DFA for features like HTTP methods. It also means that we need to go
re-implement a bunch of infrastructure.

This PR also adds the concept of an 'inert' endpoint - a non-Routable
endpoint that's created when fallback/dynamic is in use. This seems like
a cleaner design because we don't start *matching* RouteEndpoint
instances for URLs that don't match. This resolves #8130

Author: Ryan Nowak

src/Mvc/Mvc.Core/src/Builder/ControllerEndpointRouteBuilderExtensions.cs

@@ -8,6 +8,7 @@
 using Microsoft.AspNetCore.Mvc.Routing;
 using Microsoft.AspNetCore.Routing;
 using Microsoft.AspNetCore.Routing.Constraints;
+using Microsoft.AspNetCore.Routing.Patterns;
 using Microsoft.Extensions.DependencyInjection;
 
 namespace Microsoft.AspNetCore.Builder
@@ -206,7 +207,7 @@ public static void MapFallbackToController(
             EnsureControllerServices(endpoints);
 
             // Called for side-effect to make sure that the data source is registered.
-            GetOrCreateDataSource(endpoints);
+            GetOrCreateDataSource(endpoints).CreateInertEndpoints = true;
 
             // Maps a fallback endpoint with an empty delegate. This is OK because
             // we don't expect the delegate to run.
@@ -280,7 +281,7 @@ public static void MapFallbackToController(
             EnsureControllerServices(endpoints);
 
             // Called for side-effect to make sure that the data source is registered.
-            GetOrCreateDataSource(endpoints);
+            GetOrCreateDataSource(endpoints).CreateInertEndpoints = true;
 
             // Maps a fallback endpoint with an empty delegate. This is OK because
             // we don't expect the delegate to run.
@@ -346,7 +347,7 @@ public static void MapFallbackToAreaController(
             EnsureControllerServices(endpoints);
 
             // Called for side-effect to make sure that the data source is registered.
-            GetOrCreateDataSource(endpoints);
+            GetOrCreateDataSource(endpoints).CreateInertEndpoints = true;
 
             // Maps a fallback endpoint with an empty delegate. This is OK because
             // we don't expect the delegate to run.
@@ -422,7 +423,7 @@ public static void MapFallbackToAreaController(
             EnsureControllerServices(endpoints);
 
             // Called for side-effect to make sure that the data source is registered.
-            GetOrCreateDataSource(endpoints);
+            GetOrCreateDataSource(endpoints).CreateInertEndpoints = true;
 
             // Maps a fallback endpoint with an empty delegate. This is OK because
             // we don't expect the delegate to run.
@@ -433,6 +434,44 @@ public static void MapFallbackToAreaController(
             });
         }
 
+        /// <summary>
+        /// Adds a specialized <see cref="RouteEndpoint"/> to the <see cref="IEndpointRouteBuilder"/> that will
+        /// attempt to select a controller action using the route values produced by <typeparamref name="TTransformer"/>.
+        /// </summary>
+        /// <param name="endpoints">The <see cref="IEndpointRouteBuilder"/> to add the route to.</param>
+        /// <param name="pattern">The URL pattern of the route.</param>
+        /// <typeparam name="TTransformer">The type of a <see cref="DynamicRouteValueTransformer"/>.</typeparam>
+        /// <remarks>
+        /// <para>
+        /// This method allows the registration of a <see cref="RouteEndpoint"/> and <see cref="DynamicRouteValueTransformer"/>
+        /// that combine to dynamically select a controller action using custom logic.
+        /// </para>
+        /// <para>
+        /// The instance of <typeparamref name="TTransformer"/> will be retrieved from the dependency injection container.
+        /// Register <typeparamref name="TTransformer"/> with the desired service lifetime in <c>ConfigureServices</c>.
+        /// </para>
+        /// </remarks>
+        public static void MapDynamicControllerRoute<TTransformer>(this IEndpointRouteBuilder endpoints, string pattern)
+            where TTransformer : DynamicRouteValueTransformer
+        {
+            if (endpoints == null)
+            {
+                throw new ArgumentNullException(nameof(endpoints));
+            }
+
+            EnsureControllerServices(endpoints);
+
+            // Called for side-effect to make sure that the data source is registered.
+            GetOrCreateDataSource(endpoints).CreateInertEndpoints = true;
+
+            // Maps a dynamic controller endpoint with an empty delegate. This is OK because
+            // we don't expect the delegate to run.
+            endpoints.Map(pattern, context => Task.CompletedTask).Add(b =>
+            {
+                b.Metadata.Add(new DynamicControllerRouteValueTransformerMetadata(typeof(TTransformer)));
+            });
+        }
+
         private static DynamicControllerMetadata CreateDynamicControllerMetadata(string action, string controller, string area)
         {
             return new DynamicControllerMetadata(new RouteValueDictionary()

src/Mvc/Mvc.Core/src/DependencyInjection/MvcCoreServiceCollectionExtensions.cs

@@ -171,7 +171,11 @@ internal static void AddMvcCoreServices(IServiceCollection services)
             //
             // Action Selection
             //
-            services.TryAddSingleton<IActionSelector, ActionSelector>();
+            services.TryAddSingleton<IActionSelector>(services =>
+            {
+                return services.GetRequiredService<ActionSelector>();
+            });
+            services.TryAddSingleton<ActionSelector>();
             services.TryAddSingleton<ActionConstraintCache>();
 
             // Will be cached by the DefaultActionSelector
@@ -269,7 +273,6 @@ internal static void AddMvcCoreServices(IServiceCollection services)
             //
             // Endpoint Routing / Endpoints
             //
-            services.TryAddSingleton<ActionEndpointDataSource>();
             services.TryAddSingleton<ControllerActionEndpointDataSource>();
             services.TryAddSingleton<ActionEndpointFactory>();
             services.TryAddSingleton<DynamicControllerEndpointSelector>();

src/Mvc/Mvc.Core/src/Infrastructure/ActionSelectionTable.cs

@@ -74,23 +74,23 @@ public static ActionSelectionTable<ActionDescriptor> Create(ActionDescriptorColl
                 });
         }
 
-        public static ActionSelectionTable<RouteEndpoint> Create(IEnumerable<Endpoint> endpoints)
+        public static ActionSelectionTable<Endpoint> Create(IEnumerable<Endpoint> endpoints)
         {
-            return CreateCore<RouteEndpoint>(
+            return CreateCore<Endpoint>(
 
                 // we don't use version for endpoints
                 version: 0, 
 
-                // Only include RouteEndpoints and only those that aren't suppressed. 
-                items: endpoints.OfType<RouteEndpoint>().Where(e =>
+                // Exclude RouteEndpoints - we only process inert endpoints here. 
+                items: endpoints.Where(e =>
                 {
-                    return e.Metadata.GetMetadata<ISuppressMatchingMetadata>()?.SuppressMatching != true;
+                    return e.GetType() == typeof(Endpoint);
                 }),
 
-                getRouteKeys: e => e.RoutePattern.RequiredValues.Keys,
+                getRouteKeys: e => e.Metadata.GetMetadata<ActionDescriptor>().RouteValues.Keys,
                 getRouteValue: (e, key) =>
                 {
-                    e.RoutePattern.RequiredValues.TryGetValue(key, out var value);
+                    e.Metadata.GetMetadata<ActionDescriptor>().RouteValues.TryGetValue(key, out var value);
                     return Convert.ToString(value, CultureInfo.InvariantCulture) ?? string.Empty;
                 });
         }

src/Mvc/Mvc.Core/src/Routing/ActionEndpointDataSource.cs

@@ -34,7 +34,8 @@ public void AddEndpoints(
             List<Endpoint> endpoints,
             ActionDescriptor action,
             IReadOnlyList<ConventionalRouteEntry> routes,
-            IReadOnlyList<Action<EndpointBuilder>> conventions)
+            IReadOnlyList<Action<EndpointBuilder>> conventions,
+            bool createInertEndpoints)
         {
             if (endpoints == null)
             {
@@ -56,6 +57,17 @@ public void AddEndpoints(
                 throw new ArgumentNullException(nameof(conventions));
             }
 
+            if (createInertEndpoints)
+            {
+                // For each ActionDescriptor create a single 'inert' Endpoint without routing information.
+                //
+                // This makes those endpoints accessible for dynamic and fallback routing. We don't want to
+                // mix RouteEndpoint that is selected by routing, vs Endpoint that is selected by user code/policies
+                //
+                // This also helps us avoid ambiguities when an endpoint has multiple conventional routes.
+                endpoints.Add(CreateInertEndpoint(action, conventions));
+            }
+
             if (action.AttributeRouteInfo == null)
             {
                 // In traditional conventional routing setup, the routes defined by a user have a static order
@@ -181,32 +193,54 @@ private RouteEndpoint CreateEndpoint(
             bool suppressPathMatching,
             IReadOnlyList<Action<EndpointBuilder>> conventions)
         {
-
-            // We don't want to close over the retrieve the Invoker Factory in ActionEndpointFactory as
-            // that creates cycles in DI. Since we're creating this delegate at startup time
-            // we don't want to create all of the things we use at runtime until the action
-            // actually matches.
-            //
-            // The request delegate is already a closure here because we close over
-            // the action descriptor.
-            IActionInvokerFactory invokerFactory = null;
-
-            RequestDelegate requestDelegate = (context) =>
+            var builder = new RouteEndpointBuilder(CreateRequestDelegate(action), routePattern, order)
             {
-                var routeData = context.GetRouteData();
-                var actionContext = new ActionContext(context, routeData, action);
+                DisplayName = action.DisplayName,
+            };
 
-                if (invokerFactory == null)
+            // Add action metadata first so it has a low precedence
+            if (action.EndpointMetadata != null)
+            {
+                foreach (var d in action.EndpointMetadata)
                 {
-                    invokerFactory = context.RequestServices.GetRequiredService<IActionInvokerFactory>();
+                    builder.Metadata.Add(d);
                 }
+            }
 
-                var invoker = invokerFactory.CreateInvoker(actionContext);
-                return invoker.InvokeAsync();
-            };
+            builder.Metadata.Add(action);
+
+            if (dataTokens != null)
+            {
+                builder.Metadata.Add(new DataTokensMetadata(dataTokens));
+            }
 
-            var builder = new RouteEndpointBuilder(requestDelegate, routePattern, order)
+            builder.Metadata.Add(new RouteNameMetadata(routeName));
+
+            AddMetadataFromActionDescriptor(builder, action);
+
+            if (suppressLinkGeneration)
             {
+                builder.Metadata.Add(new SuppressLinkGenerationMetadata());
+            }
+
+            if (suppressPathMatching)
+            {
+                builder.Metadata.Add(new SuppressMatchingMetadata());
+            }
+
+            for (var i = 0; i < conventions.Count; i++)
+            {
+                conventions[i](builder);
+            }
+
+            return (RouteEndpoint)builder.Build();
+        }
+
+        private Endpoint CreateInertEndpoint(ActionDescriptor action, IReadOnlyList<Action<EndpointBuilder>> conventions)
+        {
+            var builder = new InertEndpointBuilder()
+            {
+                RequestDelegate = CreateRequestDelegate(action),
                 DisplayName = action.DisplayName,
             };
 
@@ -221,13 +255,44 @@ private RouteEndpoint CreateEndpoint(
 
             builder.Metadata.Add(action);
 
-            if (dataTokens != null)
+            AddMetadataFromActionDescriptor(builder, action);
+
+            for (var i = 0; i < conventions.Count; i++)
             {
-                builder.Metadata.Add(new DataTokensMetadata(dataTokens));
+                conventions[i](builder);
             }
 
-            builder.Metadata.Add(new RouteNameMetadata(routeName));
+            return builder.Build();
+        }
 
+        private RequestDelegate CreateRequestDelegate(ActionDescriptor action)
+        {
+            // We don't want to close over the retrieve the Invoker Factory in ActionEndpointFactory as
+            // that creates cycles in DI. Since we're creating this delegate at startup time
+            // we don't want to create all of the things we use at runtime until the action
+            // actually matches.
+            //
+            // The request delegate is already a closure here because we close over
+            // the action descriptor.
+            IActionInvokerFactory invokerFactory = null;
+
+            return (context) =>
+            {
+                var routeData = context.GetRouteData();
+                var actionContext = new ActionContext(context, routeData, action);
+
+                if (invokerFactory == null)
+                {
+                    invokerFactory = context.RequestServices.GetRequiredService<IActionInvokerFactory>();
+                }
+
+                var invoker = invokerFactory.CreateInvoker(actionContext);
+                return invoker.InvokeAsync();
+            };
+        }
+
+        private void AddMetadataFromActionDescriptor(EndpointBuilder builder, ActionDescriptor action)
+        {
             // Add filter descriptors to endpoint metadata
             if (action.FilterDescriptors != null && action.FilterDescriptors.Count > 0)
             {
@@ -263,23 +328,14 @@ private RouteEndpoint CreateEndpoint(
                     }
                 }
             }
+        }
 
-            if (suppressLinkGeneration)
-            {
-                builder.Metadata.Add(new SuppressLinkGenerationMetadata());
-            }
-
-            if (suppressPathMatching)
-            {
-                builder.Metadata.Add(new SuppressMatchingMetadata());
-            }
-
-            for (var i = 0; i < conventions.Count; i++)
+        private class InertEndpointBuilder : EndpointBuilder
+        {
+            public override Endpoint Build()
             {
-                conventions[i](builder);
+                return new Endpoint(RequestDelegate, new EndpointMetadataCollection(Metadata), DisplayName);
             }
-
-            return (RouteEndpoint)builder.Build();
         }
     }
 }