遍历分组列表构建分层数据集：Item与ItemSet类实现问询

嘿，我来帮你搞定这个分层数据集的构建与遍历问题！先理清楚思路：咱们需要先完善ItemSet的核心方法，再实现从扁平分组列表到层级结构的转换，最后完成遍历逻辑。

首先，补全Item类（给它加个标识属性方便演示），并实现ItemSet的Add重载方法，让它支持添加单个Item或子ItemSet：

// 基础Item类，带名称属性用于标识
public class Item
{
    public string Name { get; set; }

    public Item(string name)
    {
        Name = name;
    }
}

// 完善后的ItemSet类，支持层级嵌套和Item添加
public class ItemSet
{
    public string Name { get; set; } // 新增名称属性，方便区分不同层级集合
    public List<ItemSet> Sets { get; set; }
    public List<Item> Items { get; set; }

    public ItemSet(string name)
    {
        Name = name;
        Sets = new List<ItemSet>();
        Items = new List<Item>();
    }

    // 重载Add方法：添加单个Item
    public void Add(Item item)
    {
        Items.Add(item);
    }

    // 重载Add方法：添加子ItemSet
    public void Add(ItemSet childSet)
    {
        Sets.Add(childSet);
    }
}

假设你手里的分组列表是扁平结构（比如每条数据包含父集合名称、当前集合名称、所属Item），我们可以用字典缓存已创建的ItemSet，快速定位父节点，高效构建层级结构：

首先定义一个辅助类来存储扁平分组数据：

// 辅助类：存储扁平格式的分组条目，用于转换为层级结构
public class GroupEntry
{
    public string ParentSetName { get; set; } // 父集合名称，null表示根层级
    public string SetName { get; set; }       // 当前集合名称
    public string ItemName { get; set; }      // 集合下的Item名称
}

然后是核心构建方法：

public static ItemSet BuildHierarchicalDataset(List<GroupEntry> flatEntries)
{
    // 用字典缓存所有已创建的ItemSet，快速查找父节点
    var setCache = new Dictionary<string, ItemSet>();
    // 创建根集合，所有无父节点的集合都挂在根下
    var rootSet = new ItemSet("Root");
    setCache.Add(rootSet.Name, rootSet);

    foreach (var entry in flatEntries)
    {
        // 如果当前集合未创建，先实例化并加入缓存
        if (!setCache.ContainsKey(entry.SetName))
        {
            setCache[entry.SetName] = new ItemSet(entry.SetName);
        }
        var currentSet = setCache[entry.SetName];

        // 确定父集合：如果父名称为空则用根集合，否则从缓存取
        var parentSet = string.IsNullOrEmpty(entry.ParentSetName) 
            ? rootSet 
            : setCache[entry.ParentSetName];

        // 将当前集合挂到父集合下，并添加Item
        parentSet.Add(currentSet);
        currentSet.Add(new Item(entry.ItemName));
    }

    return rootSet;
}

对于树形结构的ItemSet，递归遍历是最直观的方式（如果层级极深，也可以改成迭代式遍历避免栈溢出）：

public static void TraverseItemSet(ItemSet currentSet, int indentLevel = 0)
{
    // 输出当前集合名称，缩进表示层级
    Console.WriteLine($"{new string(' ', indentLevel * 2)}[ItemSet: {currentSet.Name}]");

    // 遍历当前集合下的所有Item
    foreach (var item in currentSet.Items)
    {
        Console.WriteLine($"{new string(' ', (indentLevel + 1) * 2)}- Item: {item.Name}");
    }

    // 递归遍历所有子集合
    foreach (var childSet in currentSet.Sets)
    {
        TraverseItemSet(childSet, indentLevel + 1);
    }
}

咱们用一组测试数据来验证整个流程：

// 模拟扁平分组数据
var flatGroupData = new List<GroupEntry>
{
    new GroupEntry { ParentSetName = null, SetName = "Electronics", ItemName = "Laptop" },
    new GroupEntry { ParentSetName = "Electronics", SetName = "Phones", ItemName = "Smartphone" },
    new GroupEntry { ParentSetName = "Phones", SetName = "Accessories", ItemName = "Phone Case" },
    new GroupEntry { ParentSetName = null, SetName = "Clothing", ItemName = "T-Shirt" }
};

// 构建分层数据集
var hierarchicalData = BuildHierarchicalDataset(flatGroupData);

// 遍历输出结构
TraverseItemSet(hierarchicalData);

运行后会输出：

[ItemSet: Root]
  [ItemSet: Electronics]
    - Item: Laptop
    [ItemSet: Phones]
      - Item: Smartphone
      [ItemSet: Accessories]
        - Item: Phone Case
  [ItemSet: Clothing]
    - Item: T-Shirt

小提示：如果你的原始分组数据不是GroupEntry这种格式，只需要调整构建方法里的逻辑，把你的数据映射到“父集合-当前集合-Item”的关系即可。

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