c# - 插入 Entity Framework 子项的顺序

Question

我有这样的结构

public class Son {
  public string Name {get;set;} 
  public int Age {get;set;}
}

public class Daughter {
  public string Name {get;set;} 
  public int Age {get;set;}
}

public class Parent {
  public Daughter[] Daughters {get;set;}    
  public Son[] Sons {get;set;}
}

哪里有 FK Parent -> Son and Parent -> Daughter

当前，当在父对象上执行 Context.SaveChanges() 时，它会保存 Parent，然后保存 Daughter，然后保存 Son。我需要它在女儿之前保存儿子，因为我们有一个数据库触发器，它根据女儿验证儿子(如果不符合要求，将拒绝整个事情)

这个触发器显然不在 EF 的知识范围内。

我如何指定 Sons 依赖于 EF 中的 Daughters，以便首先插入 Sons；或者是否有我可以定义插入顺序的规范或属性？

PS:不要过多关注人为的示例(例如为什么我们不将其保存在一个名为 Children 的东西下)。现实世界的例子要复杂得多，但在女儿之前拯救儿子的想法是存在的

Answer 1

我喜欢挑战!

首先声明:我不喜欢触发器或建立使插入顺序重要的要求。我的第一个练习是用尽所有选项来删除这样的要求。

至少在添加实体时(例如，父级有一个或多个女儿和一个或多个儿子)经过一些修补后，插入顺序始终根据实体名称按字母顺序排列。例如，对于名为“Parent”、“Daughter”和“Son”的实体，插入始终是 Parent > Daughter > Son。属性、配置、插入甚至表名的顺序与操作无关，但是将实体类“Son”重命名为“ASon”会导致 Sons 在 Daughters 之前插入。我不知道这是否会延续到编辑中，但这是需要考虑的事情，但又不会太老套。 (虽然这样的事情肯定需要在系统中得到很好的记录，以防有人质疑命名约定以在其他东西之前插入一些东西。)

就是说，进入 hacky 有趣的行业!

使用名为 AOn 的 Son 实体强制 Sons 在 Daughters 之前，可以让 EF 反转该插入顺序:

        using (var context = new ParentDbContext())
        {
            var parent = context.Parents.Create();
            parent.Name = "Steve";

            parent.Daughters.Add(new Daughter { Name = "Elise" });
            parent.Daughters.Add(new Daughter { Name = "Susan" });
            parent.Sons.Add(new ASon { Name = "Jason" });
            parent.Sons.Add(new ASon { Name = "Duke" });
            context.Parents.Add(parent);
            context.SaveChanges();
        }

开箱即用，插入了 Parent、Son、Son、Daughter、Daughter。

为了扭转它，我覆盖了 SaveChanges，寻找我们的儿子将保存推迟到其他一切之后:

    public override int SaveChanges()
    {
        var trackedStates = new[] { EntityState.Added, EntityState.Modified };
        var trackedParentIds = ChangeTracker.Entries<Parent>().Where(x => trackedStates.Contains(x.State)).Select(x => x.Entity.ParentId).ToList();
        var addedSons = ChangeTracker.Entries<ASon>().Where(x => x.State == EntityState.Added).ToList();
        var modifiedSons = ChangeTracker.Entries<ASon>().Where(x => x.State == EntityState.Modified).ToList();

        int tempid = -1;
        int modifiedParentCount = addedSons.Select(x => x.Entity.Parent.ParentId)
            .Where(x => trackedParentIds.Contains(x))
            .Count();
        List<Tuple<Parent, ASon>> associatedSons = new List<Tuple<Parent, ASon>>();
        modifiedSons.ForEach(x => { x.State = EntityState.Unchanged; });
        addedSons.ForEach(x =>
        {
            x.Entity.SonId = tempid--;
            associatedSons.Add(new Tuple<Parent, ASon>(x.Entity.Parent, x.Entity));
            x.Entity.Parent.Sons.Remove(x.Entity);
            x.State = EntityState.Unchanged;
        });

        var result = base.SaveChanges();

        addedSons.ForEach(x => { x.Entity.Parent = associatedSons.Single(a => a.Item2 == x.Entity).Item1; x.State = EntityState.Added; });
        modifiedSons.ForEach(x => { x.State = EntityState.Modified; });

        result += base.SaveChanges() - modifiedParentCount;
        return result;
    }

那么这是在做什么:第一步很简单，我们找到添加和修改的子项。我们还统计了有修改过的和添加过的儿子的 parent 。完成后这些将被重复计算。

对于修改后的儿子，我们只是将他们的状态设置为Unchanged。对于添加的儿子，我们需要做一些肮脏的工作。我们需要给他们一个临时的唯一 ID，因为要将他们标记为未更改，EF 仍要跟踪他们的 ID，当您添加 2 个儿子时，它会在这里失败。请注意，当我们将它们放回原样时，它们将从身份列中接收到正确的 ID，而不是这些临时的负数。我们还在元组中跟踪他们添加的儿子与他们各自 parent 的关联，因为我们需要暂时从他们的 parent 中删除这些儿子。最后添加的儿子也被标记为不变。现在我们调用基础 SaveChanges 来保存我们的 parent 和他们的女儿。对于修改后的儿子，我们只需要将状态更新回 Modified。对于我们添加的儿子，我们使用我们保存的关联将他们重新分配给他们的 parent ，然后将他们的状态设置回已添加。我们再次调用基础 SaveChanges，将受影响的行计数附加到第一次运行，并减去重复的父引用。 (因修改已统计的parents)

粗略的一点是调整双重保存的结果计数，这可能不是 100% 准确，但只有在您碰巧使用 SaveChanges 的结果时才会出现问题。我不能说我真的很关注那个返回值:)

希望这能给您一些想法。