预加载（Eager loading）：如何更新含关联子实体的父实体及泛型适配？

嘿，我来帮你一步步拆解这两个问题：

一、子实体无法更新的原因与修复方案 #

你的代码里，attachedEntry.CurrentValues.SetValues(entity) 这个方法只会同步父实体的标量属性（比如idSeq、名称这类字段），完全不会处理导航属性（也就是你的children_1、children_2这些子集合）。而且EF（或EF Core）默认不会自动跟踪传入的 detached 子实体的变化，所以就算父实体更新了，子实体的修改也不会被保存到数据库。

另外还有个关键遗漏：你的原代码没有调用_context.SaveChanges()，就算状态设置正确，也不会把变更写入数据库！

下面是修改后的代码，我加上了子实体的完整处理逻辑：

public void UpdateEnt<T>(T entity) where T : parent_table 
{
    if (entity == null) 
    {
        throw new ArgumentException("Cannot add a null entity.");
    }

    using (var _context = (DataModelDetach)d.GetContextForRead(Module)) 
    {
        var entry = _context.Entry<T>(entity);
        if (entry.State == EntityState.Detached) 
        {
            var set = _context.Set<T>();
            T attachedEntity = set.Include(x => x.children_1)
                                  .Include(x => x.children_2)
                                  .SingleOrDefault(e => e.idSeq == entity.idSeq);

            if (attachedEntity != null) 
            {
                // 同步父实体的标量属性
                var attachedEntry = _context.Entry(attachedEntity);
                attachedEntry.CurrentValues.SetValues(entity);

                // ====== 处理子集合 children_1：覆盖新增、修改、删除场景 ======
                // 1. 删除：附加实体中有，但传入实体中没有的子项
                foreach (var existingChild in attachedEntity.children_1.ToList())
                {
                    if (!entity.children_1.Any(c => c.id == existingChild.id))
                    {
                        _context.Remove(existingChild);
                    }
                }

                // 2. 新增/修改：传入实体中的子项
                foreach (var child in entity.children_1)
                {
                    var existingChild = attachedEntity.children_1.SingleOrDefault(c => c.id == child.id);
                    if (existingChild == null)
                    {
                        attachedEntity.children_1.Add(child); // 新增子实体
                    }
                    else
                    {
                        _context.Entry(existingChild).CurrentValues.SetValues(child); // 修改子实体属性
                    }
                }

                // ====== 同理处理 children_2 ======
                foreach (var existingChild in attachedEntity.children_2.ToList())
                {
                    if (!entity.children_2.Any(c => c.id == existingChild.id))
                    {
                        _context.Remove(existingChild);
                    }
                }

                foreach (var child in entity.children_2)
                {
                    var existingChild = attachedEntity.children_2.SingleOrDefault(c => c.id == child.id);
                    if (existingChild == null)
                    {
                        attachedEntity.children_2.Add(child);
                    }
                    else
                    {
                        _context.Entry(existingChild).CurrentValues.SetValues(child);
                    }
                }
            } 
            else 
            {
                // 未找到已附加的实体，直接标记父实体为修改
                entry.State = EntityState.Modified;
                // 如果要同时更新子实体，需手动设置子实体状态：
                // foreach(var child in entity.children_1) 
                //     _context.Entry(child).State = child.id == 0 ? EntityState.Added : EntityState.Modified;
            }

            // 必须调用这句，才能把所有变更写入数据库
            _context.SaveChanges();
        }
    }
}

二、该方法能否适配泛型实体？ #

当前方法的约束是 where T : parent_table，只能处理parent_table类及其子类。如果要适配任意实体类型，需要做以下调整：

1. 调整泛型约束 #

把约束改成更通用的形式，同时要求实体有唯一标识字段（比如idSeq）：

// 先定义一个通用接口，规范实体必须有唯一主键
public interface IEntityWithId
{
    int idSeq { get; set; }
}

// 修改方法约束
public void UpdateEnt<T>(T entity) where T : class, IEntityWithId
{
    // ... 后续逻辑
}

这样所有实现IEntityWithId接口的实体都可以用这个方法。

2. 解决导航属性Include的问题 #

原代码里的Include(x => x.children_1)是硬编码的，泛型场景下无法提前知道实体有哪些导航属性。有两种解决思路：

• 思路一：让实体声明子集合：定义IHasChildren之类的接口，让有子实体的实体实现该接口，在方法里判断并处理。
• 思路二：反射动态获取导航属性：通过EF元数据（比如_context.Model.FindEntityType(typeof(T))）获取实体的导航属性，动态执行Include。这种方式复杂度较高，适合需要高度通用的场景。

3. 通用子实体处理的封装 #

可以把子集合的同步逻辑封装成通用方法，避免重复代码：

private void SyncChildCollections<TChild>(ICollection<TChild> attachedChildren, ICollection<TChild> incomingChildren, Func<TChild, object> getKey)
    where TChild : class
{
    // 删除逻辑
    foreach (var existingChild in attachedChildren.ToList())
    {
        if (!incomingChildren.Any(c => getKey(c).Equals(getKey(existingChild))))
        {
            _context.Remove(existingChild);
        }
    }

    // 新增/修改逻辑
    foreach (var child in incomingChildren)
    {
        var existingChild = attachedChildren.SingleOrDefault(c => getKey(c).Equals(getKey(child)));
        if (existingChild == null)
        {
            attachedChildren.Add(child);
        }
        else
        {
            _context.Entry(existingChild).CurrentValues.SetValues(child);
        }
    }
}

在泛型方法里调用时，只需传入对应的子集合和主键获取器即可。

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