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/Http/Routing/src/Matching/HttpMethodMatcherPolicy.cs

@@ -113,8 +113,8 @@ public Task ApplyAsync(HttpContext httpContext, CandidateSet candidates)
             {
                 // We do this check first for consistency with how 405 is implemented for the graph version
                 // of this code. We still want to know if any endpoints in this set require an HTTP method
-                // even if those endpoints are already invalid.
-                var metadata = candidates[i].Endpoint.Metadata.GetMetadata<IHttpMethodMetadata>();
+                // even if those endpoints are already invalid - hence the null-check.
+                var metadata = candidates[i].Endpoint?.Metadata.GetMetadata<IHttpMethodMetadata>();
                 if (metadata == null || metadata.HttpMethods.Count == 0)
                 {
                     // Can match any method.

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
@@ -212,7 +213,7 @@ public static IEndpointConventionBuilder 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.
@@ -288,7 +289,7 @@ public static IEndpointConventionBuilder 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.
@@ -356,7 +357,7 @@ public static IEndpointConventionBuilder 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.
@@ -434,7 +435,7 @@ public static IEndpointConventionBuilder 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.
@@ -447,6 +448,44 @@ public static IEndpointConventionBuilder MapFallbackToAreaController(
             return builder;
         }
 
+        /// <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/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/ActionEndpointFactory.cs

@@ -36,7 +36,8 @@ public void AddEndpoints(
             HashSet<string> routeNames,
             ActionDescriptor action,
             IReadOnlyList<ConventionalRouteEntry> routes,
-            IReadOnlyList<Action<EndpointBuilder>> conventions)
+            IReadOnlyList<Action<EndpointBuilder>> conventions,
+            bool createInertEndpoints)
         {
             if (endpoints == null)
             {
@@ -63,6 +64,27 @@ public void AddEndpoints(
                 throw new ArgumentNullException(nameof(conventions));
             }
 
+            if (createInertEndpoints)
+            {
+                var requestDelegate = CreateRequestDelegate();
+                var builder = new InertEndpointBuilder()
+                {
+                    DisplayName = action.DisplayName,
+                    RequestDelegate = requestDelegate,
+                };
+                AddActionDataToBuilder(
+                    builder,
+                    routeNames,
+                    action,
+                    routeName: null,
+                    dataTokens: null,
+                    suppressLinkGeneration: false,
+                    suppressPathMatching: false,
+                    conventions,
+                    Array.Empty<Action<EndpointBuilder>>());
+                endpoints.Add(builder.Build());
+            }
+
             if (action.AttributeRouteInfo == null)
             {
                 // Check each of the conventional patterns to see if the action would be reachable.
@@ -81,18 +103,22 @@ public void AddEndpoints(
 
                     // We suppress link generation for each conventionally routed endpoint. We generate a single endpoint per-route
                     // to handle link generation.
-                    var builder = CreateEndpoint(
+                    var requestDelegate = CreateRequestDelegate();
+                    var builder = new RouteEndpointBuilder(requestDelegate, updatedRoutePattern, route.Order)
+                    {
+                        DisplayName = action.DisplayName,
+                    };
+                    AddActionDataToBuilder(
+                        builder,
                         routeNames,
                         action,
-                        updatedRoutePattern,
                         route.RouteName,
-                        route.Order,
                         route.DataTokens,
                         suppressLinkGeneration: true,
                         suppressPathMatching: false,
                         conventions,
                         route.Conventions);
-                    endpoints.Add(builder);
+                    endpoints.Add(builder.Build());
                 }
             }
             else
@@ -109,18 +135,22 @@ public void AddEndpoints(
                     throw new InvalidOperationException("Failed to update route pattern with required values.");
                 }
 
-                var endpoint = CreateEndpoint(
+                var requestDelegate = CreateRequestDelegate();
+                var builder = new RouteEndpointBuilder(requestDelegate, updatedRoutePattern, action.AttributeRouteInfo.Order)
+                {
+                    DisplayName = action.DisplayName,
+                };
+                AddActionDataToBuilder(
+                    builder,
                     routeNames,
                     action,
-                    updatedRoutePattern,
                     action.AttributeRouteInfo.Name,
-                    action.AttributeRouteInfo.Order,
                     dataTokens: null,
                     action.AttributeRouteInfo.SuppressLinkGeneration,
                     action.AttributeRouteInfo.SuppressPathMatching,
                     conventions,
                     perRouteConventions: Array.Empty<Action<EndpointBuilder>>());
-                endpoints.Add(endpoint);
+                endpoints.Add(builder.Build());
             }
         }
 
@@ -262,49 +292,17 @@ private static (RoutePattern resolvedRoutePattern, IDictionary<string, string> r
             return (attributeRoutePattern, resolvedRequiredValues ?? action.RouteValues);
         }
 
-        private RouteEndpoint CreateEndpoint(
+        private void AddActionDataToBuilder(
+            EndpointBuilder builder, 
             HashSet<string> routeNames,
             ActionDescriptor action,
-            RoutePattern routePattern,
             string routeName,
-            int order,
             RouteValueDictionary dataTokens,
             bool suppressLinkGeneration,
             bool suppressPathMatching,
             IReadOnlyList<Action<EndpointBuilder>> conventions,
             IReadOnlyList<Action<EndpointBuilder>> perRouteConventions)
         {
-
-            // 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 routeData = new RouteData();
-                routeData.PushState(router: null, context.Request.RouteValues, dataTokens);
-
-                var actionContext = new ActionContext(context, routeData, action);
-
-                if (invokerFactory == null)
-                {
-                    invokerFactory = context.RequestServices.GetRequiredService<IActionInvokerFactory>();
-                }
-
-                var invoker = invokerFactory.CreateInvoker(actionContext);
-                return invoker.InvokeAsync();
-            };
-
-            var builder = new RouteEndpointBuilder(requestDelegate, routePattern, order)
-            {
-                DisplayName = action.DisplayName,
-            };
-
             // Add action metadata first so it has a low precedence
             if (action.EndpointMetadata != null)
             {
@@ -399,8 +397,47 @@ private RouteEndpoint CreateEndpoint(
             {
                 perRouteConventions[i](builder);
             }
+        }
+
+        private static RequestDelegate CreateRequestDelegate()
+        {
+            // 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 endpoint = context.GetEndpoint();
+                var dataTokens = endpoint.Metadata.GetMetadata<IDataTokensMetadata>();
 
-            return (RouteEndpoint)builder.Build();
+                var routeData = new RouteData();
+                routeData.PushState(router: null, context.Request.RouteValues, new RouteValueDictionary(dataTokens?.DataTokens));
+
+                // Don't close over the ActionDescriptor, that's not valid for pages.
+                var action = endpoint.Metadata.GetMetadata<ActionDescriptor>();
+                var actionContext = new ActionContext(context, routeData, action);
+
+                if (invokerFactory == null)
+                {
+                    invokerFactory = context.RequestServices.GetRequiredService<IActionInvokerFactory>();
+                }
+
+                var invoker = invokerFactory.CreateInvoker(actionContext);
+                return invoker.InvokeAsync();
+            };
+        }
+
+        private class InertEndpointBuilder : EndpointBuilder
+        {
+            public override Endpoint Build()
+            {
+                return new Endpoint(RequestDelegate, new EndpointMetadataCollection(Metadata), DisplayName);
+            }
         }
     }
 }

src/Mvc/Mvc.Core/src/Routing/ConsumesMatcherPolicy.cs

@@ -73,8 +73,8 @@ public Task ApplyAsync(HttpContext httpContext, CandidateSet candidates)
             {
                 // We do this check first for consistency with how 415 is implemented for the graph version
                 // of this code. We still want to know if any endpoints in this set require an a ContentType
-                // even if those endpoints are already invalid.
-                var metadata = candidates[i].Endpoint.Metadata.GetMetadata<IConsumesMetadata>();
+                // even if those endpoints are already invalid - hence the null check.
+                var metadata = candidates[i].Endpoint?.Metadata.GetMetadata<IConsumesMetadata>();
                 if (metadata == null || metadata.ContentTypes.Count == 0)
                 {
                     // Can match any content type.

src/Mvc/Mvc.Core/src/Routing/ControllerActionEndpointDataSource.cs

@@ -20,12 +20,12 @@ internal class ControllerActionEndpointDataSource : ActionEndpointDataSourceBase
         private int _order;
 
         public ControllerActionEndpointDataSource(
-            IActionDescriptorCollectionProvider actions, 
+            IActionDescriptorCollectionProvider actions,
             ActionEndpointFactory endpointFactory)
             : base(actions)
         {
             _endpointFactory = endpointFactory;
- 
+
             _routes = new List<ConventionalRouteEntry>();
 
             // In traditional conventional routing setup, the routes defined by a user have a order
@@ -38,13 +38,17 @@ public ControllerActionEndpointDataSource(
 
             DefaultBuilder = new ControllerActionEndpointConventionBuilder(Lock, Conventions);
 
-            // IMPORTANT: this needs to be the last thing we do in the constructor. 
+            // IMPORTANT: this needs to be the last thing we do in the constructor.
             // Change notifications can happen immediately!
             Subscribe();
         }
 
         public ControllerActionEndpointConventionBuilder DefaultBuilder { get; }
 
+        // Used to control whether we create 'inert' (non-routable) endpoints for use in dynamic
+        // selection. Set to true by builder methods that do dynamic/fallback selection.
+        public bool CreateInertEndpoints { get; set; }
+
         public ControllerActionEndpointConventionBuilder AddRoute(
             string routeName,
             string pattern,
@@ -80,7 +84,7 @@ protected override List<Endpoint> CreateEndpoints(IReadOnlyList<ActionDescriptor
             {
                 if (actions[i] is ControllerActionDescriptor action)
                 {
-                    _endpointFactory.AddEndpoints(endpoints, routeNames, action, _routes, conventions);
+                    _endpointFactory.AddEndpoints(endpoints, routeNames, action, _routes, conventions, CreateInertEndpoints);
 
                     if (_routes.Count > 0)
                     {