Кастомные Middleware на C# в ASP.NET Core

app.Use(async (context, next) =>
{
    // Код, выполняемый до вызова следующего middleware
    await next();
    // Код, выполняемый после возврата из следующего middleware
});

public async Task InvokeAsync(HttpContext context)
{
    string path = context.Request.Path;
    // Доступ к строке запроса
    var queryValues = context.Request.Query;
    
    // Манипуляции с ответом
    context.Response.Headers.Add("X-Custom-Header", "CustomValue"); 
    context.Response.ContentType = "application/json";
    
    await next(context);
}

public void Configure(IApplicationBuilder app)
{
    app.UseExceptionHandler("/Error");
    app.UseStaticFiles();
    app.UseRouting();
    app.UseAuthentication();
    app.UseAuthorization();
    app.UseEndpoints();
}

app.UseMiddlewareFactory<MyRequestScopedMiddleware>();

// Ветвление по пути запроса
app.Map("/api", apiApp => {
    apiApp.UseMiddleware<ApiAuthMiddleware>();
    apiApp.UseMiddleware<JsonFormatterMiddleware>();
});
 
// Условное ветвление
app.MapWhen(
    context => context.Request.Headers.ContainsKey("X-Special-Header"),
    specialApp => {
        specialApp.UseMiddleware<SpecialHeaderMiddleware>();
    }
);

app.UseWhen(
    context => context.Request.Path.StartsWithSegments("/secured"),
    securedApp => {
        securedApp.UseMiddleware<AdditionalSecurityMiddleware>();
    }
);

app.Use(async (context, next) =>
{
    // ВХОДЯЩАЯ ФАЗА
    var timer = Stopwatch.StartNew();
    
    // Передача управления следующему middleware
    await next();
    
    // ИСХОДЯЩАЯ ФАЗА
    timer.Stop();
    var responseTime = timer.ElapsedMilliseconds;
    context.Response.Headers.Add("X-Response-Time", responseTime.ToString());
});

public static class MiddlewareFactoryExtensions
{
    public static IApplicationBuilder UseConditionalMiddleware(
        this IApplicationBuilder builder, 
        Func<HttpContext, bool> predicate,
        Func<RequestDelegate, RequestDelegate> middleware)
    {
        return builder.Use(next => 
        {
            var branch = middleware(next);
            
            return context => 
            {
                if (predicate(context))
                    return branch(context);
                    
                return next(context);
            };
        });
    }
}

// Прокси для ленивой загрузки middleware
public class LazyLoadedMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IServiceProvider _services;
    private volatile RequestDelegate _lazyMiddleware;
    
    public LazyLoadedMiddleware(RequestDelegate next, IServiceProvider services)
    {
        _next = next;
        _services = services;
    }
    
    public async Task InvokeAsync(HttpContext context)
    {
        // Ленивая инициализация при первом запросе
        if (_lazyMiddleware == null)
        {
            var factory = _services.GetRequiredService<IMiddlewareFactory>();
            var middleware = factory.Create<ExpensiveMiddleware>();
            
            var builder = new ApplicationBuilder(_services);
            builder.Use(next => middleware.InvokeAsync);
            builder.Run(_next);
            
            _lazyMiddleware = builder.Build();
        }
        
        await _lazyMiddleware(context);
    }
}

// Первый middleware сохраняет данные
public async Task InvokeAsync(HttpContext context)
{
    context.Items["StartTime"] = DateTime.UtcNow;
    await _next(context);
}
 
// Второй middleware использует эти данные
public async Task InvokeAsync(HttpContext context)
{
    if (context.Items.TryGetValue("StartTime", out var startTimeObj))
    {
        var startTime = (DateTime)startTimeObj;
        var processingTime = DateTime.UtcNow - startTime;
        // Использование данных...
    }
    
    await _next(context);
}

// Определение интерфейса
public interface ITrackingFeature
{
    string TrackingId { get; set; }
}
 
// Реализация
public class TrackingFeature : ITrackingFeature
{
    public string TrackingId { get; set; }
}
 
// Использование в middleware
public async Task InvokeAsync(HttpContext context)
{
    var trackingFeature = new TrackingFeature
    {
        TrackingId = Guid.NewGuid().ToString()
    };
    
    context.Features.Set<ITrackingFeature>(trackingFeature);
    await _next(context);
}

   // Плохо: создает новый массив при каждом запросе
   private readonly byte[] _newLineBytes = new byte[] { 13, 10 };
   
   // Хорошо: использует статический массив
   private static readonly byte[] _newLineBytes = new byte[] { 13, 10 };

   private readonly Regex _pathRegex = new Regex(@"^/api/v\d+/", RegexOptions.Compiled);

   // Плохо: блокирует поток
   public Task InvokeAsync(HttpContext context)
   {
       Thread.Sleep(100); // Имитация работы
       return _next(context);
   }
   
   // Хорошо: асинхронная операция
   public async Task InvokeAsync(HttpContext context)
   {
       await Task.Delay(100); // Имитация работы
       await _next(context);
   }

   // Кэш результатов предыдущих запросов
   private static readonly ConcurrentDictionary<string, object> _cache 
       = new ConcurrentDictionary<string, object>();
   
   public async Task InvokeAsync(HttpContext context)
   {
       var key = context.Request.Path;
       if (!_cache.TryGetValue(key, out var result))
       {
           result = await ComputeExpensiveResult(context);
           _cache.TryAdd(key, result);
       }
       
       await WriteResultToResponse(context.Response, result);
       // Пропускаем вызов next(), так как мы уже сформировали ответ
   }

// Middleware для отображения текущего конвейера
public class PipelineVisualizerMiddleware
{
    private readonly RequestDelegate _next;
    
    public PipelineVisualizerMiddleware(RequestDelegate next)
    {
        _next = next;
    }
    
    public async Task InvokeAsync(HttpContext context)
    {
        if (context.Request.Path == "/_debug/pipeline")
        {
            // Получение информации о зарегистрированных middleware
            var services = context.RequestServices;
            var appBuilder = services.GetRequiredService<IApplicationBuilder>();
            
            context.Response.ContentType = "text/html";
            await context.Response.WriteAsync("<h1>Middleware Pipeline</h1>");
            await context.Response.WriteAsync("<ul>");
            
            // Вывод списка middleware
            foreach (var middleware in GetMiddlewareTypes(appBuilder))
            {
                await context.Response.WriteAsync($"<li>{middleware.Name}</li>");
            }
            
            await context.Response.WriteAsync("</ul>");
            return;
        }
        
        await _next(context);
    }
    
    private IEnumerable<Type> GetMiddlewareTypes(IApplicationBuilder app)
    {
        // Упрощено - в реальности требуется рефлексия
        yield break;
    }
}

app.Use(async (context, next) =>
{
    var userAgent = context.Request.Headers["User-Agent"].ToString();
    Console.WriteLine($"User-Agent: {userAgent}");
    
    await next();
    
    // На обратном пути добавляем заголовок к ответу
    context.Response.Headers.Add("X-Processed-By", "My Custom Middleware");
});

public class RequestLoggerMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<RequestLoggerMiddleware> _logger;
    
    public RequestLoggerMiddleware(RequestDelegate next, ILogger<RequestLoggerMiddleware> logger)
    {
        _next = next;
        _logger = logger;
    }
    
    public async Task InvokeAsync(HttpContext context)
    {
        _logger.LogInformation("Request started: {Method} {Path}", 
                              context.Request.Method, 
                              context.Request.Path);
        
        var sw = Stopwatch.StartNew();
        try
        {
            await _next(context);
        }
        finally
        {
            sw.Stop();
            _logger.LogInformation("Request completed in {ElapsedMs}ms with status {StatusCode}", 
                                  sw.ElapsedMilliseconds, 
                                  context.Response.StatusCode);
        }
    }
}

app.UseMiddleware<RequestLoggerMiddleware>();

public static class RequestLoggerMiddlewareExtensions
{
    public static IApplicationBuilder UseRequestLogger(
        this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<RequestLoggerMiddleware>();
    }
}

app.UseRequestLogger();

public class GeoLocationMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IGeoService _geoService;
    private readonly GeoOptions _options;
    
    public GeoLocationMiddleware(
        RequestDelegate next, 
        IGeoService geoService, 
        IOptions<GeoOptions> options)
    {
        _next = next;
        _geoService = geoService;
        _options = options.Value;
    }
    
    public async Task InvokeAsync(HttpContext context)
    {
        var ipAddress = context.Connection.RemoteIpAddress;
        if (ipAddress != null && _options.EnableIpLookup)
        {
            var location = await _geoService.LookupLocationAsync(ipAddress);
            context.Items["UserLocation"] = location;
        }
        
        await _next(context);
    }
}

public async Task InvokeAsync(HttpContext context, IUserService userService)
{
    // userService будет создаваться для каждого запроса
    var user = await userService.GetUserAsync(context.User);
    // ...
    await _next(context);
}

public async Task InvokeAsync(HttpContext context)
{
    // Асинхронная операция до передачи управления
    await PrepareRequestAsync(context);
    
    // Передача управления следующему middleware
    await _next(context);
    
    // Асинхронная операция после возврата
    await FinalizeResponseAsync(context);
}
 
private async Task PrepareRequestAsync(HttpContext context)
{
    // Имитация асинхронной операции
    await Task.Delay(10); // В реальности здесь может быть запрос к БД или внешнему API
}
 
private async Task FinalizeResponseAsync(HttpContext context)
{
    // Ещё одна асинхронная операция
    await Task.Delay(5);
}

// Применение middleware только к определённому пути
app.Map("/api", apiApp =>
{
    apiApp.UseApiKeyMiddleware();
    apiApp.UseCustomHeaderMiddleware();
});
 
// Условное применение middleware
app.MapWhen(
    context => context.Request.Query.ContainsKey("debug"),
    debugApp => {
        debugApp.UseDebugMiddleware();
    }
);

public async Task InvokeAsync(HttpContext context)
{
    // Проверяем путь запроса
    if (context.Request.Path.StartsWithSegments("/secured"))
    {
        // Логика для защищённых маршрутов
        if (!IsAuthenticated(context))
        {
            context.Response.StatusCode = 401; // Unauthorized
            return; // Прерываем конвейер
        }
    }
    
    await _next(context);
}

public async Task InvokeAsync(HttpContext context)
{
    try
    {
        await _next(context);
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "An unhandled exception occurred");
        
        // Предотвращаем утечку деталей об ошибке в продакшн
        var isDevelopment = Environment.IsDevelopment();
        
        context.Response.StatusCode = StatusCodes.Status500InternalServerError;
        context.Response.ContentType = "application/json";
        
        var response = new { 
            error = isDevelopment ? ex.Message : "An error occurred", 
            stackTrace = isDevelopment ? ex.StackTrace : null 
        };
        
        await context.Response.WriteAsJsonAsync(response);
    }
}

public async Task InvokeAsync(HttpContext context)
{
    if (context.Request.Path.StartsWithSegments("/upload"))
    {
        // ПЛОХО: загружает весь файл в память
        using var memoryStream = new MemoryStream();
        await context.Request.Body.CopyToAsync(memoryStream);
        var fileBytes = memoryStream.ToArray();
        // Дальнейшая обработка...
    }
    
    await _next(context);
}

public async Task InvokeAsync(HttpContext context)
{
    if (context.Request.Path.StartsWithSegments("/upload"))
    {
        // ХОРОШО: обрабатывает данные потоково
        using var fileStream = File.Create(Path.GetTempFileName());
        await context.Request.Body.CopyToAsync(fileStream);
        fileStream.Position = 0;
        // Дальнейшая обработка...
    }
    
    await _next(context);
}

public async Task InvokeAsync(HttpContext context)
{
    if (context.Request.Path.StartsWithSegments("/upload"))
    {
        using var fileStream = File.Create(Path.GetTempFileName());
        var buffer = new byte[8192]; // 8KB буфер
        int bytesRead;
        
        while ((bytesRead = await context.Request.Body.ReadAsync(buffer, 0, buffer.Length)) > 0)
        {
            await fileStream.WriteAsync(buffer, 0, bytesRead);
            // Можно добавить обработку каждого чанка данных
        }
    }
    
    await _next(context);
}

public async Task InvokeAsync(HttpContext context)
{
    // Делаем тело запроса доступным для повторного чтения
    context.Request.EnableBuffering();
    
    // Первое чтение 
    using (var reader = new StreamReader(
        context.Request.Body,
        encoding: Encoding.UTF8,
        detectEncodingFromByteOrderMarks: false,
        leaveOpen: true))
    {
        var body = await reader.ReadToEndAsync();
        // Обработка body...
        
        // Важно: сбросить позицию потока
        context.Request.Body.Position = 0;
    }
    
    // Теперь другие middleware могут читать тело запроса
    await _next(context);
}

public ValueTask<string> GetCachedValueAsync(string key)
{
    if (_cache.TryGetValue(key, out var cachedValue))
    {
        // Значение в кэше — возвращаем немедленно без создания Task
        return new ValueTask<string>((string)cachedValue);
    }
    
    // Значения нет — делаем "тяжёлую" асинхронную операцию
    return new ValueTask<string>(FetchValueFromDatabaseAsync(key));
}

public class OptimizedMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IMemoryCache _cache;
    
    public OptimizedMiddleware(RequestDelegate next, IMemoryCache cache)
    {
        _next = next;
        _cache = cache;
    }
    
    public async Task InvokeAsync(HttpContext context)
    {
        var cacheKey = context.Request.Path;
        
        // Пытаемся получить данные из кэша
        var cachedValue = await GetCachedDataAsync(cacheKey);
        if (cachedValue != null)
        {
            await context.Response.WriteAsync(cachedValue);
            return;
        }
        
        await _next(context);
    }
    
    private ValueTask<string> GetCachedDataAsync(string key)
    {
        if (_cache.TryGetValue(key, out string value))
        {
            return new ValueTask<string>(value);
        }
        
        return new ValueTask<string>(FetchAndCacheDataAsync(key));
    }
    
    private async Task<string> FetchAndCacheDataAsync(string key)
    {
        // Имитация тяжелой операции
        await Task.Delay(100);
        var result = $"Data for {key} at {DateTime.UtcNow}";
        
        _cache.Set(key, result, TimeSpan.FromMinutes(10));
        return result;
    }
}

public class CompositeMiddleware
{
    private readonly RequestDelegate _next;
    private readonly RequestDelegate _pipeline;
    
    public CompositeMiddleware(RequestDelegate next, IServiceProvider services)
    {
        _next = next;
        
        // Создаём внутренний конвейер из нескольких middleware
        var builder = new ApplicationBuilder(services);
        builder.UseMiddleware<FirstComponentMiddleware>();
        builder.UseMiddleware<SecondComponentMiddleware>();
        builder.UseMiddleware<ThirdComponentMiddleware>();
        builder.Run(ctx => next(ctx)); // Подключаем внешний конвейер
        
        _pipeline = builder.Build();
    }
    
    public Task InvokeAsync(HttpContext context)
    {
        // Запускаем внутренний конвейер, который в конце вызовет _next
        return _pipeline(context);
    }
}

public async Task InvokeAsync(HttpContext context)
{
    // Запускаем несколько задач параллельно
    var userDataTask = FetchUserDataAsync(context.User);
    var preferencesTask = FetchPreferencesAsync(context.User);
    var analyticsTask = TrackRequestAsync(context);
    
    // Дожидаемся завершения всех задач
    await Task.WhenAll(userDataTask, preferencesTask, analyticsTask);
    
    // Используем результаты
    context.Items["UserData"] = userDataTask.Result;
    context.Items["Preferences"] = preferencesTask.Result;
    
    await _next(context);
}

public async Task InvokeAsync(HttpContext context)
{
    // Получаем токен отмены из контекста запроса
    var requestAborted = context.RequestAborted;
    
    // Создаём токен с тайм-аутом 5 секунд
    using var timeoutCts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
    using var linkedCts = CancellationTokenSource
        .CreateLinkedTokenSource(requestAborted, timeoutCts.Token);
    
    try
    {
        // Передаём токен в асинхронную операцию
        var result = await ExpensiveOperationAsync(linkedCts.Token);
        context.Items["OperationResult"] = result;
    }
    catch (OperationCanceledException)
    {
        if (timeoutCts.IsCancellationRequested)
        {
            context.Response.StatusCode = StatusCodes.Status408RequestTimeout;
            await context.Response.WriteAsync("Operation timed out");
            return;
        }
        
        // Клиент прервал запрос
        context.Abort();
        return;
    }
    
    await _next(context);
}

public class LoggingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger _logger;
 
    public LoggingMiddleware(RequestDelegate next, ILogger<LoggingMiddleware> logger)
    {
        _next = next;
        _logger = logger;
    }
 
    public async Task InvokeAsync(HttpContext context)
    {
        var stopwatch = Stopwatch.StartNew();
        var requestId = Guid.NewGuid().ToString();
        
        // Записываем информацию о начале запроса
        _logger.LogInformation("Запрос {RequestId}: {Method} {Url} начат", 
            requestId, context.Request.Method, context.Request.Path);
 
        try
        {
            await _next(context);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Запрос {RequestId} завершился ошибкой", requestId);
            throw; // Пробрасываем исключение дальше
        }
        finally
        {
            stopwatch.Stop();
            // Записываем информацию о завершении запроса
            _logger.LogInformation("Запрос {RequestId}: завершён со статусом {StatusCode} за {ElapsedMs}мс", 
                requestId, context.Response.StatusCode, stopwatch.ElapsedMilliseconds);
        }
    }
}

public class ApiGatewayMiddleware
{
    private readonly RequestDelegate _next;
    private readonly HttpClient _httpClient;
    private readonly IConfiguration _config;
 
    public ApiGatewayMiddleware(RequestDelegate next, IConfiguration config)
    {
        _next = next;
        _config = config;
        _httpClient = new HttpClient();
    }
 
    public async Task InvokeAsync(HttpContext context)
    {
        var path = context.Request.Path.Value;
        
        // Определяем, к какому сервису направляется запрос
        if (path.StartsWith("/users"))
        {
            await ProxyRequest(context, "user-service");
            return;
        }
        
        if (path.StartsWith("/orders"))
        {
            await ProxyRequest(context, "order-service");
            return;
        }
        
        // Если нет подходящего сервиса, продолжаем стандартную обработку
        await _next(context);
    }
 
    private async Task ProxyRequest(HttpContext context, string serviceName)
    {
        var serviceUrl = _config[$"Services:{serviceName}:Url"];
        var targetUrl = $"{serviceUrl}{context.Request.Path}{context.Request.QueryString}";
        
        // ... логика проксирования запроса ...
    }
}

public class ExceptionHandlingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger _logger;
    private readonly IWebHostEnvironment _env;
 
    public ExceptionHandlingMiddleware(
        RequestDelegate next, 
        ILogger<ExceptionHandlingMiddleware> logger,
        IWebHostEnvironment env)
    {
        _next = next;
        _logger = logger;
        _env = env;
    }
 
    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 = _env.IsDevelopment()
                ? new { error = ex.Message, stackTrace = ex.StackTrace }
                : new { error = "Произошла внутренняя ошибка сервера" };
            
            await context.Response.WriteAsJsonAsync(response);
        }
    }
}

public class SimpleCachingMiddleware
{
    private readonly RequestDelegate _next;
    private static readonly ConcurrentDictionary<string, CachedResponse> _cache 
        = new ConcurrentDictionary<string, CachedResponse>();
 
    public SimpleCachingMiddleware(RequestDelegate next)
    {
        _next = next;
    }
 
    public async Task InvokeAsync(HttpContext context)
    {
        // Кэшируем только GET-запросы
        if (!HttpMethods.IsGet(context.Request.Method))
        {
            await _next(context);
            return;
        }
 
        var cacheKey = context.Request.Path.Value;
        
        if (_cache.TryGetValue(cacheKey, out var cachedResponse) && !cachedResponse.Expired)
        {
            // Возвращаем кэшированный ответ
            context.Response.StatusCode = cachedResponse.StatusCode;
            context.Response.ContentType = cachedResponse.ContentType;
            await context.Response.WriteAsync(cachedResponse.Body);
            return;
        }
 
        // Сохраняем оригинальный поток ответа
        var originalBodyStream = context.Response.Body;
        using var responseBody = new MemoryStream();
        context.Response.Body = responseBody;
 
        try
        {
            await _next(context);
            
            if (context.Response.StatusCode == 200)
            {
                // Сохраняем ответ в кэш
                responseBody.Seek(0, SeekOrigin.Begin);
                var responseBodyText = await new StreamReader(responseBody).ReadToEndAsync();
                
                var response = new CachedResponse
                {
                    Body = responseBodyText,
                    ContentType = context.Response.ContentType,
                    StatusCode = context.Response.StatusCode,
                    Cached = DateTime.UtcNow,
                    Expired = false
                };
                
                _cache.TryAdd(cacheKey, response);
                
                // Сбрасываем позицию потока для дальнейшего чтения
                responseBody.Seek(0, SeekOrigin.Begin);
            }
        }
        finally
        {
            // Копируем измененный ответ в оригинальный поток
            await responseBody.CopyToAsync(originalBodyStream);
            context.Response.Body = originalBodyStream;
        }
    }
 
    private class CachedResponse
    {
        public string Body { get; set; }
        public string ContentType { get; set; }
        public int StatusCode { get; set; }
        public DateTime Cached { get; set; }
        public bool Expired { get; set; }
    }
}

public class JwtMiddleware
{
    private readonly RequestDelegate _next;
    private readonly string _secret;
 
    public JwtMiddleware(RequestDelegate next, IConfiguration config)
    {
        _next = next;
        _secret = config["Jwt:Key"];
    }
 
    public async Task InvokeAsync(HttpContext context)
    {
        var token = context.Request.Headers["Authorization"]
            .FirstOrDefault()?.Split(" ").Last();
 
        if (token != null)
            AttachUserToContext(context, token);
 
        await _next(context);
    }
 
    private void AttachUserToContext(HttpContext context, string token)
    {
        try
        {
            var key = Encoding.ASCII.GetBytes(_secret);
            var handler = new JwtSecurityTokenHandler();
            
            // Валидация токена...
            
            // При успехе добавляем информацию о пользователе в контекст
            var userId = "extracted-user-id";
            context.Items["User"] = userId;
        }
        catch
        {
            // При ошибке валидации просто продолжаем без аутентификации
        }
    }
}

public class RateLimitingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IMemoryCache _cache;
    private readonly int _maxRequests;
    private readonly TimeSpan _window;
 
    public RateLimitingMiddleware(
        RequestDelegate next,
        IMemoryCache cache,
        IConfiguration config)
    {
        _next = next;
        _cache = cache;
        _maxRequests = config.GetValue<int>("RateLimit:MaxRequests", 100);
        _window = TimeSpan.FromSeconds(config.GetValue<int>("RateLimit:WindowSeconds", 60));
    }
 
    public async Task InvokeAsync(HttpContext context)
    {
        var clientIp = context.Connection.RemoteIpAddress?.ToString() ?? "unknown";
        var cacheKey = $"rate_limit_{clientIp}";
        
        var counter = _cache.GetOrCreate(cacheKey, entry =>
        {
            entry.AbsoluteExpirationRelativeToNow = _window;
            return 0;
        });
        
        // Увеличиваем счётчик
        counter++;
        _cache.Set(cacheKey, counter, _window);
        
        // Добавляем заголовки с информацией о лимитах
        context.Response.Headers.Add("X-RateLimit-Limit", _maxRequests.ToString());
        context.Response.Headers.Add("X-RateLimit-Remaining", Math.Max(0, _maxRequests - counter).ToString());
        
        if (counter > _maxRequests)
        {
            context.Response.StatusCode = StatusCodes.Status429TooManyRequests;
            await context.Response.WriteAsync("Too many requests. Please try again later.");
            return;
        }
        
        await _next(context);
    }
}

public class ValidationMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IEnumerable<IValidator> _validators;
 
    public ValidationMiddleware(RequestDelegate next, IEnumerable<IValidator> validators)
    {
        _next = next;
        _validators = validators;
    }
 
    public async Task InvokeAsync(HttpContext context)
    {
        foreach (var validator in _validators)
        {
            if (validator.CanValidate(context))
            {
                var result = await validator.ValidateAsync(context);
                if (!result.IsValid)
                {
                    context.Response.StatusCode = StatusCodes.Status400BadRequest;
                    await context.Response.WriteAsJsonAsync(new { errors = result.Errors });
                    return;
                }
            }
        }
        
        await _next(context);
    }
}
 
// Интерфейс для валидаторов
public interface IValidator
{
    bool CanValidate(HttpContext context);
    Task<ValidationResult> ValidateAsync(HttpContext context);
}

public class CompressionMiddleware
{
    private readonly RequestDelegate _next;
    private readonly CompressionLevel _compressionLevel;
 
    public CompressionMiddleware(RequestDelegate next, CompressionLevel compressionLevel = CompressionLevel.Fastest)
    {
        _next = next;
        _compressionLevel = compressionLevel;
    }
 
    public async Task InvokeAsync(HttpContext context)
    {
        var acceptEncoding = context.Request.Headers["Accept-Encoding"].ToString().ToLowerInvariant();
        
        // Проверяем, поддерживает ли клиент сжатие
        if (acceptEncoding.Contains("gzip"))
        {
            // Сохраняем оригинальный поток ответа
            var originalBody = context.Response.Body;
            using var compressedBody = new MemoryStream();
            
            // Заменяем поток ответа на сжимающий
            context.Response.Body = compressedBody;
            context.Response.Headers.Add("Content-Encoding", "gzip");
            
            await _next(context);
            
            // После обработки запроса сжимаем результат
            compressedBody.Seek(0, SeekOrigin.Begin);
            using var gzipStream = new GZipStream(originalBody, _compressionLevel, true);
            await compressedBody.CopyToAsync(gzipStream);
        }
        else
        {
            await _next(context);
        }
    }
}

public class LocalizationMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IStringLocalizer _localizer;
 
    public LocalizationMiddleware(RequestDelegate next, IStringLocalizer<LocalizationMiddleware> localizer)
    {
        _next = next;
        _localizer = localizer;
    }
 
    public async Task InvokeAsync(HttpContext context)
    {
        // Извлекаем предпочтительный язык из заголовков или куки
        var culture = GetPreferredCulture(context);
        
        // Устанавливаем культуру для текущего запроса
        var cultureInfo = new CultureInfo(culture);
        CultureInfo.CurrentCulture = cultureInfo;
        CultureInfo.CurrentUICulture = cultureInfo;
        
        // Сохраняем выбор пользователя
        context.Response.Cookies.Append("LANG-PREF", culture,
            new CookieOptions { Expires = DateTimeOffset.UtcNow.AddYears(1) });
        
        await _next(context);
    }
 
    private string GetPreferredCulture(HttpContext context)
    {
        // Сначала проверяем куки
        if (context.Request.Cookies.TryGetValue("LANG-PREF", out var cookieCulture))
            return cookieCulture;
            
        // Затем смотрим заголовок Accept-Language
        var acceptLang = context.Request.Headers["Accept-Language"].ToString();
        var langHeader = acceptLang.Split(',').FirstOrDefault();
        if (!string.IsNullOrEmpty(langHeader))
            return langHeader.Split(';').First().Trim();
            
        return "en-US"; // Язык по умолчанию
    }
}

public class HealthCheckMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<HealthCheckMiddleware> _logger;
    private readonly IHealthCheckService _healthService;
 
    public HealthCheckMiddleware(
        RequestDelegate next, 
        ILogger<HealthCheckMiddleware> logger,
        IHealthCheckService healthService)
    {
        _next = next;
        _logger = logger;
        _healthService = healthService;
    }
 
    public async Task InvokeAsync(HttpContext context)
    {
        if (context.Request.Path.Equals("/health"))
        {
            var result = await _healthService.CheckHealthAsync();
            context.Response.ContentType = "application/json";
            
            if (result.Status == HealthStatus.Healthy)
            {
                context.Response.StatusCode = StatusCodes.Status200OK;
                await context.Response.WriteAsJsonAsync(new { status = "healthy" });
            }
            else
            {
                _logger.LogWarning("Система сообщила о нездоровом состоянии");
                context.Response.StatusCode = StatusCodes.Status503ServiceUnavailable;
                await context.Response.WriteAsJsonAsync(new { 
                    status = "unhealthy",
                    issues = result.Issues
                });
            }
            
            return;
        }
        
        await _next(context);
    }
}

public async Task InvokeAsync(HttpContext context)
{
    var sw = Stopwatch.StartNew();
    
    await _next(context);
    
    sw.Stop();
    _logger.LogDebug(
        "Middleware {Name} выполнялся {ElapsedMs}мс",
        GetType().Name,
        sw.ElapsedMilliseconds);
}

public async Task InvokeAsync(HttpContext context)
{
    using var activity = new Activity("MyMiddleware.Execute")
        .SetTag("http.method", context.Request.Method)
        .SetTag("http.url", context.Request.Path)
        .Start();
    
    try
    {
        await _next(context);
        activity.SetTag("status", "success");
    }
    catch (Exception ex)
    {
        activity.SetTag("status", "error");
        activity.SetTag("error.type", ex.GetType().Name);
        activity.SetTag("error.message", ex.Message);
        throw;
    }
}

[Fact]
public async Task MyMiddleware_ShouldAddResponseHeader()
{
    // Arrange
    var context = new DefaultHttpContext();
    var nextCalled = false;
    
    RequestDelegate next = (HttpContext ctx) =>
    {
        nextCalled = true;
        return Task.CompletedTask;
    };
    
    var middleware = new MyMiddleware(next);
    
    // Act
    await middleware.InvokeAsync(context);
    
    // Assert
    Assert.True(nextCalled);
    Assert.Equal("ExpectedValue", context.Response.Headers["X-Custom-Header"]);
}

[Fact]
public async Task AuthMiddleware_ShouldBlockUnauthorizedRequests()
{
    // Arrange
    var mockContext = new DefaultHttpContext();
    mockContext.Request.Headers["Authorization"] = "InvalidToken";
    
    var mockLogger = new Mock<ILogger<AuthMiddleware>>();
    
    bool nextCalled = false;
    RequestDelegate next = (HttpContext ctx) => {
        nextCalled = true;
        return Task.CompletedTask;
    };
    
    var middleware = new AuthMiddleware(next, mockLogger.Object);
    
    // Act
    await middleware.InvokeAsync(mockContext);
    
    // Assert
    Assert.False(nextCalled); // Следующий middleware не должен вызываться
    Assert.Equal(401, mockContext.Response.StatusCode); // Должен вернуть 401 Unauthorized
    
    // Проверяем, что было вызвано логирование с нужным уровнем и сообщением
    mockLogger.Verify(
        x => x.Log(
            LogLevel.Warning,
            It.IsAny<EventId>(),
            It.Is<It.IsAnyType>((o, t) => o.ToString().Contains("Invalid token")),
            It.IsAny<Exception>(),
            It.IsAny<Func<It.IsAnyType, Exception, string>>()),
        Times.Once);
}

public class MiddlewareIntegrationTests
    : IClassFixture<WebApplicationFactory<Program>>
{
    private readonly WebApplicationFactory<Program> _factory;
    
    public MiddlewareIntegrationTests(WebApplicationFactory<Program> factory)
    {
        _factory = factory;
    }
    
    [Fact]
    public async Task RequestPipeline_ShouldProcessRequestCorrectly()
    {
        // Arrange
        var client = _factory.CreateClient();
        
        // Act
        var response = await client.GetAsync("/api/test");
        
        // Assert
        response.EnsureSuccessStatusCode();
        Assert.Equal("application/json", response.Content.Headers.ContentType.MediaType);
        Assert.Contains("X-Response-Time", response.Headers.Select(h => h.Key));
    }
    
    [Fact]
    public async Task AuthenticationMiddleware_ShouldBlockUnauthenticatedRequests()
    {
        // Arrange
        var client = _factory.CreateClient();
        
        // Act
        var response = await client.GetAsync("/secured/resource");
        
        // Assert
        Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
    }
}

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

public class DiagnosticMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IWebHostEnvironment _env;
    
    public DiagnosticMiddleware(RequestDelegate next, IWebHostEnvironment env)
    {
        _next = next;
        _env = env;
    }
    
    public async Task InvokeAsync(HttpContext context)
    {
        if (_env.IsDevelopment() && context.Request.Query.ContainsKey("_debug"))
        {
            await WriteDiagnosticInfo(context);
            return;
        }
        
        await _next(context);
    }
    
    private async Task WriteDiagnosticInfo(HttpContext context)
    {
        context.Response.ContentType = "text/html";
        await context.Response.WriteAsync("<h1>Diagnostic Info</h1>");
        await context.Response.WriteAsync("<h2>Request Headers</h2>");
        await context.Response.WriteAsync("<ul>");
        
        foreach (var header in context.Request.Headers)
        {
            await context.Response.WriteAsync($"<li>{header.Key}: {header.Value}</li>");
        }
        
        await context.Response.WriteAsync("</ul>");
        
        // Можно добавить и другую диагностическую информацию
    }
}