[Blazor] Endpoint discovery and configuration (#47126)

* Adds support for discovering razor pages and registering them as endpoints.
* Makes EndpointDataSource generic to support multiple instances in the future.
* Removes reflection from discovery and pushes it to the default implementation.
* Adds the appropriate metadata to the endpoints.
* Renders the component using the ComponentResult.

Author: javiercn

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

@@ -0,0 +1,24 @@
+// 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.Builder;
+
+/// <summary>
+/// Metadata that represents the component associated with an endpoint.
+/// </summary>
+public class ComponentTypeMetadata
+{
+    /// <summary>
+    /// Initializes a new instance of <see cref="ComponentTypeMetadata"/>.
+    /// </summary>
+    /// <param name="componentType">The component type.</param>
+    public ComponentTypeMetadata(Type componentType)
+    {
+        Type = componentType;
+    }
+
+    /// <summary>
+    /// Gets the component type.
+    /// </summary>
+    public Type Type { get; }
+}

src/Components/Endpoints/src/Builder/RazorComponentEndpointConventionBuilder.cs

@@ -1,19 +1,36 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using Microsoft.AspNetCore.Components;
+
 namespace Microsoft.AspNetCore.Builder;
 
-internal class RazorComponentEndpointConventionBuilder : IEndpointConventionBuilder
+/// <summary>
+/// Builds conventions that will be used for customization of <see cref="EndpointBuilder"/> instances.
+/// </summary>
+
+// TODO: This will have APIs to add and remove entire assemblies from the list of considered endpoints
+// as well as adding/removing individual pages as endpoints.
+public class RazorComponentEndpointConventionBuilder : IEndpointConventionBuilder
 {
     private readonly object _lock;
+    private readonly ComponentApplicationBuilder _builder;
     private readonly List<Action<EndpointBuilder>> _conventions;
+    private readonly List<Action<EndpointBuilder>> _finallyConventions;
 
-    internal RazorComponentEndpointConventionBuilder(object @lock, List<Action<EndpointBuilder>> conventions)
+    internal RazorComponentEndpointConventionBuilder(
+        object @lock,
+        ComponentApplicationBuilder builder,
+        List<Action<EndpointBuilder>> conventions,
+        List<Action<EndpointBuilder>> finallyConventions)
     {
         _lock = @lock;
+        _builder = builder;
         _conventions = conventions;
+        _finallyConventions = finallyConventions;
     }
 
+    /// <inheritdoc/>
     public void Add(Action<EndpointBuilder> convention)
     {
         ArgumentNullException.ThrowIfNull(convention);
@@ -25,4 +42,15 @@ public void Add(Action<EndpointBuilder> convention)
             _conventions.Add(convention);
         }
     }
+
+    /// <inheritdoc/>
+    public void Finally(Action<EndpointBuilder> finallyConvention)
+    {
+        // The lock is shared with the data source. We want to lock here
+        // to avoid mutating this list while its read in the data source.
+        lock (_lock)
+        {
+            _finallyConventions.Add(finallyConvention);
+        }
+    }
 }

src/Components/Endpoints/src/Builder/RazorComponentEndpointDataSource.cs

@@ -2,35 +2,43 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Diagnostics;
-using System.Linq;
-using System.Reflection;
-using Microsoft.AspNetCore.Components;
-using Microsoft.AspNetCore.Components.Endpoints;
+using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Routing;
-using Microsoft.AspNetCore.Routing.Patterns;
 using Microsoft.Extensions.Primitives;
 
-namespace Microsoft.AspNetCore.Builder;
+namespace Microsoft.AspNetCore.Components.Endpoints;
 
-internal class RazorComponentEndpointDataSource : EndpointDataSource
+internal class RazorComponentEndpointDataSource<TRootComponent> : EndpointDataSource
 {
-    private readonly object _lock = new object();
+    private readonly object _lock = new();
     private readonly List<Action<EndpointBuilder>> _conventions = new();
+    private readonly List<Action<EndpointBuilder>> _finallyConventions = new();
 
     private List<Endpoint>? _endpoints;
     // TODO: Implement endpoint data source updates https://github.com/dotnet/aspnetcore/issues/47026
     private readonly CancellationTokenSource _cancellationTokenSource;
     private readonly IChangeToken _changeToken;
 
-    public RazorComponentEndpointDataSource()
+    public RazorComponentEndpointDataSource(
+        ComponentApplicationBuilder builder,
+        RazorComponentEndpointFactory factory)
     {
-        DefaultBuilder = new RazorComponentEndpointConventionBuilder(_lock, _conventions);
+        _builder = builder;
+        _factory = factory;
+        DefaultBuilder = new RazorComponentEndpointConventionBuilder(
+            _lock,
+            builder,
+            _conventions,
+            _finallyConventions);
 
         _cancellationTokenSource = new CancellationTokenSource();
         _changeToken = new CancellationChangeToken(_cancellationTokenSource.Token);
     }
 
+    private readonly ComponentApplicationBuilder _builder;
+    private readonly RazorComponentEndpointFactory _factory;
+
     internal RazorComponentEndpointConventionBuilder DefaultBuilder { get; }
 
     public override IReadOnlyList<Endpoint> Endpoints
@@ -67,26 +75,11 @@ private void Initialize()
 
     private void UpdateEndpoints()
     {
-        // TODO: https://github.com/dotnet/aspnetcore/issues/46980
-
-        var entryPoint = Assembly.GetEntryAssembly() ??
-            throw new InvalidOperationException("Can't find entry assembly.");
-
-        var pages = entryPoint.GetExportedTypes()
-            .Select(t => (type: t, route: t.GetCustomAttribute<RouteAttribute>()))
-            .Where(p => p.route != null);
-
         var endpoints = new List<Endpoint>();
-        foreach (var (type, route) in pages)
+        var context = _builder.Build();
+        foreach (var definitions in context.Pages)
         {
-            // TODO: Proper endpoint definition https://github.com/dotnet/aspnetcore/issues/46985
-            var endpoint = new RouteEndpoint(
-                RazorComponentEndpoint.CreateRouteDelegate(type),
-                RoutePatternFactory.Parse(route!.Template),
-                order: 0,
-                new EndpointMetadataCollection(type.GetCustomAttributes(inherit: true)),
-                route.Template);
-            endpoints.Add(endpoint);
+            _factory.AddEndpoints(endpoints, definitions, _conventions, _finallyConventions);
         }
 
         _endpoints = endpoints;

src/Components/Endpoints/src/Builder/RazorComponentEndpointDataSourceFactory.cs

@@ -0,0 +1,23 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.AspNetCore.Components.Endpoints;
+
+namespace Microsoft.AspNetCore.Components.Infrastructure;
+
+internal class RazorComponentEndpointDataSourceFactory
+{
+    private readonly RazorComponentEndpointFactory _factory;
+
+    public RazorComponentEndpointDataSourceFactory(RazorComponentEndpointFactory factory)
+    {
+        _factory = factory;
+    }
+
+    public RazorComponentEndpointDataSource<TRootComponent> CreateDataSource<TRootComponent>()
+        where TRootComponent : IRazorComponentApplication<TRootComponent>
+    {
+        var builder = TRootComponent.GetBuilder();
+        return new RazorComponentEndpointDataSource<TRootComponent>(builder, _factory);
+    }
+}

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

@@ -0,0 +1,62 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
+using Microsoft.AspNetCore.Routing.Patterns;
+
+namespace Microsoft.AspNetCore.Components.Endpoints;
+
+internal class RazorComponentEndpointFactory
+{
+    private static readonly HttpMethodMetadata HttpGet = new(new[] { HttpMethods.Get });
+
+#pragma warning disable CA1822 // It's a singleton
+    internal void AddEndpoints(
+#pragma warning restore CA1822 // It's a singleton
+        List<Endpoint> endpoints,
+        PageDefinition pageDefinition,
+        IReadOnlyList<Action<EndpointBuilder>> conventions,
+        IReadOnlyList<Action<EndpointBuilder>> finallyConventions)
+    {
+        // We do not provide a way to establish the order or the name for the page routes.
+        // Order is not supported in our client router.
+        // Name is only relevant for Link generation, which we don't support either.
+        var builder = new RouteEndpointBuilder(
+            null,
+            RoutePatternFactory.Parse(pageDefinition.Route),
+            order: 0);
+
+        // All attributes defined for the type are included as metadata.
+        foreach (var attribute in pageDefinition.Metadata)
+        {
+            builder.Metadata.Add(attribute);
+        }
+
+        // We do not support link generation, so explicitly opt-out.
+        builder.Metadata.Add(new SuppressLinkGenerationMetadata());
+        builder.Metadata.Add(HttpGet);
+        builder.Metadata.Add(new ComponentTypeMetadata(pageDefinition.Type));
+
+        foreach (var convention in conventions)
+        {
+            convention(builder);
+        }
+
+        foreach (var finallyConvention in finallyConventions)
+        {
+            finallyConvention(builder);
+        }
+
+        // Always override the order, since our client router does not support it.
+        builder.Order = 0;
+
+        // The display name is for debug purposes by endpoint routing.
+        builder.DisplayName = $"{builder.RoutePattern.RawText} ({pageDefinition.DisplayName})";
+
+        builder.RequestDelegate = RazorComponentEndpoint.CreateRouteDelegate(pageDefinition.Type);
+
+        endpoints.Add(builder.Build());
+    }
+}

src/Components/Endpoints/src/Builder/RazorComponentsEndpointRouteBuilderExtensions.cs

@@ -2,7 +2,9 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.Linq;
+using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Endpoints;
+using Microsoft.AspNetCore.Components.Infrastructure;
 using Microsoft.AspNetCore.Routing;
 using Microsoft.Extensions.DependencyInjection;
 
@@ -18,24 +20,27 @@ public static class RazorComponentsEndpointRouteBuilderExtensions
     /// </summary>
     /// <param name="endpoints"></param>
     /// <returns></returns>
-    public static IEndpointConventionBuilder MapRazorComponents(this IEndpointRouteBuilder endpoints)
+    public static RazorComponentEndpointConventionBuilder MapRazorComponents<TRootComponent>(this IEndpointRouteBuilder endpoints)
+        where TRootComponent : IRazorComponentApplication<TRootComponent>
     {
         ArgumentNullException.ThrowIfNull(endpoints);
 
         EnsureRazorComponentServices(endpoints);
 
-        return GetOrCreateDataSource(endpoints).DefaultBuilder;
+        return GetOrCreateDataSource<TRootComponent>(endpoints).DefaultBuilder;
     }
 
-    private static RazorComponentEndpointDataSource GetOrCreateDataSource(IEndpointRouteBuilder endpoints)
+    private static RazorComponentEndpointDataSource<TRootComponent> GetOrCreateDataSource<TRootComponent>(IEndpointRouteBuilder endpoints)
+        where TRootComponent : IRazorComponentApplication<TRootComponent>
     {
-        var dataSource = endpoints.DataSources.OfType<RazorComponentEndpointDataSource>().FirstOrDefault();
+        var dataSource = endpoints.DataSources.OfType<RazorComponentEndpointDataSource<TRootComponent>>().FirstOrDefault();
         if (dataSource == null)
         {
             // Very likely this needs to become a factory and we might need to have multiple endpoint data
             // sources, once we figure out the exact scenarios for
             // https://github.com/dotnet/aspnetcore/issues/46992
-            dataSource = endpoints.ServiceProvider.GetRequiredService<RazorComponentEndpointDataSource>();
+            var factory = endpoints.ServiceProvider.GetRequiredService<RazorComponentEndpointDataSourceFactory>();
+            dataSource = factory.CreateDataSource<TRootComponent>();
             endpoints.DataSources.Add(dataSource);
         }
 

src/Components/Endpoints/src/DependencyInjection/RazorComponentsServiceCollectionExtensions.cs

@@ -1,7 +1,6 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
-using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Endpoints;
 using Microsoft.AspNetCore.Components.Infrastructure;
@@ -30,10 +29,9 @@ public static IRazorComponentsBuilder AddRazorComponents(this IServiceCollection
         // Results
         services.TryAddSingleton<RazorComponentResultExecutor>();
 
-        // Routing
-        // This can't be a singleton
-        // https://github.com/dotnet/aspnetcore/issues/46980
-        services.TryAddSingleton<RazorComponentEndpointDataSource>();
+        // Endpoints
+        services.TryAddSingleton<RazorComponentEndpointDataSourceFactory>();
+        services.TryAddSingleton<RazorComponentEndpointFactory>();
 
         // Common services required for components server side rendering
         services.TryAddSingleton<ServerComponentSerializer>(services => new ServerComponentSerializer(services.GetRequiredService<IDataProtectionProvider>()));

src/Components/Endpoints/src/Discovery/ComponentApplicationBuilder.cs

@@ -0,0 +1,34 @@
+// 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>
+/// Builder used to configure a <see cref="RazorComponentApplication"/> instance.
+/// </summary>
+public class ComponentApplicationBuilder
+{
+    private readonly HashSet<string> _assemblies = new();
+    private PageCollection? _pages;
+
+    // TODO: When we support proper discovery this will be public
+    // (and probably have a different shape).
+    internal void AddAssembly(string name)
+    {
+        _assemblies.Add(name);
+    }
+
+    /// <summary>
+    /// Builds the component application definition.
+    /// </summary>
+    /// <returns>The <see cref="RazorComponentApplication"/>.</returns>
+    public RazorComponentApplication Build()
+    {
+        return new RazorComponentApplication(_pages ?? PageCollection.Empty);
+    }
+
+    internal void RegisterPages(PageCollection pages)
+    {
+        _pages = pages;
+    }
+}