EF Core与Blazor Server协作的变更跟踪及批量更新方案问询

背景与现有实现 #

在Blazor Server中使用EF Core时，采用依赖注入+DbContextFactory为每个操作单独创建DbContext实例是推荐实践，配置与服务实现如下：

Program.cs 配置 #

public void ConfigureServices(IServiceCollection services)
{
    services.AddDbContextFactory<ApplicationDbContext>();
}

OrderService.cs 核心实现 #

private readonly IDbContextFactory<ApplicationDbContext> _contextFactory;

public OrderService(IDbContextFactory<ApplicationDbContext> contextFactory)
{
    _contextFactory = contextFactory;
}

public async Task<Order[]> GetAllOrders()
{
    using var ctx = _contextFactory.CreateDbContext();
    return await ctx.Orders.Include(o=>o.OrderLines).ToArrayAsync();
}

核心问题 #

该模式下DbContext随操作结束被释放，丢失EF Core的变更跟踪能力。当批量编辑绑定到DataTable的订单数据时，若直接将全部500条订单传入更新方法并标记为修改状态，会导致全量更新，而我们仅需更新实际修改的20条订单，且只更新变更字段。

示例业务场景代码：

@inject OrderService _orderSerivce;

async Task DoTest()
{
    var orders = await _orderSerivce.GetAllOrders(); // 获取500条订单

    Random r = new Random();
    List<Order> modifiedOrders = new List<Order>();

    // 编辑最多20条订单，同时记录变更条目
    for(int i = 0; i < 20; i++)
    {
       int rInt = r.Next(0, orders.Length-1);
       var targetOrder = orders[rInt];
       targetOrder.CustomerName = "NameChanged " + i;
       if(!modifiedOrders.Contains(targetOrder))
           modifiedOrders.Add(targetOrder);
    }

    await _orderSerivce.UpdateOrders(modifiedOrders); // 仅传入变更条目
}

可行解决方案 #

方案1：在业务层跟踪变更条目（推荐） #

在编辑过程中维护一个变更订单集合，仅将实际修改的订单传入更新方法，避免处理全量数据。

OrderService中UpdateOrders实现

public async Task UpdateOrders(IEnumerable<Order> modifiedOrders)
{
    using var ctx = _contextFactory.CreateDbContext();
    foreach(var order in modifiedOrders)
    {
        // 附加实体并标记为已修改，EF Core会自动生成仅变更字段的SQL
        ctx.Orders.Attach(order);
        ctx.Entry(order).State = EntityState.Modified;
        // 若需更精准控制字段，可指定仅更新特定属性
        // ctx.Entry(order).Property(o => o.CustomerName).IsModified = true;
    }
    await ctx.SaveChangesAsync();
}

方案2：对比数据库原始数据，仅更新变更字段 #

若无法提前跟踪变更，可在更新方法中先从数据库获取原始数据，对比后仅标记变更字段。

OrderService中UpdateOrders实现

public async Task UpdateOrders(IEnumerable<Order> orders)
{
    using var ctx = _contextFactory.CreateDbContext();
    // 提取所有订单ID，批量查询原始数据
    var orderIds = orders.Select(o => o.Id).ToArray();
    var dbOrders = await ctx.Orders.Where(o => orderIds.Contains(o.Id)).ToDictionaryAsync(o => o.Id);

    foreach(var order in orders)
    {
        if(dbOrders.TryGetValue(order.Id, out var dbOrder))
        {
            // 对比属性，仅标记变更的字段
            if(dbOrder.CustomerName != order.CustomerName)
            {
                dbOrder.CustomerName = order.CustomerName;
                // 无需手动标记，EF Core的变更跟踪会自动识别
            }
            // 可扩展对比其他属性
        }
    }
    await ctx.SaveChangesAsync();
}

方案3：使用EF Core TrackGraph精准控制更新 #

通过TrackGraph遍历实体，自定义逻辑判断是否需要更新，适用于复杂实体关系场景。

OrderService中UpdateOrders实现

public async Task UpdateOrders(IEnumerable<Order> orders)
{
    using var ctx = _contextFactory.CreateDbContext();
    foreach(var order in orders)
    {
        ctx.ChangeTracker.TrackGraph(order, e =>
        {
            // 仅处理实际变更的实体（可结合自定义修改标记，如实体添加IsModified属性）
            if(e.Entry.Entity is Order modifiedOrder && modifiedOrder.IsModified)
            {
                e.Entry.State = EntityState.Modified;
                // 若需忽略未变更字段，可手动设置
                // e.Entry.Property(o => o.CreateTime).IsModified = false;
            }
            else
            {
                e.Entry.State = EntityState.Unchanged;
            }
        });
    }
    await ctx.SaveChangesAsync();
}

内容的提问来源于stack exchange，提问作者JamesWilliams