Оптимизация производительности ASP.NET Core MVC с помощью Middleware и кеширования

// Монолитный подход: все в одном проекте
public class OrderController : Controller
{
    private readonly IProductRepository _productRepo;
    private readonly IOrderProcessor _orderProcessor;
    
    public async Task<IActionResult> PlaceOrder(OrderViewModel model)
    {
        // Всё обрабатывается внутри одного процесса
        var products = await _productRepo.GetProductsAsync(model.ProductIds);
        var order = await _orderProcessor.ProcessOrderAsync(products, model.UserId);
        return View(order);
    }
}
 
// Микросервисный подход: дополнительные накладные расходы
public class OrderController : Controller
{
    private readonly IProductServiceClient _productClient;
    private readonly IOrderServiceClient _orderClient;
    
    public async Task<IActionResult> PlaceOrder(OrderViewModel model)
    {
        // Каждый вызов — сетевой запрос к другому сервису
        var products = await _productClient.GetProductsAsync(model.ProductIds);
        var order = await _orderClient.ProcessOrderAsync(products, model.UserId);
        return View(order);
    }
}

// Entity Framework Core — удобно, но медленнее
var users = await _context.Users
    .Where(u => u.IsActive)
    .Include(u => u.Orders)
    .ToListAsync();
 
// Dapper — быстрее, но больше кода
var users = await _connection.QueryAsync<User>(@"
    SELECT u.*, o.* 
    FROM Users u 
    LEFT JOIN Orders o ON o.UserId = u.Id 
    WHERE u.IsActive = 1");

// Плохо: блокирует поток во время ожидания БД
public IActionResult GetData()
{
    var result = _repository.GetDataAsync().Result; // Блокирующий вызов!
    return Ok(result);
}
 
// Хорошо: освобождает поток во время ожидания БД
public async Task<IActionResult> GetData()
{
    var result = await _repository.GetDataAsync();
    return Ok(result);
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // Перехватывает исключения ДО любой другой обработки
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    else
    {
        app.UseExceptionHandler("/Home/Error");
        app.UseHsts();
    }
 
    app.UseHttpsRedirection();
    app.UseStaticFiles();
    app.UseRouting();
    
    app.UseAuthentication();
    app.UseAuthorization();
 
    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllerRoute(
            name: "default",
            pattern: "{controller=Home}/{action=Index}/{id?}");
    });
}

public class ResponseTimingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<ResponseTimingMiddleware> _logger;
 
    public ResponseTimingMiddleware(RequestDelegate next, ILogger<ResponseTimingMiddleware> logger)
    {
        _next = next;
        _logger = logger;
    }
 
    public async Task InvokeAsync(HttpContext context)
    {
        var sw = Stopwatch.StartNew();
        
        try
        {
            // Передаём управление следующему middleware в цепочке
            await _next(context);
        }
        finally
        {
            sw.Stop();
            _logger.LogInformation(
                "Запрос {Method} {Path} обработан за {ElapsedMilliseconds}мс",
                context.Request.Method,
                context.Request.Path,
                sw.ElapsedMilliseconds);
        }
    }
}
 
// Регистрация в пайплайне
app.UseMiddleware<ResponseTimingMiddleware>();

public class CachingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IMemoryCache _cache;
    private readonly TimeSpan _cacheDuration;
 
    public CachingMiddleware(RequestDelegate next, IMemoryCache cache, TimeSpan cacheDuration)
    {
        _next = next;
        _cache = cache;
        _cacheDuration = cacheDuration;
    }
 
    public async Task InvokeAsync(HttpContext context)
    {
        // Только GET-запросы подлежат кешированию
        if (!HttpMethods.IsGet(context.Request.Method))
        {
            await _next(context);
            return;
        }
 
        // Генерируем ключ на основе пути и квери-параметров
        var cacheKey = context.Request.Path + context.Request.QueryString;
        
        // Проверяем, есть ли ответ в кеше
        if (_cache.TryGetValue(cacheKey, out byte[] cachedResponse))
        {
            // Отправляем кешированный ответ и прерываем конвейер
            context.Response.ContentType = "application/json";
            await context.Response.Body.WriteAsync(cachedResponse);
            return;
        }
 
        // Перехватываем оригинальный ответный поток
        var originalBodyStream = context.Response.Body;
        using var responseBody = new MemoryStream();
        context.Response.Body = responseBody;
 
        // Продолжаем пайплайн
        await _next(context);
 
        // Сохраняем ответ в кеш для будущих запросов
        responseBody.Seek(0, SeekOrigin.Begin);
        var responseBytes = responseBody.ToArray();
        _cache.Set(cacheKey, responseBytes, _cacheDuration);
 
        // Копируем ответ обратно в исходный поток
        responseBody.Seek(0, SeekOrigin.Begin);
        await responseBody.CopyToAsync(originalBodyStream);
    }
}

// Отдельный пайплайн для API
app.Map("/api", apiApp => 
{
    apiApp.UseMiddleware<ApiAuthenticationMiddleware>();
    apiApp.UseMiddleware<RateLimitingMiddleware>();
    // ...
});
 
// Отдельный пайплайн для статических файлов
app.MapWhen(
    context => context.Request.Path.StartsWithSegments("/static"), 
    staticApp => 
    {
        staticApp.UseStaticFiles();
        staticApp.UseMiddleware<CachingMiddleware>();
        // ...
    });

public class ProductController : Controller
{
    private readonly IMemoryCache _memoryCache;
    private readonly IProductRepository _repository;
    
    public ProductController(IMemoryCache memoryCache, IProductRepository repository)
    {
        _memoryCache = memoryCache;
        _repository = repository;
    }
    
    public async Task<IActionResult> GetPopularProducts()
    {
        // Ищем кешированные данные по ключу
        string cacheKey = "PopularProducts";
        
        if (!_memoryCache.TryGetValue(cacheKey, out List<Product> products))
        {
            // Кеша нет - выполняем дорогостоящую операцию
            products = await _repository.GetPopularProductsAsync();
            
            // Сохраняем в кеш с временем жизни 10 минут
            var cacheOptions = new MemoryCacheEntryOptions()
                .SetAbsoluteExpiration(TimeSpan.FromMinutes(10))
                .SetSlidingExpiration(TimeSpan.FromMinutes(2))
                .SetPriority(CacheItemPriority.High);
                
            _memoryCache.Set(cacheKey, products, cacheOptions);
        }
        
        return View(products);
    }
}

public class CatalogController : Controller
{
    private readonly IDistributedCache _distributedCache;
    private readonly ICatalogService _catalogService;
    
    public CatalogController(IDistributedCache distributedCache, ICatalogService catalogService)
    {
        _distributedCache = distributedCache;
        _catalogService = catalogService;
    }
    
    public async Task<IActionResult> GetCategories()
    {
        string cacheKey = "AllCategories";
        List<Category> categories;
        
        // Пытаемся получить сериализованные данные из кеша
        byte[] cachedData = await _distributedCache.GetAsync(cacheKey);
        
        if (cachedData != null)
        {
            // Десериализуем данные
            string cachedString = Encoding.UTF8.GetString(cachedData);
            categories = JsonSerializer.Deserialize<List<Category>>(cachedString);
        }
        else
        {
            // Данных нет - запрашиваем из сервиса
            categories = await _catalogService.GetAllCategoriesAsync();
            
            // Сериализуем и кешируем
            string serialized = JsonSerializer.Serialize(categories);
            byte[] encodedData = Encoding.UTF8.GetBytes(serialized);
            
            var options = new DistributedCacheEntryOptions()
                .SetAbsoluteExpiration(TimeSpan.FromHours(24));
                
            await _distributedCache.SetAsync(cacheKey, encodedData, options);
        }
        
        return View(categories);
    }
}

public class StaticDataController : Controller
{
    [ResponseCache(Duration = 3600)] // Кеширование на 1 час
    public IActionResult CountryList()
    {
        // Даже не выполнится, если ответ в кеше
        return View(_dataService.GetCountries());
    }
    
    [ResponseCache(VaryByHeader = "User-Agent", Duration = 300)]
    public IActionResult DeviceSpecificView()
    {
        // Разный кеш для разных User-Agent
        return View();
    }
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddResponseCaching(options =>
    {
        options.MaximumBodySize = 32 * 1024 * 1024; // 32MB
        options.UseCaseSensitivePaths = true;
    });
    
    services.AddOutputCache(options =>
    {
        options.AddPolicy("ShortLived", builder => 
            builder.Expire(TimeSpan.FromSeconds(10)));
            
        options.AddPolicy("ByUser", builder => 
            builder.VaryByUser().Expire(TimeSpan.FromMinutes(5)));
    });
}
 
public void Configure(IApplicationBuilder app)
{
    app.UseResponseCaching();
    app.UseOutputCache();
}
 
// В контроллере
[OutputCache(PolicyName = "ShortLived")]
public IActionResult Index() { ... }

public class ProductService
{
    private readonly IMemoryCache _cache;
    private readonly IProductRepository _repository;
    private readonly IEventBus _eventBus;
    
    // При запуске подписываемся на события
    public ProductService(IMemoryCache cache, IProductRepository repository, IEventBus eventBus)
    {
        _cache = cache;
        _repository = repository;
        _eventBus = eventBus;
        
        // Подписываемся на событие изменения продукта
        _eventBus.Subscribe<ProductChangedEvent>(OnProductChanged);
    }
    
    // Обработчик события
    private void OnProductChanged(ProductChangedEvent @event)
    {
        // Инвалидируем кеш для конкретного продукта
        string cacheKey = $"Product_{@event.ProductId}";
        _cache.Remove(cacheKey);
        
        // И для списков, которые могли содержать этот продукт
        _cache.Remove("PopularProducts");
        _cache.Remove("NewArrivals");
    }
    
    public async Task<Product> GetProductByIdAsync(int productId)
    {
        string cacheKey = $"Product_{productId}";
        
        if (!_cache.TryGetValue(cacheKey, out Product product))
        {
            product = await _repository.GetByIdAsync(productId);
            _cache.Set(cacheKey, product, TimeSpan.FromMinutes(30));
        }
        
        return product;
    }
}

public async Task<IActionResult> GetProduct(int id)
{
    string cacheKey = $"Product_{id}";
    bool cacheHit = true;
    Product product;
    
    var watch = Stopwatch.StartNew();
    
    if (!_cache.TryGetValue(cacheKey, out product))
    {
        cacheHit = false;
        product = await _repository.GetByIdAsync(id);
        _cache.Set(cacheKey, product, TimeSpan.FromMinutes(30));
    }
    
    watch.Stop();
    
    _telemetry.TrackMetric("ProductCache.Duration", watch.ElapsedMilliseconds);
    _telemetry.TrackMetric("ProductCache.HitRate", cacheHit ? 1 : 0);
    
    return View(product);
}

public class LazyProductService
{
    private readonly IAppCache _cache;
    private readonly IProductRepository _repository;
 
    public LazyProductService(IAppCache cache, IProductRepository repository)
    {
        _cache = cache;
        _repository = repository;
    }
 
    public async Task<List<Product>> GetFeaturedProductsAsync()
    {
        // Автоматическая ленивая загрузка с обновлением каждые 20 минут
        return await _cache.GetOrAddAsync(
            "FeaturedProducts", 
            async () => await _repository.GetFeaturedProductsAsync(),
            TimeSpan.FromMinutes(20));
    }
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddStackExchangeRedisCache(options =>
    {
        options.Configuration = "localhost:6379";
        options.InstanceName = "MyAppInstance:";
    });
}

public async Task<Product> GetProductByIdAsync(int id)
{
    string cacheKey = $"product_{id}";
    
    // Проверяем кеш
    if (_cache.TryGetValue(cacheKey, out Product product))
        return product;
    
    // Кеша нет — получаем из базы
    product = await _database.Products.FindAsync(id);
    
    if (product != null)
    {
        // Сохраняем в кеш и возвращаем
        _cache.Set(cacheKey, product, TimeSpan.FromMinutes(15));
    }
    
    return product;
}

services.AddHttpClient<IProductApiClient, ProductApiClient>()
    .AddPolicyHandler(GetRetryPolicy())
    .AddPolicyHandler(GetCircuitBreakerPolicy())
    .AddPolicyHandler(GetCachePolicy());
 
private IAsyncPolicy<HttpResponseMessage> GetCachePolicy()
{
    return HttpCachePolicy.Cache()
        .AllowStaleResponses(TimeSpan.FromHours(1))
        .ForCircuitBreaker()
        .ForTransientHttpError();
}

services.AddMiniProfiler(options =>
{
    // Путь URL для доступа к результатам
    options.RouteBasePath = "/profiler";
    
    // Включить SQL-запросы для EF Core
    options.EnableServerTimingHeader = true;
});
 
// Middleware
app.UseMiniProfiler();

public async Task<IActionResult> Details(int id)
{
using (MiniProfiler.Current.Step("Получение детальной информации продукта"))
{
    using (MiniProfiler.Current.Step("Загрузка из базы"))
    {
        var product = await _repository.GetProductByIdAsync(id);
        
        using (MiniProfiler.Current.Step("Маппинг к ViewModel"))
        {
            var viewModel = _mapper.Map<ProductViewModel>(product);
            return View(viewModel);
        }
    }
}
}

services.AddApplicationInsightsTelemetry(Configuration["ApplicationInsights:InstrumentationKey"]);
 
// В коде можно добавлять собственные телеметрические данные
_telemetryClient.TrackEvent("ProductViewed", new Dictionary<string, string>
{
    { "ProductId", product.Id.ToString() },
    { "Category", product.Category.Name }
});

[MemoryDiagnoser]
public class CachingBenchmark
{
private readonly IMemoryCache _memoryCache = new MemoryCache(new MemoryCacheOptions());
private readonly IProductRepository _repository = new ProductRepository();
 
[Benchmark(Baseline = true)]
public async Task WithoutCaching()
{
    var product = await _repository.GetByIdAsync(1);
    // Использование продукта...
}
 
[Benchmark]
public async Task WithCaching()
{
    if (!_memoryCache.TryGetValue("Product_1", out Product product))
    {
        product = await _repository.GetByIdAsync(1);
        _memoryCache.Set("Product_1", product, TimeSpan.FromMinutes(10));
    }
    // Использование продукта...
}
}

// Плохо: N+1 запросы
var orders = context.Orders.ToList();
foreach (var order in orders)
{
// Для каждого заказа выполняется отдельный запрос!
var customer = context.Customers.Find(order.CustomerId);
}
 
// Хорошо: предварительная загрузка
var orders = context.Orders.Include(o => o.Customer).ToList();

services.AddEFSecondLevelCache(options =>
{
options.UseMemoryCacheProvider().DisableLogging();
});
 
services.AddDbContext<ApplicationDbContext>((serviceProvider, options) =>
{
options.UseSqlServer(connectionString)
    .AddInterceptors(serviceProvider.GetRequiredService<SecondLevelCacheInterceptor>());
});
 
// В коде
var products = await dbContext.Products
.Where(p => p.Category == "Electronics")
.OrderByDescending(p => p.Price)
.Cacheable(CacheExpirationMode.Sliding, TimeSpan.FromMinutes(5))
.ToListAsync();

services.AddControllers()
.AddJsonOptions(options =>
{
    // Оптимизация стандартной сериализации
    options.JsonSerializerOptions.PropertyNameCaseInsensitive = false;
    options.JsonSerializerOptions.IncludeFields = false;
})
.AddMvcOptions(options =>
{
    // Или использование альтернативных формат
    options.OutputFormatters.Clear();
    options.OutputFormatters.Add(new MessagePackOutputFormatter());
});

// 1. Прямая инвалидация при модификации данных
public async Task UpdateProductAsync(Product product)
{
    await _repository.UpdateProductAsync(product);
    
    // Инвалидируем кеш конкретного продукта
    _cache.Remove($"product_{product.Id}");
    
    // И связанные ключи
    _cache.Remove("featured_products");
    _cache.Remove("category_products_" + product.CategoryId);
}
 
// 2. Инвалидация через шину событий
public class ProductUpdatedEventHandler : IEventHandler<ProductUpdatedEvent>
{
    private readonly IDistributedCache _cache;
    
    public async Task HandleAsync(ProductUpdatedEvent @event)
    {
        // Инвалидация кеша в ответ на событие
        await _cache.RemoveAsync($"product_{@event.ProductId}");
    }
}
 
// 3. Временные метки модификации
public async Task<List<Product>> GetCategoryProductsAsync(int categoryId)
{
    string cacheKey = $"category_products_{categoryId}";
    
    // Получаем временную метку последнего обновления категории
    var lastModified = await _changeTracker.GetLastModifiedAsync("Category", categoryId);
    
    // Проверяем кеш с учётом версионирования
    if (_cache.TryGetValue(cacheKey, out CachedData<List<Product>> cached) && 
        cached.Timestamp >= lastModified)
    {
        return cached.Data;
    }
    
    var products = await _repository.GetProductsByCategoryAsync(categoryId);
    _cache.Set(cacheKey, new CachedData<List<Product>>(products, DateTime.UtcNow));
    return products;
}

public class ProductCacheRefresher : BackgroundService
{
    private readonly IProductRepository _repository;
    private readonly IDistributedCache _cache;
    private readonly IEventBus _eventBus;
    
    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        await _eventBus.SubscribeAsync<ProductUpdatedEvent>(async @event =>
        {
            // Не инвалидируем, а обновляем кеш в фоновом режиме
            var product = await _repository.GetByIdAsync(@event.ProductId);
            
            if (product != null)
            {
                string serialized = JsonSerializer.Serialize(product);
                await _cache.SetStringAsync(
                    $"product_{@event.ProductId}", 
                    serialized,
                    new DistributedCacheEntryOptions {
                        AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(24)
                    });
            }
        });
    }
}

app.UseStaticFiles();

app.UseStaticFiles(new StaticFileOptions
{
    OnPrepareResponse = ctx =>
    {
        // Кешируем статический контент на год
        var headers = ctx.Context.Response.Headers;
        var maxAge = TimeSpan.FromDays(365);
        
        headers[HeaderNames.CacheControl] = $"public,max-age={maxAge.TotalSeconds}";
        headers[HeaderNames.Expires] = DateTime.UtcNow.Add(maxAge).ToString("R");
    }
});

public static class VersionedFileHelper
{
    public static string GetVersionedFileName(string filePath)
    {
        string physicalPath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", filePath.TrimStart('/'));
        
        if (File.Exists(physicalPath))
        {
            using var md5 = MD5.Create();
            using var stream = File.OpenRead(physicalPath);
            var hash = md5.ComputeHash(stream);
            var fileHash = BitConverter.ToString(hash).Replace("-", "").ToLowerInvariant();
            
            var extension = Path.GetExtension(filePath);
            var versionedFileName = Path.ChangeExtension(filePath, null) + "." + fileHash + extension;
            
            return versionedFileName;
        }
        
        return filePath;
    }
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddWebOptimizer(pipeline =>
    {
        pipeline.MinifyJsFiles("js/**/*.js");
        pipeline.MinifyCssFiles("css/**/*.css");
        
        pipeline.AddJavaScriptBundle("/js/bundle.js", 
            "js/site.js", 
            "js/validation.js");
    });
}
 
public void Configure(IApplicationBuilder app)
{
    app.UseWebOptimizer();
    app.UseStaticFiles();
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddResponseCompression(options =>
    {
        options.EnableForHttps = true; // Безопасно с современными браузерами
        options.Providers.Add<BrotliCompressionProvider>();
        options.Providers.Add<GzipCompressionProvider>();
        options.MimeTypes = ResponseCompressionDefaults.MimeTypes.Concat(
            new[] { "application/json", "application/xml", "text/plain" });
    });
    
    services.Configure<BrotliCompressionProviderOptions>(options =>
    {
        options.Level = CompressionLevel.Fastest; // Баланс между CPU и степенью сжатия
    });
}
 
public void Configure(IApplicationBuilder app)
{
    app.UseResponseCompression();
    // Остальные middleware...
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddImageSharp(options =>
    {
        options.Configuration = Configuration.Default;
        options.MemoryStreamManager = new RecyclableMemoryStreamManager();
        options.CacheFolder = "img-cache";
    });
}
 
public void Configure(IApplicationBuilder app)
{
    app.UseImageSharp();
    app.UseStaticFiles();
}

public class HealthCheckMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IHealthCheckService _healthService;
 
    public HealthCheckMiddleware(RequestDelegate next, IHealthCheckService healthService)
    {
        _next = next;
        _healthService = healthService;
    }
 
    public async Task InvokeAsync(HttpContext context)
    {
        if (context.Request.Path.Equals("/health"))
        {
            var result = await _healthService.CheckHealthAsync();
            
            context.Response.StatusCode = result.Status == HealthStatus.Healthy 
                ? StatusCodes.Status200OK 
                : StatusCodes.Status503ServiceUnavailable;
                
            context.Response.ContentType = "application/json";
            
            await context.Response.WriteAsync(JsonSerializer.Serialize(result));
            return;
        }
        
        await _next(context);
    }
}

services.AddControllers()
    .AddJsonOptions(options =>
    {
        // Отключаем ненужные опции для увеличения скорасти
        options.JsonSerializerOptions.PropertyNamingPolicy = null;
        options.JsonSerializerOptions.IncludeFields = false;
        options.JsonSerializerOptions.IgnoreReadOnlyProperties = true;
        options.JsonSerializerOptions.DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull;
    });

services.AddControllers()
    .AddProtobufFormatters(); // Требует установки пакета WebApiContrib.Core.Formatter.Protobuf
 
// В контроллере
[Produces("application/x-protobuf")] // Указываем формат ответа
[HttpGet]
public ActionResult<List<Product>> GetProducts()
{
    return _repository.GetProducts();
}