Middleware в ASP.NET Core

public void Configure(IApplicationBuilder app)
{
    app.UseExceptionHandler("/error");  // Первый
    app.UseHttpsRedirection();          // Второй
    app.UseStaticFiles();               // Третий
    app.UseRouting();                   // Четвертый
    app.UseAuthentication();            // Пятый
    app.UseAuthorization();             // Шестой
    app.UseEndpoints(endpoints => {     // Седьмой
        endpoints.MapControllers();
    });
}

app.Use(async (context, next) => {
    Console.WriteLine("Middleware 1: Входящий запрос");
    await next();  // Передаём управление следующему middleware
    Console.WriteLine("Middleware 1: Исходящий ответ");
});
 
app.Use(async (context, next) => {
    Console.WriteLine("Middleware 2: Входящий запрос");
    await next();
    Console.WriteLine("Middleware 2: Исходящий ответ");
});
 
app.Run(async context => {
    Console.WriteLine("Middleware 3: Обработка финального запроса");
    await context.Response.WriteAsync("Привет, мир!");
});

Middleware 1: Входящий запрос
Middleware 2: Входящий запрос
Middleware 3: Обработка финального запроса
Middleware 2: Исходящий ответ
Middleware 1: Исходящий ответ

public class CustomMiddleware
{
    private readonly RequestDelegate _next;
 
    public CustomMiddleware(RequestDelegate next)
    {
        _next = next;
    }
 
    public async Task InvokeAsync(HttpContext context)
    {
        // Код обработки входящего запроса
        
        await _next(context);  // Вызов следующего middleware
        
        // Код обработки исходящего ответа
    }
}

Middleware 1 (открытие) -> 
    Middleware 2 (открытие) -> 
        Middleware 3 (открытие и закрытие) -> 
    Middleware 2 (закрытие) -> 
Middleware 1 (закрытие)

public async Task InvokeAsync(HttpContext context)
{
    // Перед асинхронной операцией
    var startTime = DateTime.UtcNow;
    
    await _next(context);  // Асинхронный вызов следующего middleware
    
    // После завершения всей цепочки
    var elapsed = DateTime.UtcNow - startTime;
    Debug.WriteLine($"Запрос занял {elapsed.TotalMilliseconds} мс");
}

// Так делать не стоит!
public void Invoke(HttpContext context)
{
    var result = SomeLongRunningOperation().Result;  // Блокирующий вызов
    context.Response.WriteAsync(result);
}

public async Task InvokeAsync(HttpContext context)
{
    if (!context.Request.Headers.ContainsKey("API-Key"))
    {
        context.Response.StatusCode = 401;
        await context.Response.WriteAsync("Отсутствует ключ API");
        return;  // Конвейер завершен, следующие middleware не будут вызваны
    }
    
    // Если всё в порядке, продолжаем конвейер
    await _next(context);
}

app.UseExceptionHandler("/error");

if (env.IsDevelopment())
{
    app.UseDeveloperExceptionPage();
}
else
{
    app.UseExceptionHandler("/error");
}

app.UseRouting();
app.UseEndpoints(endpoints =>
{
    endpoints.MapControllers();
    endpoints.MapRazorPages();
    endpoints.MapHub<ChatHub>("/chatHub");
});

app.UseAuthentication();
app.UseAuthorization();

app.UseStaticFiles();

app.UseStaticFiles(new StaticFileOptions
{
    FileProvider = new PhysicalFileProvider(Path.Combine(env.ContentRootPath, "MyStaticFiles")),
    RequestPath = "/static"
});

app.UseCors(policy =>
{
    policy.WithOrigins("https://example.com")
          .AllowAnyMethod()
          .AllowAnyHeader();
});

app.UseResponseCompression();

services.AddResponseCompression(options =>
{
    options.Providers.Add<BrotliCompressionProvider>();
    options.Providers.Add<GzipCompressionProvider>();
    options.MimeTypes = ResponseCompressionDefaults.MimeTypes.Concat(
        new[] { "application/json" });
});

app.UseSession();

services.AddDistributedMemoryCache(); // Для простых сценариев
// ИЛИ
services.AddStackExchangeRedisCache(options => 
{
    options.Configuration = "localhost:6379";
}); // Для production-среды
 
services.AddSession(options =>
{
    options.IdleTimeout = TimeSpan.FromMinutes(30);
    options.Cookie.HttpOnly = true;
    options.Cookie.IsEssential = true;
});

app.UseHttpsRedirection();

var corsSettings = Configuration.GetSection("Cors");
services.AddCors(options =>
{
    options.AddDefaultPolicy(policy =>
    {
        policy.WithOrigins(corsSettings.GetSection("AllowedOrigins").Get<string[]>())
              .WithMethods(corsSettings.GetSection("AllowedMethods").Get<string[]>())
              .AllowCredentials();
    });
});

app.Use(async (context, next) =>
{
    _logger.LogInformation("Перед выполнением запроса {Path}", context.Request.Path);
    
    try 
    {
        await next();
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Произошла ошибка во время обработки запроса {Path}", context.Request.Path);
        throw;
    }
    
    _logger.LogInformation("После выполнения запроса {Path}, код ответа {StatusCode}", 
        context.Request.Path, context.Response.StatusCode);
});

if (env.IsDevelopment())
{
    app.UseDeveloperExceptionPage();
    // Или более детальные диагностические страницы
    app.UseDatabaseErrorPage(); // для EF Core ошибок
}

app.Use(async (context, next) =>
{
    var sw = Stopwatch.StartNew();
    await next();
    sw.Stop();
    
    if (sw.ElapsedMilliseconds > 500) // Порог для предупреждения
    {
        _logger.LogWarning("Запрос {Path} выполнялся слишком долго: {Elapsed} мс", 
            context.Request.Path, sw.ElapsedMilliseconds);
    }
});

app.UseResponseCaching();

app.Use(async (context, next) =>
{
    // Настройка кэширования для определённых путей
    if (context.Request.Path.StartsWithSegments("/api/products"))
    {
        context.Response.GetTypedHeaders().CacheControl = 
            new Microsoft.Net.Http.Headers.CacheControlHeaderValue()
            {
                Public = true,
                MaxAge = TimeSpan.FromSeconds(60)
            };
    }
    
    await next();
});

app.Use(async (context, next) =>
{
    // Код обработки запроса
    Console.WriteLine($"Запрос: {context.Request.Path}");
    
    await next(); // Вызов следующего middleware
    
    // Код обработки ответа
    Console.WriteLine($"Ответ: {context.Response.StatusCode}");
});

// Пример с терминированием конвейера
app.Run(async context =>
{
    await context.Response.WriteAsync("Здесь конец пути!");
});
 
// Пример с созданием ответвления конвейера
app.Map("/admin", adminApp =>
{
    adminApp.Use(async (context, next) =>
    {
        // Проверка на админа
        if (!context.User.IsInRole("Admin"))
        {
            context.Response.StatusCode = 403;
            await context.Response.WriteAsync("Доступ запрещён");
            return;
        }
        
        await next();
    });
    
    // Специфичные для админа middleware...
});

public class RequestLoggingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<RequestLoggingMiddleware> _logger;
    
    public RequestLoggingMiddleware(RequestDelegate next, ILogger<RequestLoggingMiddleware> logger)
    {
        _next = next;
        _logger = logger;
    }
    
    public async Task InvokeAsync(HttpContext context)
    {
        _logger.LogInformation("Входящий запрос: {Method} {Path}", 
            context.Request.Method, context.Request.Path);
            
        var stopwatch = Stopwatch.StartNew();
        
        try
        {
            await _next(context);
        }
        finally
        {
            stopwatch.Stop();
            _logger.LogInformation("Запрос {Method} {Path} обработан за {ElapsedMs}мс",
                context.Request.Method, context.Request.Path, stopwatch.ElapsedMilliseconds);
        }
    }
}

app.UseMiddleware<RequestLoggingMiddleware>();

public static class RequestLoggingMiddlewareExtensions
{
    public static IApplicationBuilder UseRequestLogging(this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<RequestLoggingMiddleware>();
    }
}

app.UseRequestLogging();

public class MyMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IConfiguration _configuration; // ← Инъекция зависимости
    
    public MyMiddleware(RequestDelegate next, IConfiguration configuration)
    {
        _next = next;
        _configuration = configuration;
    }
    
    // ...
}

public class DatabaseCheckMiddleware
{
    private readonly RequestDelegate _next;
    
    public DatabaseCheckMiddleware(RequestDelegate next)
    {
        _next = next;
    }
    
    public async Task InvokeAsync(
        HttpContext context, 
        ApplicationDbContext dbContext) // ← Scoped-сервис
    {
        if (!await dbContext.Database.CanConnectAsync())
        {
            context.Response.StatusCode = 503;
            await context.Response.WriteAsync("База данных недоступна");
            return;
        }
        
        await _next(context);
    }
}

public class ApiKeyMiddleware
{
    private readonly RequestDelegate _next;
    private readonly string _apiKeyHeaderName;
    private readonly ICollection<string> _validApiKeys;
    
    public ApiKeyMiddleware(
        RequestDelegate next, 
        string apiKeyHeaderName,
        ICollection<string> validApiKeys)
    {
        _next = next;
        _apiKeyHeaderName = apiKeyHeaderName;
        _validApiKeys = validApiKeys;
    }
    
    public async Task InvokeAsync(HttpContext context)
    {
        if (!context.Request.Headers.TryGetValue(_apiKeyHeaderName, out var extractedApiKey))
        {
            context.Response.StatusCode = 401;
            await context.Response.WriteAsync("API ключ отсутствует");
            return;
        }
        
        if (!_validApiKeys.Contains(extractedApiKey))
        {
            context.Response.StatusCode = 401;
            await context.Response.WriteAsync("Некорректный API ключ");
            return;
        }
        
        await _next(context);
    }
}

public static class ApiKeyMiddlewareExtensions
{
    public static IApplicationBuilder UseApiKey(
        this IApplicationBuilder builder,
        string headerName = "X-API-Key",
        params string[] validKeys)
    {
        return builder.UseMiddleware<ApiKeyMiddleware>(headerName, validKeys);
    }
}

app.UseApiKey("X-API-Key", "key1", "key2", "key3");

public async Task InvokeAsync(HttpContext context)
{
    // Обработка запроса
    Console.WriteLine("Запрос обработан");
    
    // Отсутствует await _next(context);
    // Конвейер будет прерван здесь!
}

public async Task InvokeAsync(HttpContext context)
{
    await _next(context); // Первый вызов
    
    if (context.Response.StatusCode == 404)
    {
        await _next(context); // Второй вызов — ошибка!
    }
}

// Плохой подход
public async Task InvokeAsync(HttpContext context)
{
    var result = SomeBlockingOperation().Result; // Блокирует поток
    context.Items["Result"] = result;
    await _next(context);
}
 
// Хороший подход
public async Task InvokeAsync(HttpContext context)
{
    var result = await SomeAsyncOperation(); // Освобождает поток
    context.Items["Result"] = result;
    await _next(context);
}

// Неправильно
public class BadMiddleware
{
    private readonly RequestDelegate _next;
    private readonly MyDbContext _dbContext; // Scoped-сервис в конструкторе!
    
    public BadMiddleware(RequestDelegate next, MyDbContext dbContext)
    {
        _next = next;
        _dbContext = dbContext;
    }
    
    // ...
}

[Fact]
public async Task ApiKeyMiddleware_RejectsRequestWithoutApiKey()
{
    // Arrange
    var builder = new WebHostBuilder()
        .ConfigureServices(services => { /* Настройка сервисов */ })
        .Configure(app => 
        {
            app.UseApiKey("X-API-Key", "valid-key");
            app.Run(async context => 
            {
                await context.Response.WriteAsync("Request reached endpoint");
            });
        });
    
    var server = new TestServer(builder);
    var client = server.CreateClient();
    
    // Act
    var response = await client.GetAsync("/");
    
    // Assert
    Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
    var responseContent = await response.Content.ReadAsStringAsync();
    Assert.Contains("API ключ отсутствует", responseContent);
}

[Fact]
public async Task LoggingMiddleware_LogsRequestPath()
{
    // Arrange
    var logger = new Mock<ILogger<RequestLoggingMiddleware>>();
    var context = new DefaultHttpContext();
    context.Request.Path = "/test-path";
    
    var middleware = new RequestLoggingMiddleware(
        next: (innerContext) => Task.CompletedTask,
        logger: logger.Object
    );
    
    // Act
    await middleware.InvokeAsync(context);
    
    // Assert
    logger.Verify(
        x => x.Log(
            It.IsAny<LogLevel>(),
            It.IsAny<EventId>(),
            It.Is<It.IsAnyType>((v, t) => v.ToString().Contains("/test-path")),
            It.IsAny<Exception>(),
            It.IsAny<Func<It.IsAnyType, Exception, string>>()),
        Times.AtLeastOnce);
}

public class CircuitBreakerMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<CircuitBreakerMiddleware> _logger;
    private readonly CircuitBreakerOptions _options;
    
    private int _failureCount;
    private DateTime _lastFailureTime = DateTime.MinValue;
    private readonly object _circuitLock = new object();
    private CircuitState _state = CircuitState.Closed;
    
    public CircuitBreakerMiddleware(RequestDelegate next, 
                                   ILogger<CircuitBreakerMiddleware> logger,
                                   CircuitBreakerOptions options)
    {
        _next = next;
        _logger = logger;
        _options = options;
    }
    
    public async Task InvokeAsync(HttpContext context)
    {
        if (ShouldBlockRequest())
        {
            context.Response.StatusCode = StatusCodes.Status503ServiceUnavailable;
            await context.Response.WriteAsync("Сервис временно недоступен. Попробуйте позже.");
            return;
        }
        
        try
        {
            await _next(context);
            
            // Успешный ответ - сбрасываем счётчик ошибок
            if (_state == CircuitState.HalfOpen)
            {
                Reset();
            }
        }
        catch (Exception ex)
        {
            RecordFailure(ex);
            throw;
        }
    }
    
    private bool ShouldBlockRequest()
    {
        lock (_circuitLock)
        {
            if (_state == CircuitState.Open)
            {
                // Проверяем, не пора ли попробовать восстановиться
                if (DateTime.UtcNow - _lastFailureTime > _options.RecoveryTimeoutPeriod)
                {
                    _state = CircuitState.HalfOpen;
                    _logger.LogWarning("Предохранитель переходит в полуоткрытое состояние");
                    return false;
                }
                return true;
            }
            
            if (_state == CircuitState.HalfOpen)
            {
                // В полуоткрытом состоянии пропускаем только один запрос
                return false;
            }
            
            return false; // Closed - пропускаем запросы
        }
    }
    
    private void RecordFailure(Exception ex)
    {
        lock (_circuitLock)
        {
            _lastFailureTime = DateTime.UtcNow;
            _failureCount++;
            
            if ((_state == CircuitState.Closed && _failureCount >= _options.ThresholdFailures) ||
                _state == CircuitState.HalfOpen)
            {
                _state = CircuitState.Open;
                _logger.LogWarning("Предохранитель разомкнут после {FailCount} ошибок", _failureCount);
            }
        }
    }
    
    private void Reset()
    {
        lock (_circuitLock)
        {
            _state = CircuitState.Closed;
            _failureCount = 0;
            _logger.LogInformation("Предохранитель вернулся в замкнутое состояние");
        }
    }
    
    public enum CircuitState
    {
        Closed,     // Нормальная работа
        Open,       // Блокировка запросов
        HalfOpen    // Тестовое состояние
    }
}
 
public class CircuitBreakerOptions
{
    public int ThresholdFailures { get; set; } = 5;
    public TimeSpan RecoveryTimeoutPeriod { get; set; } = TimeSpan.FromSeconds(30);
}

public class FeatureToggleMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IFeatureToggleService _featureService;
    
    public FeatureToggleMiddleware(RequestDelegate next, IFeatureToggleService featureService)
    {
        _next = next;
        _featureService = featureService;
    }
    
    public async Task InvokeAsync(HttpContext context)
    {
        // Добавляем информацию о доступности функций в контекст
        context.Items["Features"] = await _featureService.GetEnabledFeaturesAsync(context.User);
        
        // Проверяем, существует ли функциональная ветка для текущего пути
        if (context.Request.Path.StartsWithSegments("/api/v2") && 
            !_featureService.IsFeatureEnabled("API_V2", context.User))
        {
            context.Response.StatusCode = StatusCodes.Status404NotFound;
            return;
        }
        
        await _next(context);
    }
}

public class HealthCheckMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IEnumerable<IHealthCheck> _healthChecks;
    
    public HealthCheckMiddleware(RequestDelegate next, 
                               IEnumerable<IHealthCheck> healthChecks)
    {
        _next = next;
        _healthChecks = healthChecks;
    }
    
    public async Task InvokeAsync(HttpContext context)
    {
        if (context.Request.Path.Equals("/health"))
        {
            var results = new Dictionary<string, object>();
            bool isHealthy = true;
            
            foreach (var check in _healthChecks)
            {
                try
                {
                    var status = await check.CheckHealthAsync();
                    results[check.Name] = new { Status = status.Status.ToString(), status.Message };
                    
                    if (status.Status != HealthStatus.Healthy)
                    {
                        isHealthy = false;
                    }
                }
                catch (Exception ex)
                {
                    results[check.Name] = new { Status = "Error", Message = ex.Message };
                    isHealthy = false;
                }
            }
            
            context.Response.ContentType = "application/json";
            context.Response.StatusCode = isHealthy ? 200 : 503;
            
            await context.Response.WriteAsJsonAsync(new
            {
                Status = isHealthy ? "Healthy" : "Unhealthy",
                Timestamp = DateTime.UtcNow,
                Results = results
            });
            
            return;
        }
        
        await _next(context);
    }
}

public class AtomicOperationMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IDistributedLock _lockProvider;
    
    public AtomicOperationMiddleware(RequestDelegate next, IDistributedLock lockProvider)
    {
        _next = next;
        _lockProvider = lockProvider;
    }
    
    public async Task InvokeAsync(HttpContext context)
    {
        // Только для определённых операций
        if (context.Request.Method == "POST" || context.Request.Method == "PUT")
        {
            var resourceId = context.Request.Path.Value.Split('/').LastOrDefault();
            
            if (!string.IsNullOrEmpty(resourceId))
            {
                var lockName = $"resource-lock-{resourceId}";
                
                try
                {
                    await _lockProvider.AcquireLockAsync(lockName, TimeSpan.FromSeconds(30));
                    await _next(context);
                }
                finally
                {
                    await _lockProvider.ReleaseLockAsync(lockName);
                }
                
                return;
            }
        }
        
        await _next(context);
    }
}

public class RateLimitingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IMemoryCache _cache;
    private readonly int _limit;
    private readonly TimeSpan _period;
    
    public RateLimitingMiddleware(
        RequestDelegate next,
        IMemoryCache cache,
        int limit = 100,
        int periodInSeconds = 60)
    {
        _next = next;
        _cache = cache;
        _limit = limit;
        _period = TimeSpan.FromSeconds(periodInSeconds);
    }
    
    public async Task InvokeAsync(HttpContext context)
    {
        // Определяем уникальный идентификатор клиента (IP адрес, API ключ и т.д.)
        var clientId = context.Connection.RemoteIpAddress?.ToString() ?? "unknown";
        var cacheKey = $"rate_limit_{clientId}";
        
        // Получаем текущий счётчик запросов или создаём новый
        var counter = _cache.GetOrCreate<RateLimitCounter>(cacheKey, entry =>
        {
            entry.AbsoluteExpiration = DateTimeOffset.UtcNow.Add(_period);
            return new RateLimitCounter { Count = 0 };
        });
        
        // Увеличиваем счётчик и проверяем лимит
        if (Interlocked.Increment(ref counter.Count) > _limit)
        {
            context.Response.StatusCode = StatusCodes.Status429TooManyRequests;
            context.Response.Headers.Add("Retry-After", _period.TotalSeconds.ToString());
            await context.Response.WriteAsync("Слишком много запросов. Пожалуйста, попробуйте позже.");
            return;
        }
        
        // Добавляем заголовки с информацией о лимите
        context.Response.Headers.Add("X-Rate-Limit-Limit", _limit.ToString());
        context.Response.Headers.Add("X-Rate-Limit-Remaining", (_limit - counter.Count).ToString());
        
        await _next(context);
    }
    
    private class RateLimitCounter
    {
        public int Count;
    }
}

public class GlobalExceptionMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<GlobalExceptionMiddleware> _logger;
    
    public GlobalExceptionMiddleware(RequestDelegate next, ILogger<GlobalExceptionMiddleware> logger)
    {
        _next = next;
        _logger = logger;
    }
    
    public async Task InvokeAsync(HttpContext context)
    {
        try
        {
            await _next(context);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Необработанное исключение");
            
            context.Response.StatusCode = StatusCodes.Status500InternalServerError;
            context.Response.ContentType = "application/json";
            
            var response = new
            {
                Error = "Произошла ошибка при обработке запроса",
                TraceId = Activity.Current?.Id ?? context.TraceIdentifier
            };
            
            await context.Response.WriteAsJsonAsync(response);
        }
    }
}

app.UseExceptionHandler("/error");      // Сначала обрабатываем исключения
app.UseHttpsRedirection();              // Перенаправление на HTPS
app.UseStaticFiles();                   // Обслуживание статического контента
app.UseRouting();                       // Определение маршрутов
app.UseCors();                          // Настройка CORS
app.UseAuthentication();                // Аутентификация пользователя
app.UseAuthorization();                 // Проверка прав доступа
// Кастомные middleware
app.UseEndpoints(endpoints => {         // Сопоставление с конечными точками
    endpoints.MapControllers();
});