Blazor Server中EF Core短生命周期DbContext下的变更追踪问题咨询

在使用IDbContextFactory创建短生命周期DbContext时，查询返回的实体会脱离原上下文的变更追踪。编辑后直接Attach无法自动标记修改，使用Update又会全量更新实体及所有关联项（比如数百条订单项），造成不必要的数据库开销。以下是几种成熟的处理方案：

方案1：加载原始实体，手动合并变更 #

这是最可靠的方案，通过对比原始实体和编辑后的实体，只更新变更部分及关联项的增删改：

public class OrderService
{
    private readonly IDbContextFactory<ApplicationDbContext> _contextFactory;

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

    public Order GetById(int id)
    {
        using var context = _contextFactory.CreateDbContext();
        return context.Orders
                      .Include(o => o.Lines)
                      .ThenInclude(o => o.Product)
                      .FirstOrDefault(o => o.OrderId == id);
    }

    public void UpdateOrder(Order editedOrder)
    {
        using var context = _contextFactory.CreateDbContext();
        // 加载包含关联项的原始实体
        var originalOrder = context.Orders
            .Include(o => o.Lines)
            .FirstOrDefault(o => o.OrderId == editedOrder.OrderId);
        
        if (originalOrder == null) return;

        // 更新订单本身的标量属性（仅变更的字段会被标记为Modified）
        context.Entry(originalOrder).CurrentValues.SetValues(editedOrder);

        // 处理订单项的删除：移除原始列表中不存在于编辑后列表的项
        foreach (var originalLine in originalOrder.Lines.ToList())
        {
            if (!editedOrder.Lines.Any(l => l.LineId == originalLine.LineId))
            {
                context.OrderLines.Remove(originalLine);
            }
        }

        // 处理订单项的新增和更新
        foreach (var editedLine in editedOrder.Lines)
        {
            var originalLine = originalOrder.Lines.FirstOrDefault(l => l.LineId == editedLine.LineId);
            if (originalLine != null)
            {
                // 更新已存在的订单项
                context.Entry(originalLine).CurrentValues.SetValues(editedLine);
            }
            else
            {
                // 添加新的订单项
                originalOrder.Lines.Add(editedLine);
            }
        }

        context.SaveChanges();
    }
}

该方案的优势是精准控制变更范围，只更新实际修改的内容，避免无意义的数据库操作。

方案2：使用TrackGraph批量处理分离实体的状态 #

EF Core的TrackGraph可以遍历实体及其关联对象，手动设置每个实体的状态，适合关联关系复杂的场景：

public void UpdateOrder(Order editedOrder)
{
    using var context = _contextFactory.CreateDbContext();

    // 先将主实体附加为Unchanged状态
    context.Attach(editedOrder).State = EntityState.Unchanged;

    // 遍历实体及所有关联项，设置状态
    context.ChangeTracker.TrackGraph(editedOrder, entry =>
    {
        // 根据主键是否有值判断：主键未赋值（新增实体）设为Added，否则设为Unchanged
        entry.State = entry.IsKeySet ? EntityState.Unchanged : EntityState.Added;

        // 处理标记为删除的订单项（需前端给删除的项添加IsDeleted属性）
        if (entry.Entity is OrderLine line && line.IsDeleted)
        {
            entry.State = EntityState.Deleted;
        }
    });

    // 手动标记主实体中已修改的属性（如果明确知道哪些字段被编辑）
    // 示例：context.Entry(editedOrder).Property(o => o.CustomerName).IsModified = true;

    context.SaveChanges();
}

注意：此方案需要前端配合标记删除的关联项，或通过主键判断新增实体。若要自动识别修改，仍需对比原始实体数据。

方案3：在Blazor组件中维护变更记录，仅传递变更内容 #

如果订单关联数据量极大，可以在组件层记录具体的变更字段和关联项的增删改，只传递必要数据到服务层，避免加载完整实体：

组件层代码示例： #

private Order _originalOrder;
private Order _editedOrder;

protected override async Task OnInitializedAsync()
{
    _editedOrder = await OrderService.GetById(OrderId);
    // 深拷贝原始实体用于对比（使用Json序列化实现深拷贝，也可使用其他工具）
    _originalOrder = JsonSerializer.Deserialize<Order>(JsonSerializer.Serialize(_editedOrder));
}

// 收集变更内容
private (Dictionary<string, object> OrderChanges, List<OrderLine> AddedLines, List<OrderLine> UpdatedLines, List<int> DeletedLineIds) GetOrderChanges()
{
    var orderChanges = new Dictionary<string, object>();
    var addedLines = new List<OrderLine>();
    var updatedLines = new List<OrderLine>();
    var deletedLineIds = new List<int>();

    // 对比订单标量属性
    if (_originalOrder.CustomerName != _editedOrder.CustomerName)
        orderChanges.Add(nameof(Order.CustomerName), _editedOrder.CustomerName);
    // 其他需要跟踪的属性...

    // 处理订单项变更
    foreach (var originalLine in _originalOrder.Lines)
    {
        if (!_editedOrder.Lines.Any(l => l.LineId == originalLine.LineId))
            deletedLineIds.Add(originalLine.LineId);
    }

    foreach (var editedLine in _editedOrder.Lines)
    {
        var originalLine = _originalOrder.Lines.FirstOrDefault(l => l.LineId == editedLine.LineId);
        if (originalLine == null)
            addedLines.Add(editedLine);
        else if (!Equals(originalLine, editedLine)) // 需实现订单项的Equals方法判断是否变更
            updatedLines.Add(editedLine);
    }

    return (orderChanges, addedLines, updatedLines, deletedLineIds);
}

// 保存变更
private async Task SaveChanges()
{
    var changes = GetOrderChanges();
    await OrderService.UpdateOrderWithChanges(_editedOrder.OrderId, changes.OrderChanges, changes.AddedLines, changes.UpdatedLines, changes.DeletedLineIds);
}

服务层代码示例： #

public void UpdateOrderWithChanges(int orderId, Dictionary<string, object> orderChanges, List<OrderLine> addedLines, List<OrderLine> updatedLines, List<int> deletedLineIds)
{
    using var context = _contextFactory.CreateDbContext();
    var order = context.Orders.Find(orderId);
    if (order == null) return;

    // 更新订单变更字段
    foreach (var (propertyName, value) in orderChanges)
    {
        typeof(Order).GetProperty(propertyName)?.SetValue(order, value);
    }

    // 删除指定订单项
    foreach (var lineId in deletedLineIds)
    {
        var line = context.OrderLines.Find(lineId);
        if (line != null) context.OrderLines.Remove(line);
    }

    // 添加新订单项
    context.OrderLines.AddRange(addedLines);

    // 更新已变更的订单项
    foreach (var line in updatedLines)
    {
        var existingLine = context.OrderLines.Find(line.LineId);
        if (existingLine != null)
            context.Entry(existingLine).CurrentValues.SetValues(line);
    }

    context.SaveChanges();
}

此方案大幅减少了数据传输和数据库查询的开销，适合大数据量场景。

关于"无DbContext的变更追踪" #

EF Core的变更追踪功能完全依赖DbContext的ChangeTracker组件，官方没有提供脱离DbContext的变更追踪能力。如果不想依赖DbContext，只能自行实现类似的变更对比逻辑（如方案3所示）。

你提到的"附加到临时DbContext获取变更"的思路可行，但临时DbContext仍需用using包裹以确保资源释放，避免连接泄漏。对比下来，方案1的实现更稳定可靠，是多数场景下的首选。

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