EF Core 6与7多级关系替换的兼容性问题及解决困境

实体模型 #

public partial class Parent
{
    public int IdParent { get; set; }

    public virtual ICollection<FirstChild> FirstChild{ get; set; } = new List<FirstChild>();
}

public partial class FirstChild
{
    public int IdFirstChild { get; set; }

    public virtual ICollection<SecondChild> SecondChild { get; set; } = new List<SecondChild>();
}

public partial class SecondChild 
{
    public int IdSecondChild  { get; set; }

    public virtual ICollection<ThirdChild> ThirdChild{ get; set; } = new List<ThirdChild>();
}

public partial class ThirdChild
{
    public int IdThirdChild { get; set; }

    public String SomeProperty{ get; set; }
}

原有更新逻辑（EF Core 6正常工作） #

通过加载实体及其所有关联层级，直接替换集合实现增删改：

var parentDB = _context.Parent.Single(x => x.IdParent == {id})
    .Include(x => x.FirstChild)
    .ThenInclude(x => x.SecondChild)
    .ThenInclude(x => x.ThirdChild);

parentDB.FirstChild = {newCollectionValuesList};

_context.SaveChanges();

EF Core 6中的预期行为 #

• 新集合中存在与原有集合ID匹配的元素：更新该元素及其所有子层级
• 新集合中不存在的元素：自动新增
• 原有集合存在但未出现在新集合中的元素：自动删除

EF Core 7升级后的问题 #

执行相同代码时出现跟踪冲突错误：

The instance of entity type 'SecondChild' cannot be tracked because another instance with the key value '{IdSecondChild: XXXX}' is already being tracked. When attaching existing entities, ensure that only one entity instance with a given key value is attached

尝试添加.AsNoTracking()解决跟踪冲突后，删除功能失效——数据库中存在但未出现在新集合中的元素不会被删除。

解决方案 #

方案1：使用Update方法处理整个实体图 #

通过无跟踪查询加载父实体，替换集合后用Update让EF自动处理增删改：

var parentDB = _context.Parent.AsNoTracking().Single(x => x.IdParent == {id});
parentDB.FirstChild = {newCollectionValuesList};
_context.Update(parentDB);
_context.SaveChanges();

此方法会让EF对比数据库状态，自动完成新增、更新和删除操作，无需手动遍历层级。

方案2：手动处理集合增删（适合需保留跟踪的场景） #

如果必须保持实体跟踪状态，可手动处理集合的增删逻辑：

var parentDB = _context.Parent
    .Include(x => x.FirstChild)
    .ThenInclude(x => x.SecondChild)
    .ThenInclude(x => x.ThirdChild)
    .Single(x => x.IdParent == {id});

// 删除不在新集合中的FirstChild
var existingFirstChildIds = parentDB.FirstChild.Select(f => f.IdFirstChild).ToList();
var newFirstChildIds = {newCollectionValuesList}.Select(f => f.IdFirstChild).ToList();
var firstChildrenToDelete = parentDB.FirstChild.Where(f => !newFirstChildIds.Contains(f.IdFirstChild)).ToList();
_context.RemoveRange(firstChildrenToDelete);

// 更新或新增FirstChild及其子实体
foreach (var newFirstChild in {newCollectionValuesList})
{
    var existingFirstChild = parentDB.FirstChild.FirstOrDefault(f => f.IdFirstChild == newFirstChild.IdFirstChild);
    if (existingFirstChild != null)
    {
        // 更新FirstChild基础属性
        _context.Entry(existingFirstChild).CurrentValues.SetValues(newFirstChild);
        // 递归处理SecondChild
        UpdateSecondChildren(existingFirstChild.SecondChild, newFirstChild.SecondChild);
    }
    else
    {
        parentDB.FirstChild.Add(newFirstChild);
    }
}

_context.SaveChanges();

// 处理SecondChild的增删改
void UpdateSecondChildren(ICollection<SecondChild> existing, ICollection<SecondChild> newItems)
{
    var existingIds = existing.Select(s => s.IdSecondChild).ToList();
    var newIds = newItems.Select(s => s.IdSecondChild).ToList();
    var toDelete = existing.Where(s => !newIds.Contains(s.IdSecondChild)).ToList();
    _context.RemoveRange(toDelete);

    foreach (var newItem in newItems)
    {
        var existingItem = existing.FirstOrDefault(s => s.IdSecondChild == newItem.IdSecondChild);
        if (existingItem != null)
        {
            _context.Entry(existingItem).CurrentValues.SetValues(newItem);
            // 处理ThirdChild
            UpdateThirdChildren(existingItem.ThirdChild, newItem.ThirdChild);
        }
        else
        {
            existing.Add(newItem);
        }
    }
}

// 处理ThirdChild的增删改
void UpdateThirdChildren(ICollection<ThirdChild> existing, ICollection<ThirdChild> newItems)
{
    var existingIds = existing.Select(t => t.IdThirdChild).ToList();
    var newIds = newItems.Select(t => t.IdThirdChild).ToList();
    var toDelete = existing.Where(t => !newIds.Contains(t.IdThirdChild)).ToList();
    _context.RemoveRange(toDelete);

    foreach (var newItem in newItems)
    {
        var existingItem = existing.FirstOrDefault(t => t.IdThirdChild == newItem.IdThirdChild);
        if (existingItem != null)
        {
            _context.Entry(existingItem).CurrentValues.SetValues(newItem);
        }
        else
        {
            existing.Add(newItem);
        }
    }
}

方案3：用TrackGraph统一管理跟踪状态 #

若新集合中部分实体已被跟踪，可通过TrackGraph手动设置实体状态，并单独处理删除逻辑：

var parentDB = _context.Parent.AsNoTracking().Single(x => x.IdParent == {id});
parentDB.FirstChild = {newCollectionValuesList};

// 遍历实体图设置跟踪状态
_context.ChangeTracker.TrackGraph(parentDB, e =>
{
    e.Entry.State = e.Entry.IsKeySet ? EntityState.Modified : EntityState.Added;
});

// 删除数据库中存在但新集合没有的FirstChild
var originalFirstChildren = _context.FirstChild.Where(f => f.ParentId == parentDB.IdParent).ToList();
var newFirstChildIds = parentDB.FirstChild.Select(f => f.IdFirstChild).ToList();
var toDelete = originalFirstChildren.Where(f => !newFirstChildIds.Contains(f.IdFirstChild)).ToList();
_context.RemoveRange(toDelete);

_context.SaveChanges();

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