C# и продвинутые приемы работы с БД

// Этот безобидный код может стать причиной падения сервера
using (var context = new DataContext())
{
    var customers = context.Customers
        .Include(c => c.Orders)
        .Include(c => c.Payments)
        .ToList();
    // Дальнейшая обработка...
}

// Этот антипаттерн встречается чаще, чем хотелось бы
public class LongLivingService
{
    private readonly DataContext _context = new DataContext();
    
    public async Task ProcessData()
    {
        // Работа с контекстом
        var data = await _context.SomeEntities.ToListAsync();
        // ...
    }
    // Метод Dispose никогда не вызывается!
}

// Классическая реализация Repository
public class CustomerRepository : ICustomerRepository
{
    private readonly DataContext _context;
    
    public CustomerRepository(DataContext context)
    {
        _context = context;
    }
    
    public Customer GetById(int id)
    {
        return _context.Customers.Find(id);
    }
    
    // Другие методы...
}

// Более специализированный подход
public class CustomerQueries
{
    private readonly DataContext _context;
    
    public CustomerQueries(DataContext context)
    {
        _context = context;
    }
    
    public CustomerDisplayDto GetForDisplay(int id)
    {
        return _context.Customers
            .Where(c => c.Id == id)
            .Select(c => new CustomerDisplayDto 
            {
                Id = c.Id,
                Name = c.Name,
                Email = c.Email
            })
            .FirstOrDefault();
    }
    
    public CustomerEditDto GetForEdit(int id)
    {
        return _context.Customers
            .Include(c => c.Address)
            .Where(c => c.Id == id)
            .Select(c => new CustomerEditDto
            {
                // Маппинг полей
            })
            .FirstOrDefault();
    }
}

// Антипаттерн: исчерпание пула соединений
foreach (var item in items)
{
    using (var connection = new SqlConnection(connectionString))
    {
        connection.Open();
        // Операции с БД...
    } // Соединение возвращается в пул
}

// Правильный подход
using (var connection = new SqlConnection(connectionString))
{
    connection.Open();
    foreach (var item in items)
    {
        // Операции с БД с использованием одного соединения
    }
} // Соединение возвращается в пул только один раз

using (var connection = new SqlConnection(connectionString))
{
    connection.Open();
    var results = await connection.QueryAsync<CustomerReport>(
        @"SELECT c.Id, c.Name, COUNT(o.Id) AS OrderCount, SUM(o.Total) AS TotalSpent
          FROM Customers c
          LEFT JOIN Orders o ON c.Id = o.CustomerId
          WHERE c.CreatedDate > @since
          GROUP BY c.Id, c.Name
          HAVING COUNT(o.Id) > 0
          ORDER BY SUM(o.Total) DESC",
        new { since = DateTime.Now.AddMonths(-6) });
    
    return results.ToList();
}

// Этот монстр-запрос выполнялся более 30 секунд
var shipments = context.Shipments
    .Include(s => s.Route)
    .Include(s => s.Items).ThenInclude(i => i.Product)
    .Include(s => s.Items).ThenInclude(i => i.PackageType)
    .Include(s => s.Carrier).ThenInclude(c => c.ContactInfo)
    .Include(s => s.Tracking).ThenInclude(t => t.CheckPoints)
    .ToList();

// Загружаем базовые данные
var shipments = context.Shipments
    .Include(s => s.Route)
    .Include(s => s.Carrier)
    .ToList();
 
// Затем догружаем связанные коллекции для уже полученных объектов
var shipmentIds = shipments.Select(s => s.Id).ToList();
var items = context.ShipmentItems
    .Include(i => i.Product)
    .Include(i => i.PackageType)
    .Where(i => shipmentIds.Contains(i.ShipmentId))
    .ToList();
 
// Группируем и связываем вручную
foreach (var shipment in shipments)
{
    shipment.Items = items.Where(i => i.ShipmentId == shipment.Id).ToList();
}
 
// Аналогично для других связанных данных

public class CreateOrderCommand
{
    public Customer Customer { get; set; }
    public List<OrderItem> Items { get; set; }
    public ShippingInfo ShippingInfo { get; set; }
}
 
public class CreateOrderHandler
{
    private readonly DataContext _context;
    
    public CreateOrderHandler(DataContext context)
    {
        _context = context;
    }
    
    public async Task<Order> HandleAsync(CreateOrderCommand command)
    {
        // Транзакционная логика создания заказа
        using var transaction = await _context.Database.BeginTransactionAsync();
        try
        {
            var order = new Order
            {
                CustomerId = command.Customer.Id,
                OrderDate = DateTime.UtcNow,
                Status = OrderStatus.Created,
                // Другие свойства
            };
            
            _context.Orders.Add(order);
            await _context.SaveChangesAsync();
            
            // Добавление позиций заказа
            foreach (var item in command.Items)
            {
                var orderItem = new OrderItem
                {
                    OrderId = order.Id,
                    ProductId = item.ProductId,
                    Quantity = item.Quantity,
                    UnitPrice = item.UnitPrice
                };
                _context.OrderItems.Add(orderItem);
            }
            
            await _context.SaveChangesAsync();
            await transaction.CommitAsync();
            
            return order;
        }
        catch
        {
            await transaction.RollbackAsync();
            throw;
        }
    }
}

public async Task<List<Transaction>> GetTransactionsAsync(DateTime from, DateTime to)
{
    var result = new List<Transaction>();
    
    // Определяем, какие секции нам нужны
    var sections = GetRequiredSections(from, to);
    
    foreach (var section in sections)
    {
        // Динамически формируем имя таблицы
        var tableName = $"Transactions_{section.Year}_{section.Month:D2}";
        
        // Используем Dapper для прямого SQL-запроса
        var query = $"SELECT * FROM {tableName} WHERE TransactionDate BETWEEN @From AND @To";
        
        using (var connection = new SqlConnection(_connectionString))
        {
            var transactions = await connection.QueryAsync<Transaction>(
                query,
                new { From = from, To = to }
            );
            
            result.AddRange(transactions);
        }
    }
    
    return result;
}

// Объявляем компилированный запрос как статическое поле
private static readonly Func<ApplicationDbContext, int, Task<Customer>> GetCustomerById = 
    EF.CompileAsyncQuery((ApplicationDbContext context, int id) => 
        context.Customers.FirstOrDefault(c => c.Id == id));
 
// Используем
public async Task<Customer> GetCustomer(int id)
{
    using var context = new ApplicationDbContext();
    return await GetCustomerById(context, id);
}

// Антипаттерн при массовых операциях
foreach (var item in items)
{
    context.Items.Add(item);
    await context.SaveChangesAsync(); // Каждый раз новая транзакция!
}

// Правильный подход
foreach (var item in items)
{
    context.Items.Add(item);
    
    // Сохраняем изменения пакетами по 100 элементов
    if (items.IndexOf(item) % 100 == 99)
    {
        await context.SaveChangesAsync();
    }
}
 
// Не забываем сохранить оставшиеся изменения
if (items.Count % 100 != 0)
{
    await context.SaveChangesAsync();
}

public async Task BulkInsertCustomersAsync(List<Customer> customers)
{
    // Преобразуем список объектов в DataTable
    var dataTable = new DataTable();
    dataTable.Columns.Add("Id", typeof(int));
    dataTable.Columns.Add("Name", typeof(string));
    dataTable.Columns.Add("Email", typeof(string));
    // Другие колонки...
    
    foreach (var customer in customers)
    {
        dataTable.Rows.Add(customer.Id, customer.Name, customer.Email /*, ...*/);
    }
    
    // Используем SqlBulkCopy для массовой вставки
    using (var connection = new SqlConnection(_connectionString))
    {
        await connection.OpenAsync();
        using (var bulkCopy = new SqlBulkCopy(connection))
        {
            bulkCopy.DestinationTableName = "Customers";
            bulkCopy.BatchSize = 1000;
            
            bulkCopy.ColumnMappings.Add("Id", "Id");
            bulkCopy.ColumnMappings.Add("Name", "Name");
            bulkCopy.ColumnMappings.Add("Email", "Email");
            // Другие маппинги...
            
            await bulkCopy.WriteToServerAsync(dataTable);
        }
    }
}

public async Task<List<Product>> GetProductsByIdsAsync(List<int> ids)
{
    var idTable = new DataTable();
    idTable.Columns.Add("Id", typeof(int));
    
    foreach (var id in ids)
    {
        idTable.Rows.Add(id);
    }
    
    using (var connection = new SqlConnection(_connectionString))
    {
        await connection.OpenAsync();
        using (var command = new SqlCommand("GetProductsByIds", connection))
        {
            command.CommandType = CommandType.StoredProcedure;
            
            var parameter = command.Parameters.AddWithValue("@Ids", idTable);
            parameter.SqlDbType = SqlDbType.Structured;
            parameter.TypeName = "dbo.IdList";
            
            using (var reader = await command.ExecuteReaderAsync())
            {
                var products = new List<Product>();
                while (await reader.ReadAsync())
                {
                    products.Add(new Product
                    {
                        Id = reader.GetInt32(reader.GetOrdinal("Id")),
                        Name = reader.GetString(reader.GetOrdinal("Name")),
                        // Другие поля...
                    });
                }
                return products;
            }
        }
    }
}

public async Task<List<Product>> GetProductsByIdsAsync(List<int> ids)
{
    var idTable = new DataTable();
    idTable.Columns.Add("Id", typeof(int));
    
    foreach (var id in ids)
    {
        idTable.Rows.Add(id);
    }
    
    using (var connection = new SqlConnection(_connectionString))
    {
        await connection.OpenAsync();
        
        var products = await connection.QueryAsync<Product>(
            "GetProductsByIds",
            new { Ids = idTable.AsTableValuedParameter("dbo.IdList") },
            commandType: CommandType.StoredProcedure
        );
        
        return products.ToList();
    }
}

await context.Customers
    .Where(c => c.LastOrderDate < DateTime.UtcNow.AddYears(-1))
    .ExecuteUpdateAsync(s => s
        .SetProperty(c => c.Status, c => "Inactive")
        .SetProperty(c => c.UpdatedDate, c => DateTime.UtcNow));

var customers = await context.Customers
    .FromSqlRaw("EXEC GetCustomersByRegion @Region", 
    new SqlParameter("@Region", "North"))
    .ToListAsync();

public async Task<(Customer customer, List<Order> orders)> GetCustomerWithOrdersAsync(int customerId)
{
    using var connection = new SqlConnection(_connectionString);
    await connection.OpenAsync();
    
    using var multi = await connection.QueryMultipleAsync(
        "GetCustomerWithOrders",
        new { CustomerId = customerId },
        commandType: CommandType.StoredProcedure);
    
    var customer = await multi.ReadFirstOrDefaultAsync<Customer>();
    var orders = (await multi.ReadAsync<Order>()).ToList();
    
    return (customer, orders);
}

public async Task<bool> TransferFundsAsync(int fromAccountId, int toAccountId, decimal amount)
{
    using var transaction = await _context.Database.BeginTransactionAsync();
    try
    {
        var fromAccount = await _context.Accounts.FindAsync(fromAccountId);
        var toAccount = await _context.Accounts.FindAsync(toAccountId);
        
        if (fromAccount.Balance < amount)
            return false;
        
        fromAccount.Balance -= amount;
        toAccount.Balance += amount;
        
        // Создаем записи в истории транзакций
        var transactionRecord = new TransactionRecord
        {
            FromAccountId = fromAccountId,
            ToAccountId = toAccountId,
            Amount = amount,
            Date = DateTime.UtcNow
        };
        
        _context.TransactionRecords.Add(transactionRecord);
        
        await _context.SaveChangesAsync();
        await transaction.CommitAsync();
        
        return true;
    }
    catch (Exception)
    {
        await transaction.RollbackAsync();
        throw;
    }
}

using (var scope = new TransactionScope(
    TransactionScopeOption.Required,
    new TransactionOptions { IsolationLevel = IsolationLevel.ReadCommitted },
    TransactionScopeAsyncFlowOption.Enabled))
{
    // Асинхронные операции с БД
    await _context.SaveChangesAsync();
    
    scope.Complete();
}

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Attributes { get; set; } // JSON строка
}
 
// В OnModelCreating
modelBuilder.Entity<Product>()
    .Property(p => p.Attributes)
    .HasColumnType("nvarchar(max)");
 
// Использование
var products = await context.Products
    .Where(p => EF.Functions.JsonContains(p.Attributes, @"{""color"": ""red""}"))
    .ToListAsync();

var products = await context.Products
    .FromSqlRaw(@"
        SELECT * FROM Products 
        WHERE JSON_VALUE(Attributes, '$.dimensions.width') > 100
        AND JSON_VALUE(Attributes, '$.dimensions.height') > 50")
    .ToListAsync();

// Неоптимально: начинает с неиндексированного поля
var customers = await context.Customers
    .Where(c => c.Name.Contains("Smith") && c.Region == "North")
    .ToListAsync();
 
// Лучше: сначала фильтр по индексированному полю
var customers = await context.Customers
    .Where(c => c.Region == "North") // Индексированное поле
    .Where(c => c.Name.Contains("Smith"))
    .ToListAsync();

// Плохо: не всегда использует индекс
var product = await context.Products
    .Where(p => p.Id == productId)
    .FirstOrDefaultAsync();
 
// Лучше: гарантированно использует первичный ключ
var product = await context.Products
    .FindAsync(productId);

// Плохо: не использует индекс по Date
var orders = await context.Orders
    .Where(o => o.Date.Year == 2023)
    .ToListAsync();
 
// Лучше: явно указываем диапазон для использования индекса
var startDate = new DateTime(2023, 1, 1);
var endDate = new DateTime(2024, 1, 1);
var orders = await context.Orders
    .Where(o => o.Date >= startDate && o.Date < endDate)
    .ToListAsync();

var salesReport = await context.SalesReports
    .FromSqlRaw(@"
        SELECT 
            s.ProductId,
            s.Date,
            s.Amount,
            SUM(s.Amount) OVER (PARTITION BY s.ProductId) AS TotalProductSales,
            ROW_NUMBER() OVER (PARTITION BY s.ProductId ORDER BY s.Amount DESC) AS Rank
        FROM Sales s
        WHERE s.Date >= @StartDate AND s.Date <= @EndDate",
        new SqlParameter("@StartDate", startDate),
        new SqlParameter("@EndDate", endDate))
    .ToListAsync();

// Антипаттерн: загружаем все поля
var customers = await _context.Customers
    .Where(c => c.Region == "North")
    .ToListAsync();

// Оптимальный подход: загружаем только нужные поля
var customerDtos = await _context.Customers
    .Where(c => c.Region == "North")
    .Select(c => new CustomerSummaryDto
    {
        Id = c.Id,
        FullName = c.FirstName + " " + c.LastName,
        Email = c.Email
    })
    .ToListAsync();

// Очень плохая пагинация
var pagedCustomers = await _context.Customers
    .OrderBy(c => c.LastName)
    .Skip((pageNumber - 1) * pageSize)
    .Take(pageSize)
    .ToListAsync();

public async Task<(List<Customer> items, int totalCount)> GetCustomersPagedAsync(
    int pageNumber, int pageSize, string searchTerm = null)
{
    IQueryable<Customer> query = _context.Customers;
    
    if (!string.IsNullOrEmpty(searchTerm))
    {
        query = query.Where(c => c.LastName.Contains(searchTerm) ||
                                c.FirstName.Contains(searchTerm) ||
                                c.Email.Contains(searchTerm));
    }
    
    // Получаем общее количество записей для корректного построения пагинации
    // Используем оптимизированный запрос для подсчета
    var totalCount = await query.CountAsync();
    
    // Если страница слишком большая, возвращаем последнюю доступную
    var totalPages = (int)Math.Ceiling(totalCount / (double)pageSize);
    if (pageNumber > totalPages)
    {
        pageNumber = totalPages;
    }
    
    // Используем оконную функцию для эффективной пагинации
    var items = await query
        .OrderBy(c => c.LastName)
        .ThenBy(c => c.FirstName)
        .Select(c => new 
        { 
            Customer = c,
            RowNum = EF.Functions.RowNumber(
                over: o => o.OrderBy(x => x.LastName).ThenBy(x => x.FirstName))
        })
        .Where(x => x.RowNum > (pageNumber - 1) * pageSize && 
                   x.RowNum <= pageNumber * pageSize)
        .Select(x => x.Customer)
        .ToListAsync();
    
    return (items, totalCount);
}

var sql = @"
    WITH NumberedCustomers AS (
        SELECT *, ROW_NUMBER() OVER (ORDER BY LastName, FirstName) AS RowNum
        FROM Customers
        WHERE (@SearchTerm IS NULL OR 
              LastName LIKE '%' + @SearchTerm + '%' OR 
              FirstName LIKE '%' + @SearchTerm + '%' OR 
              Email LIKE '%' + @SearchTerm + '%')
    )
    SELECT * FROM NumberedCustomers 
    WHERE RowNum BETWEEN @Skip + 1 AND @Skip + @Take";
 
var customers = await connection.QueryAsync<Customer>(sql, new { 
    SearchTerm = searchTerm, 
    Skip = (pageNumber - 1) * pageSize, 
    Take = pageSize 
});

// До 5 раз быстрее для больших наборов данных
var products = await _context.Products
    .AsNoTracking()
    .Where(p => p.Category == "Electronics")
    .ToListAsync();

public class HybridRepository
{
    private readonly ApplicationDbContext _context;
    
    public HybridRepository(ApplicationDbContext context)
    {
        _context = context;
    }
    
    // Используем EF для стандартных операций
    public async Task<Customer> GetCustomerByIdAsync(int id)
    {
        return await _context.Customers.FindAsync(id);
    }
    
    // Используем Dapper для сложных запросов
    public async Task<List<SalesReportDto>> GetSalesReportAsync(DateTime start, DateTime end)
    {
        var query = @"
            SELECT 
                p.Name AS ProductName,
                c.Name AS CategoryName,
                SUM(s.Quantity) AS TotalQuantity,
                SUM(s.Quantity * s.UnitPrice) AS TotalRevenue,
                COUNT(DISTINCT s.CustomerId) AS UniqueCustomers
            FROM Sales s
            JOIN Products p ON s.ProductId = p.Id
            JOIN Categories c ON p.CategoryId = c.Id
            WHERE s.Date BETWEEN @Start AND @End
            GROUP BY p.Name, c.Name
            ORDER BY TotalRevenue DESC";
        
        // Используем соединение из контекста EF
        var connection = _context.Database.GetDbConnection();
        
        return (await connection.QueryAsync<SalesReportDto>(
            query,
            new { Start = start, End = end }
        )).ToList();
    }
}

public async Task<List<Product>> FindProductsAsync(
    string nameFragment = null,
    decimal? minPrice = null,
    decimal? maxPrice = null,
    List<string> categories = null)
{
    // Начинаем с базового выражения (всегда истинно)
    Expression<Func<Product, bool>> filter = p => true;
    
    // Динамически добавляем условия
    if (!string.IsNullOrEmpty(nameFragment))
    {
        filter = CombineFilters(filter, p => p.Name.Contains(nameFragment));
    }
    
    if (minPrice.HasValue)
    {
        filter = CombineFilters(filter, p => p.Price >= minPrice.Value);
    }
    
    if (maxPrice.HasValue)
    {
        filter = CombineFilters(filter, p => p.Price <= maxPrice.Value);
    }
    
    if (categories != null && categories.Any())
    {
        filter = CombineFilters(filter, p => categories.Contains(p.Category));
    }
    
    // Применяем собранное выражение
    return await _context.Products
        .Where(filter)
        .ToListAsync();
}
 
// Метод для комбинирования выражений с логическим AND
private Expression<Func<T, bool>> CombineFilters<T>(
    Expression<Func<T, bool>> filter1,
    Expression<Func<T, bool>> filter2)
{
    var parameter = Expression.Parameter(typeof(T));
    
    var leftVisitor = new ReplaceExpressionVisitor(
        filter1.Parameters[0], parameter);
    var left = leftVisitor.Visit(filter1.Body);
    
    var rightVisitor = new ReplaceExpressionVisitor(
        filter2.Parameters[0], parameter);
    var right = rightVisitor.Visit(filter2.Body);
    
    return Expression.Lambda<Func<T, bool>>(
        Expression.AndAlso(left, right), parameter);
}
 
private class ReplaceExpressionVisitor : ExpressionVisitor
{
    private readonly Expression _oldValue;
    private readonly Expression _newValue;
    
    public ReplaceExpressionVisitor(Expression oldValue, Expression newValue)
    {
        _oldValue = oldValue;
        _newValue = newValue;
    }
    
    public override Expression Visit(Expression node)
    {
        if (node == _oldValue)
            return _newValue;
        
        return base.Visit(node);
    }
}

// Простая реализация Circuit Breaker
public class DbCircuitBreaker
{
    private int _failureCount = 0;
    private DateTime _lastFailureTime = DateTime.MinValue;
    private readonly int _failureThreshold;
    private readonly TimeSpan _resetTimeout;
    private bool _isOpen = false;
 
    public DbCircuitBreaker(int failureThreshold = 3, int resetTimeoutSeconds = 30)
    {
        _failureThreshold = failureThreshold;
        _resetTimeout = TimeSpan.FromSeconds(resetTimeoutSeconds);
    }
 
    public async Task<T> ExecuteAsync<T>(Func<Task<T>> operation)
    {
        if (_isOpen)
        {
            // Проверяем, можно ли попробовать восстановить цепь
            if (DateTime.UtcNow - _lastFailureTime > _resetTimeout)
            {
                _isOpen = false; // Полуоткрытое состояние
            }
            else
            {
                throw new CircuitBreakerOpenException("Соединение с БД временно недоступно");
            }
        }
 
        try
        {
            var result = await operation();
            // Успешное выполнение - сбрасываем счетчик ошибок
            _failureCount = 0;
            return result;
        }
        catch (Exception ex)
        {
            _lastFailureTime = DateTime.UtcNow;
            _failureCount++;
 
            if (_failureCount >= _failureThreshold)
            {
                _isOpen = true; // Открываем цепь
            }
 
            throw; // Пробрасываем исключение дальше
        }
    }
}

public class CachedRepository<T> where T : class
{
    private readonly IRepository<T> _repository;
    private readonly IMemoryCache _cache;
    private readonly TimeSpan _cacheDuration;
 
    public CachedRepository(
        IRepository<T> repository, 
        IMemoryCache cache,
        TimeSpan? cacheDuration = null)
    {
        _repository = repository;
        _cache = cache;
        _cacheDuration = cacheDuration ?? TimeSpan.FromMinutes(10);
    }
 
    public async Task<T> GetByIdAsync(int id)
    {
        string cacheKey = $"{typeof(T).Name}_{id}";
        
        if (!_cache.TryGetValue(cacheKey, out T entity))
        {
            entity = await _repository.GetByIdAsync(id);
            
            if (entity != null)
            {
                var cacheOptions = new MemoryCacheEntryOptions()
                    .SetAbsoluteExpiration(_cacheDuration)
                    .SetSlidingExpiration(TimeSpan.FromMinutes(2))
                    .SetSize(1); // Для отслеживания размера кэша
                
                _cache.Set(cacheKey, entity, cacheOptions);
            }
        }
        
        return entity;
    }
 
    // Другие методы репозитория с кэшированием
}

public class CacheInvalidationService
{
    private readonly IMemoryCache _cache;
    private readonly ILogger<CacheInvalidationService> _logger;
 
    public CacheInvalidationService(IMemoryCache cache, ILogger<CacheInvalidationService> logger)
    {
        _cache = cache;
        _logger = logger;
    }
 
    public void InvalidateEntity<T>(int id)
    {
        string cacheKey = $"{typeof(T).Name}_{id}";
        _cache.Remove(cacheKey);
        _logger.LogDebug($"Кэш для {cacheKey} инвалидирован");
    }
 
    public void InvalidateCollection<T>(string collectionKey = null)
    {
        string cacheKey = collectionKey ?? $"{typeof(T).Name}_List";
        _cache.Remove(cacheKey);
        _logger.LogDebug($"Кэш для коллекции {cacheKey} инвалидирован");
    }
}

public class DatabaseHealthMonitor : IHostedService
{
    private readonly IServiceProvider _services;
    private readonly ILogger<DatabaseHealthMonitor> _logger;
    private Timer _timer;
 
    public DatabaseHealthMonitor(
        IServiceProvider services,
        ILogger<DatabaseHealthMonitor> logger)
    {
        _services = services;
        _logger = logger;
    }
 
    public Task StartAsync(CancellationToken cancellationToken)
    {
        _timer = new Timer(CheckHealth, null, TimeSpan.Zero, TimeSpan.FromMinutes(5));
        return Task.CompletedTask;
    }
 
    private async void CheckHealth(object state)
    {
        try
        {
            using var scope = _services.CreateScope();
            var db = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
            
            // Проверка времени отклика
            var stopwatch = Stopwatch.StartNew();
            await db.Database.ExecuteSqlRawAsync("SELECT 1");
            stopwatch.Stop();
            
            _logger.LogInformation($"Время отклика БД: {stopwatch.ElapsedMilliseconds}мс");
            
            // Другие проверки здоровья...
            // Например, количество соединений, размер БД и т.д.
            
            // Проверка процента занятого места на диске
            var dbSizeInfo = await db.Database.ExecuteSqlRawAsync(@"
                SELECT 
                    (SUM(size) * 8) / 1024 AS 'SizeInMB',
                    (SUM(size) * 8) / 1024 / 1024 AS 'SizeInGB'
                FROM sys.database_files");
            
            // Отправка метрик в систему мониторинга
            // ...
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка проверки здоровья БД");
        }
    }
 
    public Task StopAsync(CancellationToken cancellationToken)
    {
        _timer?.Change(Timeout.Infinite, 0);
        return Task.CompletedTask;
    }
}

public async Task<T> ExecuteWithRetryAsync<T>(Func<Task<T>> operation)
{
    int maxRetries = 3;
    int currentRetry = 0;
    TimeSpan delay = TimeSpan.FromMilliseconds(200);
 
    while (true)
    {
        try
        {
            return await operation();
        }
        catch (SqlException ex) when (IsTransientError(ex.Number) && currentRetry < maxRetries)
        {
            currentRetry++;
            _logger.LogWarning($"Транзиентная ошибка БД: {ex.Message}. Повторная попытка {currentRetry} из {maxRetries}");
            
            // Экспоненциальное увеличение задержки
            await Task.Delay(delay);
            delay = TimeSpan.FromMilliseconds(delay.TotalMilliseconds * 2);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Необрабатываемая ошибка при работе с БД");
            throw; // Не транзиентная ошибка - пробрасываем дальше
        }
    }
}
 
private bool IsTransientError(int errorNumber)
{
    // Коды транзиентных ошибок SQL Server
    int[] transientErrors = { 4060, 40197, 40501, 40613, 49918, 49919, 49920, 11001 };
    return transientErrors.Contains(errorNumber);
}

services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(connectionString, sqlOptions =>
    {
        sqlOptions.EnableRetryOnFailure(
            maxRetryCount: 5,
            maxRetryDelay: TimeSpan.FromSeconds(30),
            errorNumbersToAdd: null);
    }));

public class RedisRepository<T> where T : class
{
    private readonly IRepository<T> _repository;
    private readonly IDatabase _redisDb;
    private readonly TimeSpan _cacheDuration;
    
    public RedisRepository(
        IRepository<T> repository,
        IConnectionMultiplexer redisConnection,
        TimeSpan? cacheDuration = null)
    {
        _repository = repository;
        _redisDb = redisConnection.GetDatabase();
        _cacheDuration = cacheDuration ?? TimeSpan.FromMinutes(10);
    }
    
    public async Task<T> GetByIdAsync(int id)
    {
        string cacheKey = $"{typeof(T).Name}:{id}";
        
        // Пробуем получить из кэша
        var cachedValue = await _redisDb.StringGetAsync(cacheKey);
        if (cachedValue.HasValue)
        {
            return JsonSerializer.Deserialize<T>(cachedValue);
        }
        
        // Если в кэше нет - получаем из БД
        var entity = await _repository.GetByIdAsync(id);
        if (entity != null)
        {
            var serialized = JsonSerializer.Serialize(entity);
            await _redisDb.StringSetAsync(
                cacheKey, 
                serialized, 
                _cacheDuration, 
                When.Always);
        }
        
        return entity;
    }
}

public class RedisInvalidationService
{
    private readonly IConnectionMultiplexer _redis;
    private readonly ISubscriber _subscriber;
    private readonly string _appInstanceId;
    
    public RedisInvalidationService(IConnectionMultiplexer redis)
    {
        _redis = redis;
        _subscriber = redis.GetSubscriber();
        _appInstanceId = Guid.NewGuid().ToString("N");
        
        // Подписываемся на события инвалидации
        _subscriber.Subscribe("cache:invalidate", OnInvalidationMessage);
    }
    
    public async Task InvalidateEntityAsync<T>(int id)
    {
        string cacheKey = $"{typeof(T).Name}:{id}";
        
        // Удаляем из локального кэша текущего экземпляра
        await _redis.GetDatabase().KeyDeleteAsync(cacheKey);
        
        // Уведомляем другие экземпляры
        await _subscriber.PublishAsync("cache:invalidate", 
            JsonSerializer.Serialize(new {
                Source = _appInstanceId,
                Key = cacheKey
            }));
    }
    
    private void OnInvalidationMessage(RedisChannel channel, RedisValue message)
    {
        var invalidation = JsonSerializer.Deserialize<dynamic>(message);
        
        // Игнорируем сообщения от себя же
        if (invalidation.Source == _appInstanceId)
            return;
            
        // Инвалидируем локальный кэш
        _redis.GetDatabase().KeyDeleteAsync(invalidation.Key);
    }
}

public class SqlProfilerMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<SqlProfilerMiddleware> _logger;
    
    public SqlProfilerMiddleware(
        RequestDelegate next,
        ILogger<SqlProfilerMiddleware> logger)
    {
        _next = next;
        _logger = logger;
    }
    
    public async Task InvokeAsync(HttpContext context, ApplicationDbContext dbContext)
    {
        // Подписываемся на события выполнения команд
        var diagnosticSource = dbContext.GetService<DiagnosticSource>();
        using var listener = new SqlCommandListener(_logger);
        
        await _next(context);
        
        // Анализируем собранные данные
        if (listener.SlowQueries.Any())
        {
            foreach (var query in listener.SlowQueries)
            {
                _logger.LogWarning(
                    "Медленный запрос: {Query} - {Duration}мс", 
                    query.CommandText, 
                    query.Duration.TotalMilliseconds);
            }
        }
    }
}
 
public class SqlCommandListener : IObserver<DiagnosticListener>
{
    private readonly ILogger _logger;
    public List<SlowQueryInfo> SlowQueries { get; } = new();
    
    public SqlCommandListener(ILogger logger)
    {
        _logger = logger;
    }
    
    // Имплементация IObserver<DiagnosticListener>
    // ...
    
    private void OnSqlCommandExecuted(string commandText, TimeSpan duration)
    {
        if (duration.TotalMilliseconds > 500) // Порог для "медленных" запросов
        {
            SlowQueries.Add(new SlowQueryInfo
            {
                CommandText = commandText,
                Duration = duration
            });
        }
    }
}

public class ReadWriteConnectionFactory
{
    private readonly string _writeConnectionString;
    private readonly List<string> _readConnectionStrings;
    private int _currentReadIndex = 0;
    private readonly object _lock = new();
    
    public ReadWriteConnectionFactory(
        string writeConnectionString, 
        List<string> readConnectionStrings)
    {
        _writeConnectionString = writeConnectionString;
        _readConnectionStrings = readConnectionStrings;
    }
    
    public SqlConnection CreateReadConnection()
    {
        if (_readConnectionStrings.Count == 0)
            return CreateWriteConnection();
            
        string connectionString;
        lock (_lock)
        {
            connectionString = _readConnectionStrings[_currentReadIndex];
            _currentReadIndex = (_currentReadIndex + 1) % _readConnectionStrings.Count;
        }
        
        return new SqlConnection(connectionString);
    }
    
    public SqlConnection CreateWriteConnection()
    {
        return new SqlConnection(_writeConnectionString);
    }
}

public class ReadDbContext : ApplicationDbContext
{
    public ReadDbContext(DbContextOptions<ApplicationDbContext> options) 
        : base(options)
    {
        // Все запросы по умолчанию без отслеживания
        ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking;
    }
    
    // Запрещаем операции изменения
    public override int SaveChanges() => 
        throw new InvalidOperationException("ReadDbContext не поддерживает сохранение изменений");
    
    public override Task<int> SaveChangesAsync(CancellationToken cancellationToken = default) => 
        throw new InvalidOperationException("ReadDbContext не поддерживает сохранение изменений");
}

public class DatabaseMetrics
{
    private readonly Counter _totalQueries;
    private readonly Histogram _queryDuration;
    private readonly Gauge _activeConnections;
    
    public DatabaseMetrics(IMetricFactory metricFactory)
    {
        _totalQueries = metricFactory.CreateCounter(
            "db_queries_total", 
            "Общее количество запросов к БД",
            new CounterConfiguration { 
                LabelNames = new[] { "type", "status" } 
            });
            
        _queryDuration = metricFactory.CreateHistogram(
            "db_query_duration_seconds",
            "Длительность выполнения запросов",
            new HistogramConfiguration {
                LabelNames = new[] { "type" },
                Buckets = Histogram.ExponentialBuckets(0.001, 2, 10) // от 1мс до ~1с
            });
            
        _activeConnections = metricFactory.CreateGauge(
            "db_active_connections",
            "Количество активных соединений с БД"
        );
    }
    
    public void RecordQuery(string type, TimeSpan duration, bool success)
    {
        _totalQueries.WithLabels(type, success ? "success" : "failure").Inc();
        _queryDuration.WithLabels(type).Observe(duration.TotalSeconds);
    }
    
    public void SetActiveConnections(int count)
    {
        _activeConnections.Set(count);
    }
}

// Domain Layer - бизнес-сущности
public class Order
{
    public int Id { get; set; }
    public int CustomerId { get; set; }
    public DateTime OrderDate { get; set; }
    public OrderStatus Status { get; set; }
    public decimal TotalAmount { get; set; }
    public List<OrderItem> Items { get; set; }
    
    // Бизнес-логика
    public void Calculate()
    {
        TotalAmount = Items.Sum(i => i.Quantity * i.UnitPrice);
    }
}
 
// Data Access Layer - EF Core + Dapper
public class OrderRepository : IOrderRepository
{
    private readonly AppDbContext _context;
    private readonly IDbConnection _connection;
 
    public OrderRepository(AppDbContext context, IDbConnectionFactory connectionFactory)
    {
        _context = context;
        _connection = connectionFactory.CreateConnection();
    }
    
    // EF Core для простых операций
    public async Task<Order> GetByIdAsync(int id)
    {
        return await _context.Orders
            .AsNoTracking()
            .Include(o => o.Items)
            .FirstOrDefaultAsync(o => o.Id == id);
    }
    
    // Dapper для сложных запросов
    public async Task<List<OrderSummaryDto>> GetOrdersWithFilterAsync(OrderFilterDto filter)
    {
        var query = @"
            SELECT o.Id, o.OrderDate, c.Name as CustomerName, o.TotalAmount,
                   COUNT(i.Id) AS ItemCount
            FROM Orders o
            JOIN Customers c ON o.CustomerId = c.Id
            JOIN OrderItems i ON o.Id = i.OrderId
            WHERE (@StartDate IS NULL OR o.OrderDate >= @StartDate)
              AND (@EndDate IS NULL OR o.OrderDate <= @EndDate)
              AND (@Status IS NULL OR o.Status = @Status)
            GROUP BY o.Id, o.OrderDate, c.Name, o.TotalAmount
            ORDER BY o.OrderDate DESC
            OFFSET @Skip ROWS
            FETCH NEXT @Take ROWS ONLY";
            
        return (await _connection.QueryAsync<OrderSummaryDto>(
            query,
            new {
                StartDate = filter.StartDate,
                EndDate = filter.EndDate,
                Status = filter.Status,
                Skip = (filter.Page - 1) * filter.PageSize,
                Take = filter.PageSize
            })).ToList();
    }
}

public static class DatabaseConfiguration
{
    public static IServiceCollection ConfigureDatabase(
        this IServiceCollection services,
        IConfiguration configuration,
        IHostEnvironment environment)
    {
        // Базовая конфигурация
        services.AddDbContext<AppDbContext>(options =>
        {
            var connectionString = configuration.GetConnectionString("DefaultConnection");
            
            options.UseSqlServer(connectionString, sqlOptions =>
            {
                // Общие настройки
                sqlOptions.EnableRetryOnFailure();
                sqlOptions.CommandTimeout(30);
                
                if (environment.IsDevelopment())
                {
                    // Для разработки - подробное логирование
                    options.EnableDetailedErrors();
                    options.EnableSensitiveDataLogging();
                }
                else if (environment.IsProduction())
                {
                    // Для продакшена - оптимизация производительности
                    sqlOptions.CommandTimeout(60);
                }
            });
        });
        
        // Регистрация фабрики соединений
        if (environment.IsProduction())
        {
            // В продакшене - разделение чтения/записи
            services.AddSingleton<IDbConnectionFactory>(sp =>
            {
                var writeConnection = configuration.GetConnectionString("WriteConnection");
                var readConnections = configuration.GetSection("ReadConnections")
                    .Get<List<string>>();
                    
                return new ReadWriteConnectionFactory(writeConnection, readConnections);
            });
        }
        else
        {
            // В других средах - одно соединение
            services.AddSingleton<IDbConnectionFactory>(sp =>
                new SingleConnectionFactory(
                    configuration.GetConnectionString("DefaultConnection")));
        }
        
        return services;
    }
}

public class OrderRepositoryTests : IClassFixture<DatabaseFixture>
{
    private readonly DatabaseFixture _fixture;
    
    public OrderRepositoryTests(DatabaseFixture fixture)
    {
        _fixture = fixture;
    }
    
    [Fact]
    public async Task GetOrdersWithFilter_ReturnsCorrectData()
    {
        // Arrange
        await _fixture.SeedTestDataAsync();
        var repository = new OrderRepository(_fixture.Context, _fixture.ConnectionFactory);
        var filter = new OrderFilterDto
        {
            StartDate = DateTime.UtcNow.AddDays(-7),
            Status = OrderStatus.Completed,
            Page = 1,
            PageSize = 10
        };
        
        // Act
        var results = await repository.GetOrdersWithFilterAsync(filter);
        
        // Assert
        Assert.NotEmpty(results);
        Assert.All(results, r => Assert.Equal(OrderStatus.Completed.ToString(), r.Status));
    }
}