Entity Framework Core：如何保留父实体并分离其余关联实体

问题背景 #

我们正从现有代码库迁移至Entity Framework Core，需实现现有仓储接口的核心行为：分别调用parentRepository.InsertItemAsync(parentEntity, cancellationToken);和childRepository.InsertItemAsync(childEntity, cancellationToken);独立插入父、子实体，避免插入父实体时自动插入其子实体，同时插入子实体时不会误分离父实体导致功能异常。

当前实现的问题 #

现有DetachRelatedEntities方法仅对父实体插入场景有效，处理子实体时会误分离其父实体，而EF Core会自动将关联的子实体也标记为分离，最终导致插入失败：

/// <summary>
/// 分离所有非当前仓储管理类型的实体
/// </summary>
private void DetachRelatedEntities()
{
    EntityEntry[] entities = _dbContext.ChangeTracker.Entries().ToArray();

    foreach (EntityEntry? e in entities)
    {
        var entityType = e.Entity.GetType();

        if (entityType != typeof(T))
            e.State = EntityState.Detached;
    }
}

// <T> 是当前IRepository<T>管理的实体类型

附上调用该方法的InsertItemsAsync实现：

public async Task InsertItemsAsync(IEnumerable<T> items, CancellationToken cancellationToken = default)
{
    var itemsList = items.ToList();
    if (itemsList.TrueForAll(i => !Set.AsNoTrackingWithIdentityResolution().Any(s => s.Id == i.Id)))
    {
        Set.AddRange(itemsList);

        DetachRelatedEntities(); // 期望分离非T类型实体，但当前实现逻辑有问题

        await _dbContext.SaveChangesAsync(cancellationToken);

        DetachEntities(); // 该方法已实现，用于分离所有实体避免上下文跟踪冲突
        return;
    }

    throw new InvalidOperationException($"集合中存在已在数据库中的{item}实例");
}

改进方案 #

方案1：基于EF元数据保留T的关联父实体类型 #

通过EF Core的模型元数据，识别当前实体T的所有引用导航属性（即父实体类型），保留这些类型的实体并将其状态设为Unchanged（避免被插入），仅分离其他非T类型实体：

private void DetachRelatedEntities()
{
    // 获取T对应的EF实体元数据
    var entityType = _dbContext.Model.FindEntityType(typeof(T));
    if (entityType == null) return;

    // 收集需要保留的类型：T本身 + 所有引用导航的目标父实体类型
    var retainedTypes = new HashSet<Type> { typeof(T) };
    foreach (var nav in entityType.GetNavigations().Where(n => !n.IsCollection))
    {
        retainedTypes.Add(nav.TargetEntityType.ClrType);
    }

    var trackedEntities = _dbContext.ChangeTracker.Entries().ToArray();
    foreach (var entry in trackedEntities)
    {
        var currentType = entry.Entity.GetType();
        if (!retainedTypes.Contains(currentType))
        {
            // 分离非保留类型的实体
            entry.State = EntityState.Detached;
        }
        else if (currentType != typeof(T))
        {
            // 将父实体设为Unchanged，确保不会被插入
            entry.State = EntityState.Unchanged;
        }
    }
}

方案2：精准保留被T实体引用的关联实例 #

遍历所有被T实体直接引用的关联实体实例，仅保留这些实例和T实体，分离其他所有无关实体：

private void DetachRelatedEntities()
{
    var trackedEntities = _dbContext.ChangeTracker.Entries().ToArray();
    // 获取当前仓储管理的所有T实体实例
    var tEntities = trackedEntities
        .Where(e => e.Entity.GetType() == typeof(T))
        .Select(e => e.Entity)
        .ToList();

    // 收集所有被T实体引用的关联实体
    var referencedEntities = new HashSet<object>();
    var entityType = _dbContext.Model.FindEntityType(typeof(T));
    if (entityType != null)
    {
        foreach (var tEntity in tEntities)
        {
            foreach (var nav in entityType.GetNavigations())
            {
                var navValue = nav.PropertyInfo.GetValue(tEntity);
                if (navValue == null) continue;

                if (nav.IsCollection)
                {
                    // 处理集合导航，添加所有元素
                    foreach (var item in (IEnumerable)navValue)
                    {
                        referencedEntities.Add(item);
                    }
                }
                else
                {
                    // 处理单个引用导航
                    referencedEntities.Add(navValue);
                }
            }
        }
    }

    // 遍历跟踪实体，分离无关实例
    foreach (var entry in trackedEntities)
    {
        var entity = entry.Entity;
        if (entity.GetType() == typeof(T))
        {
            continue;
        }
        else if (referencedEntities.Contains(entity))
        {
            entry.State = EntityState.Unchanged;
        }
        else
        {
            entry.State = EntityState.Detached;
        }
    }
}

方案3：添加实体后直接设置关联实体状态 #

无需分离操作，在添加T实体到DbSet后，手动将所有关联的非T实体状态设为Unchanged，从根源避免自动插入：

public async Task InsertItemsAsync(IEnumerable<T> items, CancellationToken cancellationToken = default)
{
    var itemsList = items.ToList();
    if (itemsList.TrueForAll(i => !Set.AsNoTrackingWithIdentityResolution().Any(s => s.Id == i.Id)))
    {
        Set.AddRange(itemsList);

        // 手动处理关联实体状态，避免自动插入
        var entityType = _dbContext.Model.FindEntityType(typeof(T));
        if (entityType != null)
        {
            foreach (var item in itemsList)
            {
                var entry = _dbContext.Entry(item);
                foreach (var nav in entry.Navigations)
                {
                    if (nav.EntityEntry.Entity.GetType() != typeof(T))
                    {
                        nav.EntityEntry.State = EntityState.Unchanged;
                    }
                }
            }
        }

        await _dbContext.SaveChangesAsync(cancellationToken);

        DetachEntities();
        return;
    }

    throw new InvalidOperationException($"集合中存在已在数据库中的{item}实例");
}

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