Al migrar aplicaciones ASP.NET existentes a ASP.NET Core, nos encontramos con un concepto novedoso: los middleware.

Los middleware representan una adición fundamental en ASP.NET Core. Cada componente de middleware es un software integrado en el pipeline de la aplicación encargado de procesar las solicitudes y respuestas HTTP. Cada componente:

• Decide si pasa la solicitud al siguiente componente en el pipeline.
• Puede ejecutar lógica antes o después de que el siguiente componente procese la solicitud.

Desde una perspectiva inicial, la definición de middleware sugiere una analogía con extensiones de Programación Orientada a Aspectos (AOP) dentro del flujo de procesamiento de solicitudes HTTP.

Antes de profundizar en los middleware, es útil revisar cómo se manejaban las solicitudes en ASP.NET con HttpHandler y HttpModule.

I. HttpHandler y HttpModule en ASP.NET

En ASP.NET, los HttpHandler se encargaban de procesar solicitudes basadas en una extensión de archivo o nombre de archivo específico, implementando la interfaz IHttpHandler y requiriendo registro en Web.Config. Por ejemplo, un manejador para archivos .report.

Por otro lado, los HttpModule intervenía en cada solicitud, procesando eventos a nivel de aplicación, similar a un módulo de autorización. Implementaban la interfaz IHttpModule, se configuraban en Web.Config y permitían interrumpir la solicitud o modificar la respuesta. Cada solicitud pasaba por el procesamiento de los HttpModule.

ASP.NET Core introduce los middleware para unificar y simplificar estas capacidades de procesamiento de solicitudes.

II. Diferencias entre Middleware de ASP.NET Core y HttpHandler/HttpModule de ASP.NET

1. Simplicidad del Middleware

• Se eliminan conceptos como "módulos", "manejadores", el archivo Global.asax.cs, la configruación en Web.Config (excepto configuraciones de IIS) y el ciclo de vida de la aplicación explícito.
• Los middleware asumen los roles de HttpHandler y HttpModule.
• La configuración de middleware se realiza mediante código, no en Web.Config.
• Permiten ramificar el pipeline de solicitud, dirigiendo solicitudes a middleware específicos no solo por URL, sino también por cabeceras, parámetros de consulta, etc.

2. Similitud con HttpModule

• Procesan cada solicitud entrante.
• Pueden intervenir en el procesamiento de la solicitud y decidir si continuarla.
• Son capaces de generar respuestas HTTP personalizadas.

3. Orden de Procesamiento Diferente

• El orden de ejecución de los middleware está determinado por su adición al pipeline de solicitud, mientras que el orden de los módulos se basaba principalmente en eventos del ciclo de vida de la aplicación.
• El orden de las respuestas generadas por los middleware es inverso al orden de las solicitudes, a diferencia de los HttpModule donde el orden de solicitud y respuesta es el mismo.

III. Principios de Diseño del Middleware en ASP.NET Core

El pipeline de procesamiento de solicitudes en ASP.NET Core consta de una secuencia de delegados de solicitud (middleware) que se invocan uno tras otro. Cada delgeado puede ejecutar lógica antes y después de llamar al siguiente en la cadena. Es crucial manejar las excepciones temprano en el pipeline para capturar errores de etapas posteriores.

El orden en que se agregan los componentes de middleware en el método Configure de la clase Startup define el orden de invocación para las solicitudes y el orden inverso para las respuestas. Este orden es crítico para la seguridad, el rendimiento y la funcionalidad de la aplicación.

A continuación, se presenta un ejemplo de código:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage(); // Middleware para mostrar detalles de excepciones en desarrollo
        app.UseDatabaseErrorPage();      // Middleware para mostrar errores de base de datos en desarrollo
    }
    else
    {
        app.UseExceptionHandler("/Error"); // Middleware genérico para manejo de excepciones en producción
        app.UseHsts();                     // Middleware para HSTS (HTTP Strict Transport Security)
    }

    app.UseHttpsRedirection();         // Middleware para redirigir HTTP a HTTPS
    app.UseStaticFiles();              // Middleware para servir archivos estáticos
    // app.UseCookiePolicy();          // Middleware para políticas de cookies (ej. GDPR)

    app.UseRouting();                  // Middleware para enrutamiento de solicitudes
    // app.UseRequestLocalization();   // Middleware para localización de solicitudes
    // app.UseCors();                  // Middleware para manejo de CORS

    app.UseAuthentication();           // Middleware para autenticación
    app.UseAuthorization();            // Middleware para autorización

    // app.UseSession();               // Middleware para manejo de sesiones

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapRazorPages();    // Mapeo para Razor Pages
        endpoints.MapControllerRoute(  // Mapeo de ruta para controladores MVC
            name: "default",
            pattern: "{controller=Home}/{action=Index}/{id?}");
    });
}

En el código anterior, cada método de extensión app.Use*** expuesto en IApplicationBuilder representa un middleware integrado. Algunos ejemplos comunes incluyen:

1. Middleware de Manejo de Excepciones: UseDeveloperExceptionPage y UseDatabaseErrorPage en desarrollo; UseExceptionHandler y UseHsts en producción.
2. Middleware de Redirección HTTPS: UseHttpsRedirection.
3. Middleware de Archivos Estáticos: UseStaticFiles.
4. Middleware de Política de Cookies: UseCookiePolicy (cumplimiento de GDPR).
5. Middleware de Enrutamiento: UseRouting.
6. Middleware de Autenticación: UseAuthentication.
7. Middleware de Autorización: UseAuthorization.
8. Middleware de Sesión: UseSession (para mantener estado de sesión).
9. Middleware de Enrutamiento de Puntos Finales: UseEndpoints con MapRazorPages y MapControllerRoute.
10. Middleware para SPAs: UseSpaStaticFiles, usualmente el último en el pipeline para permitir que otros middleware manejen las solicitudes primero y que el SPA maneje las rutas no reconocidas por el servidor.

Existen muchos otros middleware integrados. Para una lista completa, consulte la documentación oficial de Microsoft.

IV. Creación de Middleware Personalizado

En ocasiones, es necesario crear middleware personalizados para replicar la funcionalidad de antiguos HttpModule o HttpHandler.

Consideremos la implementación de un HttpModule existente:

/// <summary>
/// Módulo personalizado de extensión HTTP.
/// </summary>
public class CustomerHttpModule : IHttpModule
{        
    public void Init(HttpApplication context)
    {
        context.BeginRequest += Context_BeginRequest;
    }

    private void Context_BeginRequest(object sender, EventArgs e)
    {            
        HttpApplication app = (HttpApplication)sender;
        // Lógica a ejecutar al inicio de la solicitud.            
    }

    public void Dispose()
    {
        // Liberar recursos.
    }
}

La migración a un middleware personalizado en ASP.NET Core se vería así:

/// <summary>
/// Middleware personalizado.
/// </summary>
public class CustomMiddleware
{
    private readonly RequestDelegate _nextDelegate; // Delegado para el siguiente middleware en el pipeline.

    /// <summary>
    /// Constructor que recibe el siguiente delegado en el pipeline.
    /// </summary>
    /// <param name="nextDelegate">El siguiente delegado en la cadena.</param>
    public CustomMiddleware(RequestDelegate nextDelegate)
    {
        _nextDelegate = nextDelegate;
    }

    /// <summary>
    /// Método principal de procesamiento de la solicitud.
    /// </summary>
    /// <param name="httpContext">El contexto de la solicitud HTTP.</param>
    public async Task InvokeAsync(HttpContext httpContext)
    {
        // Lógica a ejecutar antes de pasar al siguiente middleware.                
        await _nextDelegate(httpContext); // Pasar el control al siguiente middleware.
        // Lógica a ejecutar después de que el siguiente middleware haya terminado.
        // Limpieza si es necesario.
    }
}

Además, se puede añadir un método de extensión para facilitar la integración en el pipeline:

/// <summary>
/// Extensión para agregar el middleware personalizado al pipeline de IApplicationBuilder.
/// </summary>
public static class ApplicationBuilderExtensions
{
    public static IApplicationBuilder UseCustomMiddleware(this IApplicationBuilder builder)
    {
        // Usa el middleware genérico de ASP.NET Core, especificando nuestro tipo de middleware.
        return builder.UseMiddleware<custommiddleware>();
    }
}
</custommiddleware>

Finalmente, se integra este middleware personalizado en el método Configure de Startup:

// En el método Configure de Startup.cs
app.UseCustomMiddleware();

Esta exposición resume el origen y el uso de los middleware en ASP.NET Core.