Habilitar o suporte Blazor Server do ASP.NET Core com o Yarp na migração incremental

Ao adicionar o Yarp a um aplicativoBlazor Server, ambos tentam agir como rotas de fallback para o roteamento de solicitação do aplicativo. O Blazor ou o Yarp manipula o roteamento arbitrariamente, o que significa que cenários como a vinculação profunda no Blazor podem falhar. Isso será corrigido na versão 8 do .NET ainda este ano. Para migração para ASP.NET Core 6.0 e 7.0, mapeie os pontos de extremidade de Blazorpara obter o roteamento de solicitação correto seguindo as diretrizes neste artigo.

Adicione a seguinte classe de extensões do construtor de rotas ao projeto.

BlazorEndpointRouteBuilderExtensions.cs:

using System;
using System.Collections.Generic;
using System.Reflection;
using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Routing;

public static class BlazorEndpointRouteBuilderExtensions {
    public static IEndpointConventionBuilder MapBlazorPages(
        this IEndpointRouteBuilder endpoints, string page)
    {
        var assembly = Assembly.GetEntryAssembly();

        if (assembly is null)
        {
            throw new InvalidOperationException("No entry assembly available.");
        }

        return endpoints.MapBlazorPages(page, assembly);
    }

    public static IEndpointConventionBuilder MapBlazorPages(
        this IEndpointRouteBuilder endpoints, string page, 
        params Assembly[] assemblies)
    {
        ArgumentNullException.ThrowIfNull(assemblies);

        var builder = new BlazorEndpointConventionBuilder();

        foreach (var route in GetRoutes(assemblies))
        {
            var conventionBuilder = endpoints.MapFallbackToPage(route, page);

            conventionBuilder.Add(b =>
            {
                b.DisplayName = $"Blazor {route}";
                ((RouteEndpointBuilder)b).Order = -1;
            });

            builder.Add(conventionBuilder);
        }

        return builder;
    }

    private static IEnumerable<string> GetRoutes(Assembly[] assemblies)
    {
        foreach (var assembly in assemblies)
        {
            foreach (var type in assembly.GetTypes())
            {
                if (typeof(IComponent).IsAssignableFrom(type))
                {
                    foreach (var attribute in 
                        type.GetCustomAttributes(typeof(RouteAttribute)))
                    {
                        if (attribute is RouteAttribute { Template: { } route })
                        {
                            yield return route;
                        }
                    }
                }
            }
        }
    }

    private sealed class BlazorEndpointConventionBuilder : IEndpointConventionBuilder {
        private readonly List<IEndpointConventionBuilder> builders = new();

        public void Add(IEndpointConventionBuilder builder)
        {
            builders.Add(builder);
        }

        void IEndpointConventionBuilder.Add(Action<EndpointBuilder> convention)
        {
            foreach (var builder in builders)
            {
                builder.Add(convention);
            }
        }

#if NET7_0_OR_GREATER
        void IEndpointConventionBuilder.Finally(
            Action<EndpointBuilder> finalConvention)
        {
            foreach (var builder in builders)
            {
                builder.Finally(finalConvention);
            }
        }
#endif
    }
}

No código anterior:

• EndpointBuilder.DisplayName usa como padrão Fallback {route}. A linha que o altera para Blazor {route} (b.DisplayName = $"Blazor {route}";) identifica a rota Blazor como registrada explicitamente.
• Para a linha que define a ordem de rota (((RouteEndpointBuilder)b).Order = -1;), {page} tem uma ordem de rota de 0 por padrão. Definir a ordem de rota Blazor para -1 garante que a ordem seja alterada para dar precedência à rota Blazor.

Atualize o registro do aplicativo para uso de Blazor no Program.cs:

- app.MapFallbackToPage("/_Host");
+ app.MapBlazorPages("/_Host");

Neste ponto, o aplicativo deve rotear solicitações corretamente para o Blazor e o Yarp, incluindo vinculação profunda a páginas.