Static pages amid global interactivity

src/Components/Components/src/ComponentFactory.cs

@@ -49,23 +49,16 @@ private static ComponentTypeInfoCacheEntry GetComponentTypeInfo([DynamicallyAcce
     public IComponent InstantiateComponent(IServiceProvider serviceProvider, [DynamicallyAccessedMembers(Component)] Type componentType, IComponentRenderMode? callerSpecifiedRenderMode, int? parentComponentId)
     {
         var (componentTypeRenderMode, propertyInjector) = GetComponentTypeInfo(componentType);
-        IComponent component;
 
-        if (componentTypeRenderMode is null && callerSpecifiedRenderMode is null)
-        {
-            // Typical case where no rendermode is specified in either location. We don't call ResolveComponentForRenderMode in this case.
-            component = _componentActivator.CreateInstance(componentType);
-        }
-        else
-        {
-            // At least one rendermode is specified. We require that it's exactly one, and use ResolveComponentForRenderMode with it.
-            var effectiveRenderMode = callerSpecifiedRenderMode is null
-                ? componentTypeRenderMode!
-                : componentTypeRenderMode is null
-                    ? callerSpecifiedRenderMode
-                    : throw new InvalidOperationException($"The component type '{componentType}' has a fixed rendermode of '{componentTypeRenderMode}', so it is not valid to specify any rendermode when using this component.");
-            component = _renderer.ResolveComponentForRenderMode(componentType, parentComponentId, _componentActivator, effectiveRenderMode);
-        }
+        // In the typical case where no rendermode is specified in either location, we don't even call
+        // ComputeEffectiveRenderMode and hence don't call ResolveComponentForRenderMode either.
+        var effectiveRenderMode = componentTypeRenderMode is null && callerSpecifiedRenderMode is null
+            ? null
+            : _renderer.ResolveEffectiveRenderMode(componentType, parentComponentId, componentTypeRenderMode, callerSpecifiedRenderMode);
+
+        var component = effectiveRenderMode is null
+            ? _componentActivator.CreateInstance(componentType)
+            : _renderer.ResolveComponentForRenderMode(componentType, parentComponentId, _componentActivator, effectiveRenderMode);
 
         if (component is null)
         {

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

@@ -1 +1,4 @@
 #nullable enable
+Microsoft.AspNetCore.Components.RouteAttribute.Static.get -> bool
+Microsoft.AspNetCore.Components.RouteAttribute.Static.set -> void
+virtual Microsoft.AspNetCore.Components.RenderTree.Renderer.ResolveEffectiveRenderMode(System.Type! componentType, int? parentComponentId, Microsoft.AspNetCore.Components.IComponentRenderMode? componentTypeRenderMode, Microsoft.AspNetCore.Components.IComponentRenderMode? callerSpecifiedRenderMode) -> Microsoft.AspNetCore.Components.IComponentRenderMode?

src/Components/Components/src/RenderTree/Renderer.cs

@@ -1228,6 +1228,27 @@ void NotifyExceptions(List<Exception> exceptions)
         }
     }
 
+    /// <summary>
+    /// Determines the rendermode to use for a component when one is specified either at the call site or on the component type.
+    /// Renderer subclasses may override this to impose additional rules about rendermode selection.
+    /// </summary>
+    /// <param name="componentType">The type of component that was requested.</param>
+    /// <param name="parentComponentId">The parent component ID, or null if it is a root component.</param>
+    /// <param name="componentTypeRenderMode">The <see cref="IComponentRenderMode"/> declared on <paramref name="componentType"/>.</param>
+    /// <param name="callerSpecifiedRenderMode">The <see cref="IComponentRenderMode"/> declared at the call site (for example, by the parent component).</param>
+    /// <returns></returns>
+    /// <exception cref="InvalidOperationException"></exception>
+    protected internal virtual IComponentRenderMode? ResolveEffectiveRenderMode(Type componentType, int? parentComponentId, IComponentRenderMode? componentTypeRenderMode, IComponentRenderMode? callerSpecifiedRenderMode)
+    {
+        // To avoid confusion, we require that you don't specify the rendermode in two places. This means that
+        // the resolution is trivial - just use the nonnull one (if any).
+        return callerSpecifiedRenderMode is null
+            ? componentTypeRenderMode!
+            : componentTypeRenderMode is null
+                ? callerSpecifiedRenderMode
+                : throw new InvalidOperationException($"The component type '{componentType}' has a fixed rendermode of '{componentTypeRenderMode}', so it is not valid to specify any rendermode when using this component.");
+    }
+
     /// <summary>
     /// Determines how to handle an <see cref="IComponentRenderMode"/> when obtaining a component instance.
     /// This is only called when a render mode is specified either at the call site or on the component type.

src/Components/Components/src/RouteAttribute.cs

@@ -24,4 +24,10 @@ public RouteAttribute(string template)
     /// Gets the route template.
     /// </summary>
     public string Template { get; }
+
+    /// <summary>
+    /// Gets or sets a flag to indicate whether the page should be rendered statically.
+    /// The effect of this flag is to suppress any <code>@rendermode</code> directives in the root component.
+    /// </summary>
+    public bool Static { get; set; }
 }

src/Components/Components/src/Routing/RouteTable.cs

@@ -11,7 +11,7 @@ namespace Microsoft.AspNetCore.Components.Routing;
 internal sealed class RouteTable(TreeRouter treeRouter)
 {
     private readonly TreeRouter _router = treeRouter;
-    private static readonly ConcurrentDictionary<(Type, string), InboundRouteEntry> _routeEntryCache = new();
+    private static readonly ConcurrentDictionary<(Type, string), InboundRouteEntry> _parameterProcessingRouteEntryCache = new();
 
     public TreeRouter? TreeRouter => _router;
 
@@ -23,9 +23,11 @@ internal static RouteData ProcessParameters(RouteData endpointRouteData)
     {
         if (endpointRouteData.Template != null)
         {
-            var entry = _routeEntryCache.GetOrAdd(
+            // When building this cache, we include static routes because even though the interactive router doesn't use them for
+            // matching, we still need to process the parameters for them after they are matched during endpoint routing.
+            var entry = _parameterProcessingRouteEntryCache.GetOrAdd(
                 (endpointRouteData.PageType, endpointRouteData.Template),
-                ((Type page, string template) key) => RouteTableFactory.CreateEntry(key.page, key.template));
+                ((Type page, string template) key) => RouteTableFactory.CreateEntry(key.page, key.template, includeStaticRoutes: true));
 
             var routeValueDictionary = new RouteValueDictionary(endpointRouteData.RouteValues);
             foreach (var kvp in endpointRouteData.RouteValues)

src/Components/Components/src/Routing/RouteTableFactory.cs

@@ -83,35 +83,40 @@ static void GetRouteableComponents(List<Type> routeableComponents, Assembly asse
 
     internal static RouteTable Create(List<Type> componentTypes, IServiceProvider serviceProvider)
     {
-        var templatesByHandler = new Dictionary<Type, string[]>();
+        var templatesByHandler = new Dictionary<Type, IReadOnlyList<string>>();
         foreach (var componentType in componentTypes)
         {
             // We're deliberately using inherit = false here.
             //
             // RouteAttribute is defined as non-inherited, because inheriting a route attribute always causes an
             // ambiguity. You end up with two components (base class and derived class) with the same route.
-            var templates = GetTemplates(componentType);
-
-            templatesByHandler.Add(componentType, templates);
+            // We exclude static routes because this is the interactive router.
+            var templates = GetTemplates(componentType, includeStaticRoutes: false);
+            if (templates.Count > 0)
+            {
+                templatesByHandler.Add(componentType, templates);
+            }
         }
         return Create(templatesByHandler, serviceProvider);
     }
 
-    private static string[] GetTemplates(Type componentType)
+    private static IReadOnlyList<string> GetTemplates(Type componentType, bool includeStaticRoutes)
     {
         var routeAttributes = componentType.GetCustomAttributes(typeof(RouteAttribute), inherit: false);
-        var templates = new string[routeAttributes.Length];
-        for (var i = 0; i < routeAttributes.Length; i++)
+        var templates = new List<string>(routeAttributes.Length);
+        foreach (RouteAttribute routeAttribute in routeAttributes)
         {
-            var attribute = (RouteAttribute)routeAttributes[i];
-            templates[i] = attribute.Template;
+            if (includeStaticRoutes || !routeAttribute.Static)
+            {
+                templates.Add(routeAttribute.Template);
+            }
         }
 
         return templates;
     }
 
     [UnconditionalSuppressMessage("Trimming", "IL2067", Justification = "Application code does not get trimmed, and the framework does not define routable components.")]
-    internal static RouteTable Create(Dictionary<Type, string[]> templatesByHandler, IServiceProvider serviceProvider)
+    internal static RouteTable Create(Dictionary<Type, IReadOnlyList<string>> templatesByHandler, IServiceProvider serviceProvider)
     {
         var routeOptions = Options.Create(new RouteOptions());
         if (!OperatingSystem.IsBrowser() || RegexConstraintSupport.IsEnabled)
@@ -141,10 +146,10 @@ internal static RouteTable Create(Dictionary<Type, string[]> templatesByHandler,
         return new RouteTable(builder.Build());
     }
 
-    private static TemplateGroupInfo ComputeTemplateGroupInfo(string[] templates)
+    private static TemplateGroupInfo ComputeTemplateGroupInfo(IReadOnlyList<string> templates)
     {
         var result = new TemplateGroupInfo(templates);
-        for (var i = 0; i < templates.Length; i++)
+        for (var i = 0; i < templates.Count; i++)
         {
             var parsedTemplate = RoutePatternParser.Parse(templates[i]);
             var parameterNames = GetParameterNames(parsedTemplate);
@@ -159,15 +164,15 @@ private static TemplateGroupInfo ComputeTemplateGroupInfo(string[] templates)
         return result;
     }
 
-    private struct TemplateGroupInfo(string[] templates)
+    private struct TemplateGroupInfo(IReadOnlyCollection<string> templates)
     {
         public HashSet<string> AllRouteParameterNames { get; set; } = new(StringComparer.OrdinalIgnoreCase);
-        public (RoutePattern, HashSet<string>)[] ParsedTemplates { get; set; } = new (RoutePattern, HashSet<string>)[templates.Length];
+        public (RoutePattern, HashSet<string>)[] ParsedTemplates { get; set; } = new (RoutePattern, HashSet<string>)[templates.Count];
     }
 
-    internal static InboundRouteEntry CreateEntry([DynamicallyAccessedMembers(Component)] Type pageType, string template)
+    internal static InboundRouteEntry CreateEntry([DynamicallyAccessedMembers(Component)] Type pageType, string template, bool includeStaticRoutes)
     {
-        var templates = GetTemplates(pageType);
+        var templates = GetTemplates(pageType, includeStaticRoutes);
         var result = ComputeTemplateGroupInfo(templates);
 
         RoutePattern? parsedTemplate = null;

src/Components/Components/test/Routing/RouteTableFactoryTests.cs

@@ -1107,7 +1107,7 @@ public RouteTable Build()
             {
                 var templatesByHandler = _routeTemplates
                     .GroupBy(rt => rt.Handler)
-                    .ToDictionary(group => group.Key, group => group.Select(g => g.Template).ToArray());
+                    .ToDictionary(group => group.Key, group => (IReadOnlyList<string>)group.Select(g => g.Template).ToArray());
                 return RouteTableFactory.Create(templatesByHandler, _serviceProvider);
             }
             catch (InvalidOperationException ex) when (ex.InnerException is InvalidOperationException)

src/Components/Endpoints/src/Builder/ComponentTypeMetadata.cs

@@ -20,9 +20,25 @@ public ComponentTypeMetadata([DynamicallyAccessedMembers(Component)] Type compon
         Type = componentType;
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="ComponentTypeMetadata"/>.
+    /// </summary>
+    /// <param name="componentType">The component type.</param>
+    /// <param name="isStaticPage">A flag indicating whether the page's route is declared as static.</param>
+    public ComponentTypeMetadata([DynamicallyAccessedMembers(Component)] Type componentType, bool isStaticPage)
+        : this(componentType)
+    {
+        IsStaticRoute = isStaticPage;
+    }
+
     /// <summary>
     /// Gets the component type.
     /// </summary>
     [DynamicallyAccessedMembers(Component)]
     public Type Type { get; }
+
+    /// <summary>
+    /// Gets a flag indicating whether the page's route is declared as static.
+    /// </summary>
+    public bool IsStaticRoute { get; }
 }

src/Components/Endpoints/src/Builder/RazorComponentEndpointFactory.cs

@@ -32,7 +32,7 @@ internal void AddEndpoints(
         // Name is only relevant for Link generation, which we don't support either.
         var builder = new RouteEndpointBuilder(
             null,
-            RoutePatternFactory.Parse(pageDefinition.Route),
+            RoutePatternFactory.Parse(pageDefinition.Route.Template),
             order: 0);
 
         // Require antiforgery by default, let the page override it.
@@ -47,7 +47,7 @@ internal void AddEndpoints(
         // We do not support link generation, so explicitly opt-out.
         builder.Metadata.Add(new SuppressLinkGenerationMetadata());
         builder.Metadata.Add(HttpMethodsMetadata);
-        builder.Metadata.Add(new ComponentTypeMetadata(pageDefinition.Type));
+        builder.Metadata.Add(new ComponentTypeMetadata(pageDefinition.Type, pageDefinition.Route.Static));
         builder.Metadata.Add(new RootComponentMetadata(rootComponent));
         builder.Metadata.Add(configuredRenderModesMetadata);
 

src/Components/Endpoints/src/Discovery/IRazorComponentApplication.cs

@@ -33,7 +33,7 @@ static ComponentApplicationBuilder GetBuilderForAssembly(ComponentApplicationBui
                     {
                         pages.Add(new PageComponentBuilder()
                         {
-                            RouteTemplates = routes.Select(r => r.Template).ToList(),
+                            RouteTemplates = routes.ToList(),
                             AssemblyName = name,
                             PageType = candidate
                         });

src/Components/Endpoints/src/Discovery/PageComponentBuilder.cs

@@ -14,7 +14,7 @@ namespace Microsoft.AspNetCore.Components.Discovery;
 [DebuggerDisplay($"{{{nameof(GetDebuggerDisplay)}(),nq}}")]
 internal class PageComponentBuilder : IEquatable<PageComponentBuilder?>
 {
-    private IReadOnlyList<string> _routeTemplates = Array.Empty<string>();
+    private IReadOnlyList<RouteAttribute> _routeTemplates = Array.Empty<RouteAttribute>();
 
     /// <summary>
     /// Gets or sets the assembly name where this component comes from.
@@ -24,7 +24,7 @@ internal class PageComponentBuilder : IEquatable<PageComponentBuilder?>
     /// <summary>
     /// Gets or sets the route templates for this page component.
     /// </summary>
-    public required IReadOnlyList<string> RouteTemplates
+    public required IReadOnlyList<RouteAttribute> RouteTemplates
     {
         get => _routeTemplates;
         set
@@ -61,7 +61,7 @@ public bool Equals(PageComponentBuilder? other)
     {
         return other is not null &&
                AssemblyName == other.AssemblyName &&
-               RouteTemplates.SequenceEqual(other.RouteTemplates!, StringComparer.OrdinalIgnoreCase) &&
+               RouteTemplates.SequenceEqual(other.RouteTemplates!, RouteAttributeComparer.Instance) &&
                EqualityComparer<Type>.Default.Equals(PageType, other.PageType);
     }
 
@@ -81,13 +81,33 @@ public override int GetHashCode()
         return hash.ToHashCode();
     }
 
-    internal PageComponentInfo Build(string route, object[] pageMetadata)
+    internal PageComponentInfo Build(RouteAttribute route, object[] pageMetadata)
     {
-        return new PageComponentInfo(route, PageType, route, pageMetadata);
+        return new PageComponentInfo(route.Template, PageType, route, pageMetadata);
     }
 
     private string GetDebuggerDisplay()
     {
-        return $"Type = {PageType.FullName}, RouteTemplates = {string.Join(", ", RouteTemplates ?? Enumerable.Empty<string>())}";
+        return $"Type = {PageType.FullName}, RouteTemplates = {string.Join(", ", RouteTemplates?.Select(r => r.Template) ?? Enumerable.Empty<string>())}";
+    }
+
+    private class RouteAttributeComparer : IEqualityComparer<RouteAttribute>
+    {
+        public static RouteAttributeComparer Instance { get; } = new();
+
+        public bool Equals(RouteAttribute? x, RouteAttribute? y)
+        {
+            if (x is null)
+            {
+                return y is null;
+            }
+
+            return y is not null
+                && string.Equals(x.Template, y.Template, StringComparison.OrdinalIgnoreCase)
+                && x.Static == y.Static;
+        }
+
+        public int GetHashCode([DisallowNull] RouteAttribute value)
+            => HashCode.Combine(value.Template, value.Static);
     }
 }

src/Components/Endpoints/src/Discovery/PageComponentInfo.cs

@@ -23,7 +23,7 @@ internal class PageComponentInfo
     internal PageComponentInfo(
         string displayName,
         [DynamicallyAccessedMembers(Component)] Type type,
-        string route,
+        RouteAttribute route,
         IReadOnlyList<object> metadata)
     {
         DisplayName = displayName;
@@ -46,7 +46,7 @@ internal PageComponentInfo(
     /// <summary>
     /// Gets the routes for the page.
     /// </summary>
-    public string Route { get; }
+    public RouteAttribute Route { get; }
 
     /// <summary>
     /// Gets the metadata for the page.

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

@@ -1 +1,3 @@
 #nullable enable
+Microsoft.AspNetCore.Components.Endpoints.ComponentTypeMetadata.ComponentTypeMetadata(System.Type! componentType, bool isStaticPage) -> void
+Microsoft.AspNetCore.Components.Endpoints.ComponentTypeMetadata.IsStaticRoute.get -> bool

src/Components/Endpoints/src/RazorComponentEndpointInvoker.cs

@@ -46,8 +46,14 @@ private async Task RenderComponentCore(HttpContext context)
 
         var endpoint = context.GetEndpoint() ?? throw new InvalidOperationException($"An endpoint must be set on the '{nameof(HttpContext)}'.");
 
+        var componentTypeMetadata = endpoint.Metadata.GetRequiredMetadata<ComponentTypeMetadata>();
         var rootComponent = endpoint.Metadata.GetRequiredMetadata<RootComponentMetadata>().Type;
-        var pageComponent = endpoint.Metadata.GetRequiredMetadata<ComponentTypeMetadata>().Type;
+        var pageComponent = componentTypeMetadata.Type;
+
+        if (componentTypeMetadata.IsStaticRoute)
+        {
+            _renderer.SuppressRootComponentRenderModes();
+        }
 
         Log.BeginRenderRootComponent(_logger, rootComponent.Name, pageComponent.Name);