EF Core控制器中实体被方法修改后如何保留手动更新？

问题场景 #

我有一个名为Save的Action，负责从数据库加载Order实体并应用用户的修改。每次执行这个Action时都会调用UpdateOrderStates方法，但出现了问题：手动在Action中对实体的修改会被该方法覆盖，无法保留。

代码示例 #

public IActionResult Save(MyViewModel model){
 var order = context.Orders....
 
 if(model.MyState !=null && model.MyState !=order.MyState){
  order.MyState=model.MyState;
 }
 //更多操作....

    await workflow.UpdateOrderStates(model.orderId);
   //context.Update(order);
    context.Entry(order).State = EntityState.Modified;
    await context.SaveChangesAsync();
}

 public async Task UpdateOrderStates(int orderId){
   var order = context.Orders....
   var subOrders = order.SubOrders;
   var subOrdersStateAll = subOrders.All(x=>x.MyState=="DONE");
  //.....
   if(subOrdersStateAll) order.MyState ="DONE"; //存在更多状态及对应逻辑

  context.Update(order);
  await context.SaveChangesAsync();
}

现象 #

在Action的if语句中更新order.MyState后，调用UpdateOrderStates方法会将该值重置为方法中设置的状态，即使设置EntityState.Modified也无效。

问题1：如何保留Action中获取的实体对象，不受方法修改的影响？ #

核心原因是EF Core的上下文跟踪机制：Save里加载的order和UpdateOrderStates中重新查询的order属于同一个上下文实例的同一实体，后者的内存修改会直接覆盖前者的变更。解决思路是让两个逻辑复用同一个实体实例，避免重复查询：

解决方案代码 #

1. 修改UpdateOrderStates方法，直接接收已加载的Order实体作为参数：

public async Task UpdateOrderStates(Order order)
{
    // 直接使用传入的实体，无需重新查询数据库
    var subOrders = order.SubOrders;
    var subOrdersStateAll = subOrders.All(x => x.MyState == "DONE");
    // 其他状态判断逻辑...
    
    if (subOrdersStateAll)
    {
        order.MyState = "DONE";
    }

    // 移除内部的SaveChanges，交给上层统一处理
    // await context.SaveChangesAsync();
}

2. 在SaveAction中传入已加载的实体调用方法：

public async Task<IActionResult> Save(MyViewModel model)
{
    var order = context.Orders.FirstOrDefault(o => o.Id == model.orderId);
    
    if(model.MyState != null && model.MyState != order.MyState)
    {
        order.MyState = model.MyState;
    }
    // 更多操作....

    // 传入已加载的实体，避免重新查询导致的覆盖
    await workflow.UpdateOrderStates(order);
    
    await context.SaveChangesAsync();
    return Ok();
}

问题2：如何实现手动修改与自动修改协同工作？ #

要让用户手动修改优先、自动状态更新仅在无手动干预时生效，核心是标记状态是否被用户手动修改，在自动更新逻辑中跳过已手动修改的状态。

解决方案代码 #

方式1：通过方法参数传递标记

1. 在SaveAction中记录是否手动修改了状态：

public async Task<IActionResult> Save(MyViewModel model)
{
    var order = context.Orders.FirstOrDefault(o => o.Id == model.orderId);
    bool isStateManuallyModified = false;
    
    if(model.MyState != null && model.MyState != order.MyState)
    {
        order.MyState = model.MyState;
        isStateManuallyModified = true; // 标记状态被手动修改
    }
    // 更多操作....

    await workflow.UpdateOrderStates(order, isStateManuallyModified);
    await context.SaveChangesAsync();
    return Ok();
}

2. 修改UpdateOrderStates方法，根据标记判断是否执行自动更新：

public async Task UpdateOrderStates(Order order, bool isStateManuallyModified)
{
    var subOrdersStateAll = order.SubOrders.All(x => x.MyState == "DONE");
    // 其他状态判断逻辑...

    // 仅当用户未手动修改状态时，才执行自动更新
    if (!isStateManuallyModified && subOrdersStateAll)
    {
        order.MyState = "DONE";
    }
    // 其他状态分支同理，都加上!isStateManuallyModified判断
}

方式2：通过实体临时属性标记（适合方法被多处调用的场景）

如果UpdateOrderStates被多处调用，不想每次都传递标记参数，可以给Order实体添加一个不映射到数据库的临时属性：

// 在Order实体中添加临时属性
[NotMapped]
public bool IsStateManuallySet { get; set; }

然后在SaveAction中设置标记：

if(model.MyState != null && model.MyState != order.MyState)
{
    order.MyState = model.MyState;
    order.IsStateManuallySet = true;
}

最后修改UpdateOrderStates方法：

public async Task UpdateOrderStates(Order order)
{
    var subOrdersStateAll = order.SubOrders.All(x => x.MyState == "DONE");
    // 仅当未被手动设置状态时，执行自动更新
    if (!order.IsStateManuallySet && subOrdersStateAll)
    {
        order.MyState = "DONE";
    }
    // 其他状态分支同理
}

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