Eficiência com ASP.NET Core com Middleware

O conceito de Middleware no ASP.NET Core é um ponto extremamente forte. Ele permite configurar uma pipeline de requisição flexível, onde cada componente do middleware pode adicionar, modificar ou interromper a requisição. Isso ajuda a:

• Otimizar o fluxo de requisições e respostas, evitando processamentos desnecessários.
• Adicionar funcionalidades como autenticação, logging, manipulação de erros e muito mais.
• Ter um controle granular sobre como cada requisição é tratada, facilitando a criação de APIs mais performáticas e eficientes.

Por Que Isso É Importante?

Com Middleware, podemos construir APIs modulares e leves, que aproveitam ao máximo o potencial de escalabilidade do ASP.NET Core. Esses recursos tornam o desenvolvimento mais ágil e permitem uma manutenção mais simples, o que é essencial para projetos de longo prazo.
Aqui está um exemplo de dois Middlewares criados para trabalhar com os logs de requisições e outro para medir performance no tempo que a requisição concluirá:

1. A classe Program.cs ativa os Middlewares

using ExampleNetCore.Middlewares;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();

//Usando os middlewares
app.UseLoggingMiddleware();         // Aqui trabalharemos com os logs da requisição
app.UseExecutionTimeMiddleware();   // Aqui faremos a medição de tempo

app.UseAuthorization();

app.MapControllers();

app.Run();

2. Criamos uma classe de extensão de Middleware

using Microsoft.AspNetCore.Builder;

namespace ExampleNetCore.Middlewares
{
    public static class MiddlewareExtensions
    {
        public static IApplicationBuilder UseLoggingMiddleware(this IApplicationBuilder builder)
        {
            return builder.UseMiddleware<Log>();
        }

        public static IApplicationBuilder UseExecutionTimeMiddleware(this IApplicationBuilder builder)
        {
            return builder.UseMiddleware<Performance>();
        }
    }
}

3. Por fim criamos as classes de log e de performance

using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using System;

namespace ExampleNetCore.Middlewares
{
    public class Log
    {
        private readonly RequestDelegate _next;

        public Log(RequestDelegate next)
        {
            _next = next;
        }

        public async Task InvokeAsync(HttpContext context)
        {
            //Usando a lógica para persistir ou trabalhar de outra forma com os dados da requisição
            Console.WriteLine($"Método: {context.Request.Method}");
            Console.WriteLine($"Path: {context.Request.Path}");
            Console.WriteLine($"QueryString: {context.Request.QueryString}");

            await _next(context);

            Console.WriteLine($"Status Code: {context.Response.StatusCode}");
        }
    }
}

using System.Diagnostics;

namespace ExampleNetCore.Middlewares
{
    public class Performance
    {
        private readonly RequestDelegate _next;

        public Performance(RequestDelegate next)
        {
            _next = next;
        }

        public async Task InvokeAsync(HttpContext context)
        {
            //Medição do tempo de processamento da requisição
            var stopwatch = Stopwatch.StartNew();

            await _next(context);

            stopwatch.Stop();
            Console.WriteLine($"Tempo de execução: {stopwatch.ElapsedMilliseconds} ms");
        }
    }
}