如何生成嵌套至无值的多层嵌套Object JSON结构？

嘿，我来帮你解决这个无限嵌套JSON的问题！你要的结构其实就是递归嵌套的层级模型，正好对应评论回复这种“父-子-孙”无限延伸的场景，下面一步步给你讲清楚：

一、先把C#类定义改对（递归结构是关键） #

你之前的类可能没做好递归关联，要让每个子节点能包含同样结构的下一层子节点，类得这么定义：

// 子节点的递归类，对应你示例里的ChildName+ChildName2结构
public class EmployeeNode
{
    public string ChildName { get; set; }
    // ChildName2是同类型的列表，实现无限嵌套
    public List<EmployeeNode> ChildName2 { get; set; } = new List<EmployeeNode>();
}

// 顶层父节点类
public class ParentEmployee
{
    public string id { get; set; }
    public string name { get; set; }
    public EmployeeData data { get; set; }
    public List<EmployeeNode> children { get; set; } = new List<EmployeeNode>();
}

// 附属数据类
public class EmployeeData
{
    public string phone { get; set; }
    public string email { get; set; }
}

二、用递归方法生成无限嵌套节点 #

要实现“循环至ChildName无值为止”，递归是最直接的方式——每次创建节点时，检查是否还有下一层内容，没有就终止：

/// <summary>
/// 递归构建嵌套节点
/// </summary>
/// <param name="childName">当前节点名称</param>
/// <param name="remainingDepth">剩余嵌套层数（或者换成实际业务的终止条件，比如是否有子回复）</param>
/// <returns></returns>
public static EmployeeNode BuildNestedNode(string childName, int remainingDepth)
{
    // 终止条件：如果没有剩余层数，或者ChildName为空，就返回空的子列表
    if (remainingDepth == 0 || string.IsNullOrEmpty(childName))
    {
        return new EmployeeNode 
        { 
            ChildName = childName, 
            ChildName2 = new List<EmployeeNode>() 
        };
    }

    // 创建当前节点，然后递归生成下一层子节点
    var currentNode = new EmployeeNode { ChildName = childName };
    currentNode.ChildName2.Add(BuildNestedNode(childName, remainingDepth - 1));
    return currentNode;
}

三、序列化生成目标JSON #

用Json.NET（Newtonsoft.Json）序列化就行，示例代码如下：

// 构建顶层父节点
var parentEmp = new ParentEmployee
{
    id = "100",
    name = "ParentEMP_0",
    data = new EmployeeData 
    { 
        phone = "2469465", 
        email = "parent.data0@somemail.com" 
    }
};

// 生成4层嵌套（对应你示例里的4层ChildEMP_0），实际业务中可以换成"是否存在子回复"的判断
parentEmp.children.Add(BuildNestedNode("ChildEMP_0", 3));

// 序列化并输出格式化后的JSON
var jsonResult = Newtonsoft.Json.JsonConvert.SerializeObject(
    new List<ParentEmployee> { parentEmp }, 
    Newtonsoft.Json.Formatting.Indented
);
Console.WriteLine(jsonResult);

四、针对评论回复场景的优化建议 #

如果是做类似Facebook的评论模块，实际场景中数据一般是从数据库读的扁平结构（比如每条评论有ParentId），这时候可以把扁平数据转成嵌套结构，示例代码如下：

// 数据库里的扁平评论实体
public class Comment
{
    public int Id { get; set; }
    public string Content { get; set; }
    public int? ParentId { get; set; }
}

// 嵌套用的评论节点类
public class CommentNode
{
    public int Id { get; set; }
    public string Content { get; set; }
    public List<CommentNode> Replies { get; set; } = new List<CommentNode>();
}

// 把扁平评论转成嵌套树的方法
public static List<CommentNode> BuildCommentTree(List<Comment> allComments, int? parentId = null)
{
    return allComments
        .Where(c => c.ParentId == parentId)
        .Select(c => new CommentNode
        {
            Id = c.Id,
            Content = c.Content,
            // 递归获取当前评论的所有子回复
            Replies = BuildCommentTree(allComments, c.Id)
        })
        .ToList();
}

这个方法会自动根据ParentId把所有评论组装成无限嵌套的回复树，序列化后就是完美的评论JSON结构。

小总结 #

核心思路就是递归：让类的结构支持自身嵌套，再用递归方法控制终止条件（比如ChildName为空、没有子回复），就能生成你要的无限层级JSON啦。你找到的那个例子本质也是用递归实现的，抓住这个核心就没问题了。

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