ASP.NET Core - Métodos de extensão Map

 Hoje vou apresentar os métodos de extensão Map da ASP .NET Core.

Se você deseja inserir alguma lógica de middleware específica para alguma URL específica, pode fazer o mesmo usando o Método de Extensão de Map em qualquer tipo de Aplicativo ASP.NET Core.

Antes de usar o Método Map, vamos primeiro dar uma olhada na definição deste método que é mostrada  a seguir. Existem duas versões sobrecarregadas disponíveis para este método no ASP.NET Core.

1- Map(IApplicationBuilder, PathString, Action<IApplicationBuilder>)

2- Map(IApplicationBuilder, PathString, Boolean, Action<IApplicationBuilder>)

O método Map Ramifica o pipeline de solicitação com base nas correspondências do caminho de solicitação fornecido. Se o caminho da solicitação começar com o caminho fornecido, a ramificação será executada, caso contrário, o Middleware simplesmente será ignorado.

A seguir temos os parâmetros do método:

Vejamos a seguir um exemplo de uso deste método.

Usando o método Map

Vamos criar um novo projeto usando o template ASP .NET Core Empty no VS 2019 com o nome AspnMap.

A seguir vamos incluir o seguinte método na classe Startup. Esta é a lógica personalizada que queremos executar para uma URL específica.

private void MapMeuMiddleware(IApplicationBuilder app)
{
        app.Use(async (context, next) =>
        {
                await context.Response.WriteAsync("URL especifica do meu Middleware \n");
        });
 }

Agora, precisamos registrar o componente Middleware usando o método Map no método Configure da classe Startup sando o código abaixo:


   app.Map("/testemap", MapMeuMiddleware);
 

Neste código fornecemos o caminho como “/testemap” e também fornecemos o segundo parâmetro como o método MapMeuMiddleware que acabamos de criar.

Com isso, quando o request chegar, se ele contiver /testemap como parte da URL, apenas esse componente de Middleware será executado caso contrário ele será simplesmente ignorado.

Agora vamos completar o código da classe Startup para testar o projeto:

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

namespace AspnMap
{
    public class Startup
    {
        public void ConfigureServices(IServiceCollection services)
        {
        }

        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            app.Use(async (context, next) =>
            {
                await context.Response.WriteAsync("Usando o Middleware \n");
                await next();
            });

            app.Map("/testemap", MapMeuMiddleware);

            app.Run(async context =>
            {
                await context.Response.WriteAsync("Rodando o Componente Middleware\n");
            });
        }

        private void MapMeuMiddleware(IApplicationBuilder app)
        {
            app.Use(async (context, next) =>
            {
                await context.Response.WriteAsync("URL especifica do meu Middleware \n");
            });
        }
    }
}

Agora, vamos salvar e executar o aplicativo.

O resultado pode ser visto abaixo:

Como você pode ver, o Middleware que é configurado usando o método Map Extension não será executado.

Isso ocorre porque a URL de solicitação de entrada não inclui o caminho /testemap como parte da URL.

Vamos então modificar a URL para incluir /testemap e veremos a resposta a seguir:

Agora, o primeiro middleware é executado e, em seguida, o método Map faz com que o método com o meu Middleware seja executado, que é projetado especificamente para essa solicitação.

E estamos conversados.

"Quanto ao mais, irmãos, tudo o que é verdadeiro, tudo o que é honesto, tudo o que é justo, tudo o que é puro, tudo o que é amável, tudo o que é de boa fama, se há alguma virtude, e se há algum louvor, nisso pensai."
Filipenses 4:8

Referências:

José Carlos Macoratti