使用LINQ递归获取层级结构并包含父节点

首先明确你的数据模型（基于描述补充完整）：

public class Parent
{
    public Guid Id { get; set; }
    public List<Comment> Comments { get; set; } = new();
}

public class Comment
{
    public Guid Id { get; set; }
    public string Text { get; set; }
    public List<Comment> Replies { get; set; } = new();
}

你的核心问题是现有代码仅遍历二级节点，无法递归定位深层目标节点并关联其祖先与子节点。以下是完整的递归解决方案，可实现指定ID（如5）时，返回Parent对象及ID为3、4、5、6的评论节点（支持扁平化列表或保留层级结构）。

方案实现 #

1. 递归查找目标节点的完整路径（祖先+目标） #

这个方法会遍历所有层级的评论，找到目标节点时返回从根评论到目标节点的完整路径：

private static List<Comment> FindCommentPath(List<Comment> comments, Guid targetId, List<Comment> currentPath = null)
{
    currentPath ??= new List<Comment>();

    foreach (var comment in comments)
    {
        currentPath.Add(comment);
        if (comment.Id == targetId)
            return currentPath;

        var childMatch = FindCommentPath(comment.Replies, targetId, currentPath);
        if (childMatch != null)
            return childMatch;

        currentPath.RemoveAt(currentPath.Count - 1);
    }

    return null;
}

2. 递归收集目标节点的所有子节点 #

获取目标节点下的所有层级子节点（包括直接和间接子节点）：

private static List<Comment> GetAllDescendants(Comment targetComment)
{
    var descendants = new List<Comment> { targetComment };
    foreach (var reply in targetComment.Replies)
        descendants.AddRange(GetAllDescendants(reply));
    return descendants;
}

3. 整合逻辑获取最终结果 #

根据需求，你可以选择返回扁平化的目标节点列表或保留层级结构的树：

public static (Parent Parent, List<Comment> TargetComments) GetTargetData(Parent parent, Guid targetId)
{
    var commentPath = FindCommentPath(parent.Comments, targetId);
    if (commentPath == null)
        return (parent, new List<Comment>());

    // 获取目标节点的所有子节点
    var targetNode = commentPath.Last();
    var allDescendants = GetAllDescendants(targetNode);

    // 合并路径节点与子节点，去重后得到最终扁平化列表
    var targetComments = commentPath.Concat(allDescendants.Skip(1)).DistinctBy(c => c.Id).ToList();

    // 如果需要保留层级结构，使用下面的克隆方法替代扁平化列表
    // var hierarchicalTree = parent.Comments.Select(c => CloneTargetBranch(c, targetId)).Where(c => c != null).ToList();

    return (parent, targetComments);
}

// 可选：克隆仅包含目标分支的层级结构
private static Comment CloneTargetBranch(Comment original, Guid targetId)
{
    if (original.Id == targetId)
    {
        return new Comment
        {
            Id = original.Id,
            Text = original.Text,
            Replies = original.Replies.Select(r => CloneTargetBranch(r, targetId)).ToList()
        };
    }

    var validReplies = original.Replies.Select(r => CloneTargetBranch(r, targetId)).Where(r => r != null).ToList();
    return validReplies.Any() ? new Comment { Id = original.Id, Text = original.Text, Replies = validReplies } : null;
}

说明 #

• 递归遍历解决了深层节点的定位问题，无论目标节点在第几层都能精准找到。
• 扁平化列表直接返回所有符合要求的节点（3、4、5、6），层级结构则保留原父子关系，仅保留包含目标节点的分支。
• 使用DistinctBy避免重复节点（目标节点会同时出现在路径和子节点列表中）。

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