Какой жизненный цикл у middleware?

Жизненный цикл Middleware в ASP.NET Core

В ASP.NET Core middleware — это программные компоненты, которые объединяются в конвейер обработки HTTP-запросов. Жизненный цикл middleware тесно связан с жизненным циклом самого приложения и конвейера запросов. Давайте разберем его поэтапно.

1. Регистрация и конфигурация

Middleware регистрируется в методе Configure класса Startup (в старых версиях) или непосредственно в Program.cs (в современных шаблонах). Каждый middleware добавляется в конвейер с помощью методов Use, Run, Map и других.

public void Configure(IApplicationBuilder app)
{
    // Middleware 1: обработка исключений
    app.UseExceptionHandler();
    
    // Middleware 2: статические файлы
    app.UseStaticFiles();
    
    // Middleware 3: маршрутизация
    app.UseRouting();
    
    // Middleware 4: авторизация
    app.UseAuthorization();
    
    // Terminal middleware: конечная точка
    app.UseEndpoints(endpoints => endpoints.MapControllers());
}

Ключевой момент: Порядок регистрации критически важен, так как определяет последовательность выполнения в конвейере.

2. Строительство конвейера

При запуске приложения ASP.NET Core строит конвейер обработки запросов (request pipeline). Каждый middleware оборачивается в делегат RequestDelegate, формируя связанный список (цепочку ответственности). Этот процесс происходит один раз при старте приложения.

// Упрощенное представление построения конвейера
RequestDelegate pipeline = async context =>
{
    await middleware1(context, async () =>
    {
        await middleware2(context, async () =>
        {
            await terminalMiddleware(context);
        });
    });
};

3. Обработка HTTP-запроса

При поступлении HTTP-запроса начинается его прохождение через конвейер middleware:

• Входящий поток (Inbound): Запрос последовательно проходит через все зарегистрированные middleware в порядке их добавления.
• Обработка в middleware: Каждый middleware может:

    - Выполнить предобработку запроса (например, аутентификацию, логирование)
    - Решить передать запрос следующему middleware (`await next(context)`)
    - Прервать цепочку и сразу вернуть ответ (short-circuiting)

• Исходящий поток (Outbound): После выполнения конечного middleware (или прерывания) управление возвращается обратно через все middleware в обратном порядке для постобработки.

public class CustomMiddleware
{
    private readonly RequestDelegate _next;
    
    public CustomMiddleware(RequestDelegate next)
    {
        _next = next;
    }
    
    public async Task InvokeAsync(HttpContext context)
    {
        // Входящая обработка
        LogRequest(context);
        
        // Передача следующему middleware
        await _next(context);
        
        // Исходящая обработка
        LogResponse(context);
    }
}

4. Варианты завершения

Middleware может завершить обработку несколькими способами:

• Нормальное завершение: Все middleware вызывают next() и возвращают управление
• Короткое замыкание: Middleware возвращает ответ, не вызывая next() (например, app.UseStaticFiles() для статических файлов)
• Агрессивное завершение: Middleware вызывает context.Response.CompleteAsync() для немедленного завершения
• Исключение: Middleware может выбросить исключение, которое может быть обработано middleware обработки ошибок

5. Зависимости и время жизни

Middleware создается при построении конвейера и обычно существует в течение всего времени жизни приложения (Singleton). Однако, через внедрение зависимостей можно получать службы с разным временем жизни:

• Transient, Scoped и Singleton службы могут быть внедрены в конструктор middleware
• Для Scoped служб важно понимать, что область видимости создается на каждый запрос, а middleware — долгоживущий объект

public class ScopedMiddleware
{
    private readonly RequestDelegate _next;
    
    public ScopedMiddleware(RequestDelegate next)
    {
        _next = next;
    }
    
    public async Task InvokeAsync(HttpContext context, IScopedService scopedService)
    {
        // IScopedService создается заново для каждого запроса
        await scopedService.DoSomethingAsync();
        await _next(context);
    }
}

6. Особенности для разных типов middleware

• Встроенные middleware: (UseRouting, UseAuthentication, UseAuthorization) — имеют четко определенное место в конвейере
• Пользовательские middleware: Могут быть реализованы как классы, делегаты или фабричные методы
• Terminal middleware: Не вызывают следующий middleware (app.Run)
• Branching middleware: Создают ветвление конвейера (app.Map, app.MapWhen)

7. Управление жизненным циклом

Для сложных сценариев можно использовать IMiddlewareFactory и IMiddleware, которые позволяют контролировать создание и время жизни middleware:

public class FactoryActivatedMiddleware : IMiddleware
{
    public async Task InvokeAsync(HttpContext context, RequestDelegate next)
    {
        // Этот middleware создается фабрикой для каждого запроса
        await next(context);
    }
}

Ключевые выводы

1. Однократная инициализация: Middleware инициализируется при старте приложения
2. Неизменяемость конвейера: После построения конвейер нельзя изменить во время выполнения
3. Двунаправленный поток: Middleware обрабатывает запрос на входе и ответ на выходе
4. Порядок имеет значение: Неправильный порядок middleware — частая причина ошибок
5. Гибкость завершения: Middleware может продолжить или прервать цепочку обработки

Понимание жизненного цикла middleware критически важно для создания эффективных, безопасных и масштабируемых веб-приложений на ASP.NET Core, так как напрямую влияет на производительность, безопасность и корректность обработки запросов.