如何使用实体框架进行递归加载？

Question

我在 DB 中有一个带有 TreeNodes 表的树结构。该表具有 nodeId、parentId 和 parameterId。在 EF 中，结构类似于 TreeNode.Children，其中每个孩子都是一个 TreeNode... 我还有一个包含 id、name 和 rootNodeId 的 Tree 表。

一天结束时，我想将树加载到 TreeView 中，但我不知道如何一次将其全部加载。 我试过了：

var trees = from t in context.TreeSet.Include("Root").Include("Root.Children").Include("Root.Children.Parameter")
        .Include("Root.Children.Children")
                        where t.ID == id
                        select t;

这将使我获得前 2 代，但不会更多。 如何加载包含所有世代和附加数据的整个树？

Answer 1

我最近遇到了这个问题，在我想出了一个简单的方法来实现结果之后偶然发现了这个问题。我提供了对 Craig 的答案的编辑，提供了第 4 种方法，但权力决定它应该是另一个答案。这对我来说很好:)

My original question / answer can be found here.

只要您在表中的项目都知道它们属于哪棵树（在您的情况下看起来像：t.ID），这就会起作用。也就是说，目前尚不清楚您真正拥有哪些实体，但即使您拥有多个实体，您也必须在实体 Children 中拥有一个 FK，如果那不是 TreeSet

基本上不要使用Include():

var query = from t in context.TreeSet
            where t.ID == id
            select t;

// if TreeSet.Children is a different entity:
var query = from c in context.TreeSetChildren
            // guessing the FK property TreeSetID
            where c.TreeSetID == id
            select c;

这将带回树的所有项目并将它们全部放在集合的根目录中。此时，您的结果集将如下所示：

-- Item1
   -- Item2
      -- Item3
-- Item4
   -- Item5
-- Item2
-- Item3
-- Item5

由于您可能希望您的实体仅分层地从 EF 中出来，这不是您想要的，对吧？

.. 然后，排除存在于根级别的后代：

幸运的是，由于您的模型中有导航属性，子实体集合仍将被填充，如上面结果集的插图所示。通过使用foreach() 循环手动迭代结果集，并将这些根项添加到new List<TreeSet>()，您现在将拥有一个包含根元素和所有后代正确嵌套的列表。

如果您的树变大并且性能受到关注，您可以按ParentID（它是Nullable，对吗？）对返回集 ASCENDING 进行排序，以便所有根项都排在第一位。像以前一样迭代和添加，但是一旦你到达一个非空的循环就会中断。

var subset = query
     // execute the query against the DB
     .ToList()
     // filter out non-root-items
     .Where(x => !x.ParentId.HasValue);

现在subset 将如下所示：

-- Item1
   -- Item2
      -- Item3
-- Item4
   -- Item5

关于 Craig 的解决方案：

1. 您真的不想为此使用延迟加载！围绕 n+1 查询的必要性构建的设计将是一个主要的性能吸盘。
*********（好吧，公平地说，如果您要允许用户有选择地向下钻取树，那么它可能是合适的。只是不要使用延迟加载来将它们全部提前！）


2. 我从未尝试过嵌套设置东西，我也不建议破解 EF 配置来完成这项工作，因为有一个更简单的解决方案。


3. Another reasonable suggestion 正在创建一个提供自链接的数据库视图，然后将该视图映射到中间连接/链接/m2m 表。就个人而言，我发现这个解决方案比必要的复杂，但它可能有它的用途。

Answer 2

当您使用Include() 时，您要求实体框架将您的查询转换为 SQL。所以想一想：你将如何编写返回任意深度的树的 SQL 语句？

回答：除非您使用数据库服务器的特定层次结构功能（这些功能不是 SQL 标准，但某些服务器支持，例如 SQL Server 2008，尽管它的实体框架提供程序不支持），否则您不会。在 SQL 中处理任意深度树的常用方法是使用 the nested sets model 而不是父 ID 模型。

因此，您可以使用三种方法来解决此问题：

1. 使用嵌套集模型。这需要更改您的元数据。
2. 使用 SQL Server 的层次结构功能，并破解实体框架以理解它们（很棘手，但 this technique might work）。同样，您需要更改元数据。i
3. 使用显式加载或 EF 4 的延迟加载而不是急切加载。这将导致很多数据库查询，而不是一个。

Answer 3

我想发布我的答案，因为其他人没有帮助我。

我的数据库有点不同，基本上我的表有一个 ID 和一个 ParentID。该表是递归的。以下代码获取所有子级并将它们嵌套到最终列表中。

public IEnumerable<Models.MCMessageCenterThread> GetAllMessageCenterThreads(int msgCtrId)
{
    var z = Db.MCMessageThreads.Where(t => t.ID == msgCtrId)
        .Select(t => new MCMessageCenterThread
        {
            Id = t.ID,
            ParentId = t.ParentID ?? 0,
            Title = t.Title,
            Body = t.Body
        }).ToList();

    foreach (var t in z)
    {
        t.Children = GetChildrenByParentId(t.Id);
    }

    return z;
}

private IEnumerable<MCMessageCenterThread> GetChildrenByParentId(int parentId)
{
    var children = new List<MCMessageCenterThread>();

    var threads = Db.MCMessageThreads.Where(x => x.ParentID == parentId);

    foreach (var t in threads)
    {
        var thread = new MCMessageCenterThread
        {
            Id = t.ID,
            ParentId = t.ParentID ?? 0,
            Title = t.Title,
            Body = t.Body,
            Children = GetChildrenByParentId(t.ID)
        };

        children.Add(thread);
    }

    return children;
}

为了完整起见，这是我的模型：

public class MCMessageCenterThread
{
    public int Id { get; set; }
    public int ParentId { get; set; }
    public string Title { get; set; }
    public string Body { get; set; }

    public IEnumerable<MCMessageCenterThread> Children { get; set; }
}

Answer 4

我最近写了一个 N+1 选择加载整个树的东西，其中 N 是源对象中最深路径的层数。

鉴于以下自引用类，这就是我所做的

public class SomeEntity 
{
  public int Id { get; set; }
  public int? ParentId { get; set; }
  public string Name { get; set;
}

我写了以下 DbSet 助手

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Threading.Tasks;

namespace Microsoft.EntityFrameworkCore
{
    public static class DbSetExtensions
    {
        public static async Task<TEntity[]> FindRecursiveAsync<TEntity, TKey>(
            this DbSet<TEntity> source,
            Expression<Func<TEntity, bool>> rootSelector,
            Func<TEntity, TKey> getEntityKey,
            Func<TEntity, TKey> getChildKeyToParent)
            where TEntity: class
        {
            // Keeps a track of already processed, so as not to invoke
            // an infinte recursion
            var alreadyProcessed = new HashSet<TKey>();

            TEntity[] result = await source.Where(rootSelector).ToArrayAsync();

            TEntity[] currentRoots = result;
            while (currentRoots.Length > 0)
            {
                TKey[] currentParentKeys = currentRoots.Select(getEntityKey).Except(alreadyProcessed).ToArray();
                alreadyProcessed.AddRange(currentParentKeys);

                Expression<Func<TEntity, bool>> childPredicate = x => currentParentKeys.Contains(getChildKeyToParent(x));
                currentRoots = await source.Where(childPredicate).ToArrayAsync();
            }

            return result;
        }
    }
}

当你需要加载整个树时，你只需调用这个方法，传入三个东西

1. 根对象的选择标准
2. 如何获取对象的主键属性（SomeEntity.Id）
3. 如何获取引用其父级 (SomeEntity.ParentId) 的子级属性

例如

SomeEntity[] myEntities = await DataContext.SomeEntity.FindRecursiveAsync(
  rootSelector: x => x.Id = 42,
  getEntityKey: x => x.Id,
  getChildKeyToParent: x => x.ParentId).ToArrayAsync();
);

或者，如果您可以将RootId 列添加到表中，那么对于每个非根条目，您可以将此列设置为树根的 ID。然后，您可以通过一次选择获取所有内容

DataContext.SomeEntity.Where(x => x.Id == rootId || x.RootId == rootId)

Answer 5

对于加载子对象的示例，我将给出一个包含注释的 Comment 对象的示例。每个评论都有一个可能的子评论。

private static void LoadComments(<yourObject> q, Context yourContext)
{
    if(null == q | null == yourContext)
    {
        return;
    }
    yourContext.Entry(q).Reference(x=> x.Comment).Load();
    Comment curComment = q.Comment;
    while(null != curComment)
    {
        curComment = LoadChildComment(curComment, yourContext);
    }
}

private static Comment LoadChildComment(Comment c, Context yourContext)
{
    if(null == c | null == yourContext)
    {
        return null;
    }
    yourContext.Entry(c).Reference(x=>x.ChildComment).Load();
    return c.ChildComment;
}

现在，如果您拥有自己的集合，您将需要使用 Collection 而不是 Reference 并进行相同的潜水。至少这是我在处理实体和 SQLite 时在这种情况下采用的方法。

Answer 6

这是一个老问题，但其他答案要么有 n+1 个数据库命中，要么他们的模型有利于自下而上（树干到叶子）方法。在这种情况下，标签列表作为树加载，并且标签可以有多个父级。我使用的方法只有两个数据库命中：第一个获取所选文章的标签，然后另一个急切加载连接表。因此，这使用了自上而下（从树干到树干）的方法；如果您的连接表很大，或者如果结果不能真正被缓存以供重用，那么急切加载整个事物就会开始显示这种方法的权衡。

首先，我初始化了两个HashSets：一个保存根节点（结果集），另一个保存对每个被“命中”的节点的引用。

var roots = new HashSet<AncestralTagDto>(); //no parents
var allTags = new HashSet<AncestralTagDto>();

接下来，我抓取客户请求的所有叶子，将它们放入一个包含子集合的对象中（但在此步骤之后该集合将保持为空）。

var startingTags = await _dataContext.ArticlesTags
        .Include(p => p.Tag.Parents)
        .Where(t => t.Article.CategoryId == categoryId)
        .GroupBy(t => t.Tag)
        .ToListAsync()
        .ContinueWith(resultTask => 
             resultTask.Result.Select(
                  grouping => new AncestralTagDto(
                        grouping.Key.Id, 
                        grouping.Key.Name)));

现在，让我们抓取标签自连接表，并将其全部加载到内存中：

var tagRelations = await _dataContext.TagsTags.Include(p => p.ParentTag).ToListAsync();

现在，对于startingTags 中的每个标签，将该标签添加到allTags 集合中，然后沿着树向下递归地获取祖先：

foreach (var tag in startingTags)
{
    allTags.Add(tag);
    GetParents(tag);
}
return roots;

最后，这是构建树的嵌套递归方法：

void GetParents(AncestralTagDto tag)
{
    var parents = tagRelations.Where(c => c.ChildTagId == tag.Id).Select(p => p.ParentTag);
    if (parents.Any()) //then it's not a root tag; keep climbing down
    {
        foreach (var parent in parents)
        {
            //have we already seen this parent tag before? If not, instantiate the dto.
            var parentDto = allTags.SingleOrDefault(i => i.Id == parent.Id);
            if (parentDto is null)
            {
                parentDto = new AncestralTagDto(parent.Id, parent.Name);
                allTags.Add(parentDto);
            }

            parentDto.Children.Add(tag);
            GetParents(parentDto);
        }
    }
    else //the tag is a root tag, and should be in the root collection. If it's not in there, add it.
    {
        //this block could be simplified to just roots.Add(tag), but it's left this way for other logic.
        var existingRoot = roots.SingleOrDefault(i => i.Equals(tag));
        if (existingRoot is null)
            roots.Add(tag);
    }
}

在幕后，我依靠HashSet 的属性来防止重复。为此，您使用的中间对象（我在这里使用 AncestralTagDto，它的 Children 集合也是 HashSet）非常重要，根据您的用例覆盖 Equals 和 GetHashCode 方法。