.NET MongoDB如何在多层嵌套结构的列表中插入元素

针对你用C#处理ProjectSchema和FolderSchema嵌套结构的需求，最直观且易实现的方式是递归遍历（如果嵌套层级极深，也可以用迭代方式避免栈溢出）。下面是具体的实现步骤和代码示例：

1. 先确认类结构定义 #

首先确保你的ProjectSchema和FolderSchema包含必要的属性（这里补充了子文件夹集合和Id属性，你可以根据实际情况调整）：

using MongoDB.Bson.Serialization.Attributes;
using System.Collections.Generic;

public class ProjectSchema
{
    [BsonElement("rootFolder")]
    public FolderSchema RootFolder { get; set; }
    // 其他根文档属性...
}

public class FolderSchema
{
    [BsonElement("id")]
    public string Id { get; set; }
    [BsonElement("children")]
    public List<FolderSchema> Children { get; set; } = new List<FolderSchema>();
    // 其他文件夹属性，比如名称、创建时间等...
}

2. 递归遍历查找目标文件夹 #

递归是处理树形结构最直接的方式，我们可以写一个辅助方法，从根文件夹开始逐层遍历，直到找到匹配Id的文件夹：

/// <summary>
/// 递归查找指定Id的文件夹
/// </summary>
/// <param name="currentFolder">当前遍历的文件夹</param>
/// <param name="targetId">要查找的文件夹Id</param>
/// <returns>找到的文件夹，未找到则返回null</returns>
private static FolderSchema FindFolderById(FolderSchema currentFolder, string targetId)
{
    // 先检查当前文件夹是否匹配
    if (currentFolder.Id == targetId)
    {
        return currentFolder;
    }

    // 遍历所有子文件夹，递归查找
    foreach (var childFolder in currentFolder.Children)
    {
        var foundFolder = FindFolderById(childFolder, targetId);
        if (foundFolder != null)
        {
            return foundFolder;
        }
    }

    // 遍历完所有层级都没找到
    return null;
}

3. 执行查找并插入新文件夹 #

反序列化完成后，调用上面的方法找到目标文件夹，然后插入新的FolderSchema实例：

// 1. 反序列化BsonDocument到ProjectSchema
var project = MongoDB.Bson.Serialization.BsonSerializer.Deserialize<ProjectSchema>(yourBsonDocument);

// 2. 定义目标文件夹Id和新文件夹实例
string targetFolderId = "your-target-folder-id";
var newFolder = new FolderSchema
{
    Id = System.Guid.NewGuid().ToString(), // 生成唯一Id
    // 设置其他属性，比如Name = "新建文件夹"等
};

// 3. 查找目标文件夹并插入
var targetFolder = FindFolderById(project.RootFolder, targetFolderId);
if (targetFolder != null)
{
    targetFolder.Children.Add(newFolder);
    Console.WriteLine("新文件夹插入成功");
}
else
{
    Console.WriteLine("未找到指定Id的文件夹");
}

4. 备选：迭代遍历（避免栈溢出） #

如果你的文件夹嵌套层级非常深（比如超过1000层），递归可能会触发栈溢出错误，这时候可以用**栈（Stack）**实现迭代遍历：

private static FolderSchema FindFolderByIdIterative(FolderSchema rootFolder, string targetId)
{
    var folderStack = new Stack<FolderSchema>();
    folderStack.Push(rootFolder);

    while (folderStack.Count > 0)
    {
        var currentFolder = folderStack.Pop();
        if (currentFolder.Id == targetId)
        {
            return currentFolder;
        }

        // 反向入栈保证遍历顺序和递归一致（栈是后进先出）
        foreach (var child in currentFolder.Children.Reverse())
        {
            folderStack.Push(child);
        }
    }

    return null;
}

额外优化建议 #

• 可以把查找和插入逻辑封装成扩展方法，让代码更简洁：

  public static class FolderExtensions
  {
      public static bool TryAddChild(this FolderSchema root, string targetId, FolderSchema newChild)
      {
          var target = FindFolderById(root, targetId);
          if (target != null)
          {
              target.Children.Add(newChild);
              return true;
          }
          return false;
      }
  
      private static FolderSchema FindFolderById(FolderSchema current, string targetId)
      {
          // 递归或迭代实现...
      }
  }
  

  使用时直接调用：project.RootFolder.TryAddChild(targetFolderId, newFolder);
• 确保文件夹Id的唯一性，避免出现多个Id相同的文件夹导致只找到第一个匹配项。

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