C# и базы данных: Dapper vs EF Core 9, работа с NoSQL (Redis, MongoDB)

public class MongoAnalyticsService
{
    private readonly IMongoCollection<Order> _orders;
    
    public async Task<SalesReport> GetSalesReportAsync(DateTime from, DateTime to)
    {
        var pipeline = new BsonDocument[]
        {
            // Stage 1: Фильтрация по дате
            new BsonDocument("$match", new BsonDocument
            {
                ["order_date"] = new BsonDocument
                {
                    ["$gte"] = from,
                    ["$lte"] = to
                }
            }),
            
            // Stage 2: Разворачивание товаров
            new BsonDocument("$unwind", "$items"),
            
            // Stage 3: Группировка по категории
            new BsonDocument("$group", new BsonDocument
            {
                ["_id"] = "$items.category",
                ["total_quantity"] = new BsonDocument("$sum", "$items.quantity"),
                ["total_revenue"] = new BsonDocument("$sum", new BsonDocument
                {
                    ["$multiply"] = new BsonArray
                    {
                        "$items.price",
                        "$items.quantity"
                    }
                }),
                ["average_price"] = new BsonDocument("$avg", "$items.price"),
                ["unique_products"] = new BsonDocument("$addToSet", "$items.product_id")
            }),
            
            // Stage 4: Проекция
            new BsonDocument("$project", new BsonDocument
            {
                ["category"] = "$_id",
                ["total_quantity"] = 1,
                ["total_revenue"] = 1,
                ["average_price"] = 1,
                ["product_count"] = new BsonDocument("$size", "$unique_products"),
                ["_id"] = 0
            }),
            
            // Stage 5: Сортировка
            new BsonDocument("$sort", new BsonDocument("total_revenue", -1))
        };
        
        var results = await _orders.Aggregate<BsonDocument>(pipeline).ToListAsync();
        
        return new SalesReport
        {
            Period = $"{from:yyyy-MM-dd} to {to:yyyy-MM-dd}",
            Categories = results.Select(doc => new CategorySales
            {
                Category = doc["category"].AsString,
                TotalQuantity = doc["total_quantity"].AsInt32,
                TotalRevenue = doc["total_revenue"].AsDecimal,
                AveragePrice = doc["average_price"].AsDecimal,
                ProductCount = doc["product_count"].AsInt32
            }).ToList()
        };
    }
    
    // Текстовый поиск
    public async Task<List<Product>> SearchProductsAsync(string query)
    {
        var filter = Builders<Product>.Filter.Text(query);
        var sort = Builders<Product>.Sort
            .MetaTextScore("textScore")
            .Descending(p => p.CreatedAt);
        
        return await _products.Find(filter)
            .Sort(sort)
            .Limit(50)
            .ToListAsync();
    }
    
    // Геопространственные запросы
    public async Task<List<Store>> FindNearbyStoresAsync(double latitude, double longitude, double radiusKm)
    {
        var point = new GeoJsonPoint<GeoJson2DCoordinates>(
            new GeoJson2DCoordinates(longitude, latitude));
        
        var filter = Builders<Store>.Filter.NearSphere(
            s => s.Location, point, radiusKm * 1000); // Конвертация в метры
        
        return await _stores.Find(filter).Limit(20).ToListAsync();
    }
}

// Модель для геоданных
public class Store
{
    [BsonId]
    public ObjectId Id { get; set; }
    
    public string Name { get; set; }
    
    [BsonElement("location")]
    public GeoJsonPoint<GeoJson2DCoordinates> Location { get; set; }
    
    [BsonElement("address")]
    public string Address { get; set; }
}

4.3. Транзакции и репликация

public class MongoTransactionService
{
    private readonly IMongoClient _client;
    private readonly IMongoDatabase _database;
    
    public async Task<bool> ProcessOrderTransactionAsync(Order order)
    {
        using var session = await _client.StartSessionAsync();
        session.StartTransaction();
        
        try
        {
            var orders = _database.GetCollection<Order>("orders");
            var inventory = _database.GetCollection<Inventory>("inventory");
            
            // 1. Создание заказа
            await orders.InsertOneAsync(session, order);
            
            // 2. Обновление инвентаря для каждого товара
            foreach (var item in order.Items)
            {
                var filter = Builders<Inventory>.Filter.And(
                    Builders<Inventory>.Filter.Eq(i => i.ProductId, item.ProductId),
                    Builders<Inventory>.Filter.Gte(i => i.Quantity, item.Quantity)
                );
                
                var update = Builders<Inventory>.Update
                    .Inc(i => i.Quantity, -item.Quantity)
                    .Set(i => i.LastUpdated, DateTime.UtcNow);
                
                var result = await inventory.UpdateOneAsync(
                    session, filter, update);
                
                if (result.ModifiedCount == 0)
                {
                    throw new InsufficientInventoryException(
                        $"Недостаточно товара: {item.ProductId}");
                }
            }
            
            // 3. Запись в журнал
            var auditLog = new AuditLog
            {
                Action = "ORDER_CREATED",
                EntityId = order.Id.ToString(),
                Timestamp = DateTime.UtcNow,
                Details = new BsonDocument
                {
                    ["order_total"] = order.TotalAmount,
                    ["item_count"] = order.Items.Count
                }
            };
            
            var auditCollection = _database.GetCollection<AuditLog>("audit_logs");
            await auditCollection.InsertOneAsync(session, auditLog);
            
            // Коммит транзакции
            await session.CommitTransactionAsync();
            return true;
        }
        catch (Exception ex)
        {
            await session.AbortTransactionAsync();
            throw new OrderProcessingException("Ошибка обработки заказа", ex);
        }
    }
}

5. Гибридный подход: комбинирование технологий

5.1. Оптимальная архитектура для разных сценариев

public class HybridDataService
{
    private readonly ApplicationDbContext _dbContext;
    private readonly RedisService _redis;
    private readonly MongoProductRepository _mongoProducts;
    private readonly ILogger<HybridDataService> _logger;
    
    public HybridDataService(
        ApplicationDbContext dbContext,
        RedisService redis,
        MongoProductRepository mongoProducts)
    {
        _dbContext = dbContext;
        _redis = redis;
        _mongoProducts = mongoProducts;
    }
    
    // Сценарий 1: Чтение продукта с кэшированием
    public async Task<ProductDto> GetProductWithCacheAsync(int productId)
    {
        var cacheKey = $"product:{productId}";
        
        // Попытка получить из кэша
        var cached = await _redis.GetStringAsync(cacheKey);
        if (!string.IsNullOrEmpty(cached))
        {
            return JsonConvert.DeserializeObject<ProductDto>(cached);
        }
        
        // Получение из SQL (EF Core)
        var product = await _dbContext.Products
            .AsNoTracking()
            .Include(p => p.Category)
            .FirstOrDefaultAsync(p => p.Id == productId);
        
        if (product == null)
        {
            // Попытка получить из MongoDB
            var mongoProduct = await _mongoProducts.GetByIdAsync(productId.ToString());
            if (mongoProduct != null)
            {
                product = MapToEntity(mongoProduct);
            }
        }
        
        if (product == null) return null;
        
        var dto = MapToDto(product);
        
        // Кэширование на 5 минут
        await _redis.SetStringAsync(
            cacheKey, 
            JsonConvert.SerializeObject(dto), 
            TimeSpan.FromMinutes(5));
        
        return dto;
    }
    
    // Сценарий 2: Поиск с использованием подходящей БД
    public async Task<SearchResult> SearchProductsAsync(SearchRequest request)
    {
        if (request.UseFullTextSearch && request.Query.Length > 3)
        {
            // Использование MongoDB для полнотекстового поиска
            var mongoResults = await _mongoProducts.SearchProductsAsync(request.Query);
            return new SearchResult
            {
                Source = "MongoDB",
                Products = mongoResults.Select(MapToDto).ToList(),
                Total = mongoResults.Count
            };
        }
        else
        {
            // Использование SQL для структурированного поиска
            var query = _dbContext.Products.AsNoTracking();
            
            if (!string.IsNullOrEmpty(request.Category))
                query = query.Where(p => p.Category.Name == request.Category);
            
            if (request.MinPrice.HasValue)
                query = query.Where(p => p.Price >= request.MinPrice.Value);
            
            if (request.MaxPrice.HasValue)
                query = query.Where(p => p.Price <= request.MaxPrice.Value);
            
            var sqlResults = await query
                .OrderBy(p => p.Name)
                .Skip((request.Page - 1) * request.PageSize)
                .Take(request.PageSize)
                .ToListAsync();
            
            return new SearchResult
            {
                Source = "SQL Server",
                Products = sqlResults.Select(MapToDto).ToList(),
                Total = await query.CountAsync()
            };
        }
    }
    
    // Сценарий 3: Аналитика с использованием агрегаций
    public async Task<AnalyticsReport> GetAnalyticsAsync(DateTime from, DateTime to)
    {
        // Для сложных агрегаций используем MongoDB
        var salesReport = await _mongoAnalytics.GetSalesReportAsync(from, to);
        
        // Для транзакционных данных используем SQL
        var transactionStats = await _dbContext.Orders
            .Where(o => o.OrderDate >= from && o.OrderDate <= to)
            .GroupBy(o => o.Status)
            .Select(g => new
            {
                Status = g.Key,
                Count = g.Count(),
                Total = g.Sum(o => o.TotalAmount)
            })
            .ToListAsync();
        
        // Кэшируем результат в Redis на 1 час
        var report = new AnalyticsReport
        {
            Sales = salesReport,
            Transactions = transactionStats,
            GeneratedAt = DateTime.UtcNow
        };
        
        var cacheKey = $"analytics:{from:yyyyMMdd}:{to:yyyyMMdd}";
        await _redis.SetStringAsync(
            cacheKey,
            JsonConvert.SerializeObject(report),
            TimeSpan.FromHours(1));
        
        return report;
    }
}

Заключение

Выбор инструментов для работы с данными в C# приложениях — это не вопрос «что лучше», а вопрос «что больше подходит для конкретной задачи».