EF LINQ如何Include多层嵌套子实体？层级实体查询求助

这个问题我之前也碰到过——EF的Include方法默认只会加载直接关联的一级子实体，不会自动递归遍历整个树形结构。下面给你几个不同场景下的解决方案，按需选择：

1. 最简单的方案：启用延迟加载 #

如果你的项目对性能要求不是极高，且上下文生命周期足够长（比如在Web请求范围内），延迟加载是最省心的选择：

前提条件： #

• 你的Child类中Children导航属性已经是virtual（你代码里已经满足了）
• 上下文启用了延迟加载支持：
  • EF Core：在上下文配置中添加UseLazyLoadingProxies()：

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseSqlServer("你的连接字符串")
                      .UseLazyLoadingProxies();
    }
    

  • EF6：默认只要导航属性是virtual就会启用延迟加载，除非你手动关闭了它。

效果： #

当你遍历RootChildren.Children时，EF会自动触发数据库查询加载下一层子节点，直到所有嵌套层级都被访问到。缺点是会产生N+1查询问题（每个节点都会触发一次查询），数据量大时性能会受影响。

2. 预加载所有层级（EF Core 5+） #

如果需要一次性加载所有层级，且不想用延迟加载，可以用显式递归加载的方式：

// 先获取根节点
var rootChild = dbContext.Parent
    .Where(p => p.Id == id)
    .Select(p => p.RootChildren)
    .FirstOrDefault();

// 递归加载所有子节点
if (rootChild != null)
{
    LoadAllChildren(dbContext, rootChild);
}

// 递归加载方法
private static void LoadAllChildren(YourDbContext context, Child parentNode)
{
    // 加载当前节点的直接子节点
    context.Entry(parentNode)
           .Collection(c => c.Children)
           .Load();
    
    // 递归加载每个子节点的子节点
    foreach (var child in parentNode.Children)
    {
        LoadAllChildren(context, child);
    }
}

这种方法比延迟加载更可控，但本质还是每个层级触发一次查询，同样存在N+1问题，适合层级较浅的场景。

如果层级是固定的（比如最多3层），也可以用多层Include+ThenInclude直接指定：

var rootChild = dbContext.Parent 
    .Where(p => p.Id == id) 
    .Select(r => r.RootChildren) 
    .Include(c => c.Children)
        .ThenInclude(c => c.Children) // 第二层
            .ThenInclude(c => c.Children) // 第三层，按需添加
    .FirstOrDefault();

3. 性能最优方案：使用SQL递归CTE #

如果你的树形结构层级深、数据量大，强烈推荐用SQL的**递归CTE（公共表表达式）**一次性查询所有节点，再手动构建树形结构——这是性能最好的方式，只需要一次数据库查询：

步骤1：查询所有节点（包括根节点） #

// 先获取根节点的Id（假设Parent的RootChildren有对应的Id字段，或者直接从查询中获取）
var rootChildId = dbContext.Parent
    .Where(p => p.Id == id)
    .Select(p => p.RootChildren.Id)
    .FirstOrDefault();

// 用CTE查询所有嵌套子节点
var allNodes = dbContext.Child
    .FromSqlRaw(@"
        WITH RecursiveChildTree AS (
            -- 初始节点：根节点
            SELECT Id, ParentId, /* 这里列出Child类的所有字段 */
            FROM Child
            WHERE Id = {0}
            UNION ALL
            -- 递归查询：子节点关联父节点
            SELECT c.Id, c.ParentId, /* 同上，列出所有字段 */
            FROM Child c
            INNER JOIN RecursiveChildTree rct ON c.ParentId = rct.Id
        )
        SELECT * FROM RecursiveChildTree", rootChildId)
    .ToList();

步骤2：手动构建树形结构 #

// 先建立Id到实体的映射，方便快速查找父节点
var nodeMap = allNodes.ToDictionary(n => n.Id);

// 获取根节点
var rootNode = nodeMap[rootChildId];

// 遍历所有节点，将子节点挂载到对应的父节点下
foreach (var node in allNodes.Where(n => n.Id != rootChildId))
{
    if (nodeMap.TryGetValue(node.ParentId, out var parentNode))
    {
        if (parentNode.Children == null)
            parentNode.Children = new List<Child>();
        parentNode.Children.Add(node);
    }
}

这种方法彻底解决了N+1问题，适合生产环境中数据量大的树形结构场景。

为什么你的原代码不生效？ #

你原来的代码中Include(c => c.Children)只会告诉EF加载RootChildren的直接子节点（第一层），EF不会自动递归识别嵌套的Children属性。只有当你用ThenInclude明确指定下一层级时，才会加载更深的节点，但这种方式无法处理不确定的嵌套层级。

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