C# Entity Framework Core 进阶：查询优化、事务管理与批量操作实现

一、当EF Core遇见复杂场景

在真实的业务开发中，我们常会遇到需要处理十万级订单的批量更新、高并发下的数据一致性保障、复杂关联查询的性能优化等场景。作为开发者，掌握EF Core的高级特性就如同获得了一把瑞士军刀，本文将通过真实案例深度解析三大进阶技能。

1. 查询优化核心策略

① 警惕导航属性的N+1陷阱

// 反例：未经优化的关联查询
var orders = context.Orders.ToList();
foreach (var order in orders)
{
    var details = context.Entry(order)
                        .Collection(o => o.OrderDetails)
                        .Query()
                        .ToList(); // 每次循环产生新的SQL查询
}

// 正例：预先加载优化
var optimizedOrders = context.Orders
    .Include(o => o.OrderDetails) // 单个查询加载全部关联数据
    .Where(o => o.CreateDate > DateTime.Now.AddDays(-7))
    .ToList();

// 投影优化示例（EF Core 7.0）
var projections = context.Orders
    .Select(o => new 
    {
        o.OrderId,
        TotalAmount = o.OrderDetails.Sum(d => d.Quantity * d.UnitPrice),
        CustomerName = o.Customer.Name
    })
    .Take(100)
    .ToList();

技术栈：EF Core 7.0 + SQL Server

关键要点：

• Include的层级深度控制在3层以内
• 优先使用显式加载而非懒加载
• 投影查询减少数据传输量

② 异步查询的正确姿态

public async Task<PagedResult<Order>> SearchOrdersAsync(OrderSearchCriteria criteria)
{
    var query = context.Orders.AsNoTracking();
    
    // 动态条件构建
    if (!string.IsNullOrEmpty(criteria.Keyword))
    {
        query = query.Where(o => o.OrderNumber.Contains(criteria.Keyword));
    }

    // 分页执行
    var total = await query.CountAsync();
    var items = await query
                     .OrderByDescending(o => o.CreateDate)
                     .Skip((criteria.PageIndex - 1) * criteria.PageSize)
                     .Take(criteria.PageSize)
                     .ToListAsync();

    return new PagedResult<Order>(items, total);
}

最佳实践：

• 始终对分页查询进行总数统计
• 对只读查询使用AsNoTracking
• 异步方法需延续上下文生命周期管理

2. 事务管理的艺术

① 显式事务控制

using var transaction = await context.Database.BeginTransactionAsync();

try
{
    // 更新库存
    var product = await context.Products.FindAsync(productId);
    product.Stock -= quantity;
    
    // 创建订单
    var order = new Order { /* ... */ };
    context.Orders.Add(order);

    await context.SaveChangesAsync(); // 首次提交
    
    // 触发后续操作
    await _paymentService.ProcessPaymentAsync(order.Id);
    
    await transaction.CommitAsync();
}
catch
{
    await transaction.RollbackAsync();
    throw;
}

跨服务事务：

• 使用基于消息队列的最终一致性方案
• 对分布式事务采用Saga模式补偿机制

② 隐式事务的应用

using (var scope = new TransactionScope(
    TransactionScopeAsyncFlowOption.Enabled))
{
    // 跨DbContext操作
    using var db1 = new OrderContext();
    using var db2 = new InventoryContext();
    
    // 事务一致性保证
    await db1.Orders.AddAsync(order);
    await db2.Inventories.UpdateAsync(inventory);
    
    await db1.SaveChangesAsync();
    await db2.SaveChangesAsync();
    
    scope.Complete();
}

隔离级别选择指南：

• 读已提交（默认）：平衡性能与一致性
• 可重复读：防止幻读但可能引发死锁
• 序列化：最高隔离级别的性能代价

3. 批量操作性能革命

① 原生批量更新示例

// EF Core 7.0 批量更新
await context.Products
    .Where(p => p.CategoryId == 5)
    .ExecuteUpdateAsync(p => 
        p.SetProperty(x => x.Price, x => x.Price * 1.1m));

// 对比传统方式：产生多个UPDATE语句
foreach (var product in productsToUpdate)
{
    product.Price *= 1.1m;
}
await context.SaveChangesAsync();

② 分批次批量插入

var batchSize = 100;
var batches = Math.Ceiling((double)largeData.Count / batchSize);

for (int i = 0; i < batches; i++)
{
    var batch = largeData.Skip(i * batchSize).Take(batchSize);
    context.Products.AddRange(batch);
    
    await context.SaveChangesAsync();
    context.ChangeTracker.Clear(); // 清除追踪状态
    
    // 进度报告
    var progress = (i + 1) * 100 / batches;
    Console.WriteLine($"处理进度：{progress}%");
}

性能对照表：

4. 关联技术点睛：Dapper混合使用

// 复杂报表查询使用Dapper
using (var connection = new SqlConnection(connectionString))
{
    var sql = @"SELECT DATE_FORMAT(CreateDate, '%Y-%m') AS Month,
                       SUM(TotalAmount) AS Total
                FROM Orders
                GROUP BY DATE_FORMAT(CreateDate, '%Y-%m')";

    var reportData = await connection.QueryAsync<SalesReport>(sql);
}

// 保持DbContext事务一致性
using var transaction = context.Database.BeginTransaction();
try
{
    // EF Core操作
    context.Products.Update(/* ... */);

    // Dapper操作
    context.Database.GetDbConnection().Execute(
        "UPDATE Inventory SET LockCount = LockCount + 1 WHERE ProductId = @id",
        new { id = productId },
        transaction.GetDbTransaction());

    await transaction.CommitAsync();
}

混合方案优势：

• 复杂SQL直接执行
• 复用现有事务
• 保持数据一致性

二、关键决策指南

应用场景矩阵：

• 事务管理：订单创建、库存扣减等需要原子性操作
• 批量操作：数据迁移、定时任务等大规模数据处理
• 查询优化：C端用户高频访问的列表/详情页

技术选型对比：

三、避坑指南

1. 跟踪陷阱：批量操作后及时清除ChangeTracker
2. 索引缺失：通过Explain分析执行计划
3. 事务超时：合理设置CommandTimeout
4. 连接泄漏：始终使用using语句块
5. 版本兼容：注意EF Core跨版本差异

四、总结升华

通过本次探讨，我们深入掌握了EF Core在三大核心领域的进阶技巧。重要的是要理解，没有绝对的最佳实践，只有适合当前场景的最优解。在实际开发中需要平衡性能需求、团队能力和维护成本，建议通过压力测试验证不同方案的临界值。