C# 使用什么样的数据结构？

我正在从事一个项目，需要跟踪：

• 仅一个字符串名称的5-6个根项目
• 每个根项需要有多个不同标识符类型（int、string、float等）的子项。一个根的所有子级都是相同的类型，但每个根都有不同的子级类型
• 用户需要能够从每个根目录中添加/删除子目录
• 稍后我将需要单独访问每个子级，并在需要时执行字符串操作和解析

我考虑过使用字典，其中键是字符串，值是对象列表。或者为每个根项目创建一个唯一的类，并且每个类将包含一个子类列表

有人有什么好的建议吗？我对OOP还很陌生，请耐心点：）

---

谢谢

听起来像是

字典

是一个很好的候选者

键将是字符串（根）。根的子元素是一个元组。我们可以向元组添加项。谢谢你指出这一点

---

一个带有

列表的泛型类如何包含子类：

public class Root<T>
{
    private List<T> children = null;

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

    public string Name { get; set; }

    public List<T> Children
    {
        get
        {
            if (children == null)
            {
                children = new List<T>();
            }

            return children;
        }
    }
}

Root<int> intRoot = new Root<int>("IntRoot");
intRoot.Children.Add(23);
intRoot.Children.Add(42);

Root<string> stringRoot = new Root<string>("StringRoot");
stringRoot.Children.Add("String1");
stringRoot.Children.Add("String2");
stringRoot.Children.Add("String3");
stringRoot.Children.Add("String4");

公共接口IRoot{}
公共类根项：IRoot
{
公共字符串名称{get；set；}
公共列表子项{get；set；}
}

然后保留一本
字典
来保存它们

Dictionary<string, IRoot> hair = new Dictionary<string, IRoot>();
hair.Add(
  new RootItem<int>()
      {
        Name = "None",
        Children = new List<int>() {1, 2, 3, 4}
      }
);

hair.Add(
  new RootItem<decimal>()
      {
        Name = "None",
        Children = new List<decimal>() {1m, 2m, 3m, 4m}
      }
);

Dictionary hair=newdictionary（）；
头发，加上(
新根项（）
{
Name=“无”，
Children=新列表（）{1,2,3,4}
}
);
头发，加上(
新根项（）
{
Name=“无”，
Children=新列表（）{1m，2m，3m，4m}
}
);
这里有一种方法。需要进行大量的铸造工作，但它完成了工作：

    static void Main(string[] args)
    {
        Dictionary<string, IRootCollection> values = new Dictionary<string, IRootCollection>();

        values["strings"] = new RootCollection<string>();
        (values["strings"] as RootCollection<string>).Add("foo");
        (values["strings"] as RootCollection<string>).Add("bar");

        values["ints"] = new RootCollection<int>();
        (values["ints"] as RootCollection<int>).Add(45);
        (values["ints"] as RootCollection<int>).Add(86);
    }

    interface IRootCollection { }
    class RootCollection<T> : List<T>, IRootCollection { }

static void Main（字符串[]args）
{
字典值=新字典（）；
值[“strings”]=newrootcollection（）；
（值[“strings”]作为RootCollection）。添加（“foo”）；
（值[“strings”]作为RootCollection）。添加（“bar”）；
值[“ints”]=newrootcollection（）；
（值[“ints”]作为RootCollection）；
（值[“ints”]作为RootCollection）；
}
接口IRootCollection{}
类RootCollection:List，IRootCollection{}
乍一看，字典似乎就是你要找的。你想强制规定给定根的所有子项都是相同类型的吗？我正在努力找到一种方法来做到这一点。如果你愿意在没有这种类型强制的情况下生活，那么一个
字典就可以了。给定根目录的子目录不必是相同的类型，事实上，如果不是，可能会更好。因此，有了元组，我就可以动态添加/删除我想要的任何类型的项了？我的第一眼不正确-jonnyGold的解决方案快速而优雅。您无法在运行时从元组中添加或删除项。
tuple
构造允许异构
字典
值，但是@swifferclean提到，每个值都是一个任意列表，其项的类型都相同。它是需要改变的值列表的类型。。我懂了。所以使用列表可能更好？我认为您可以在运行时从列表中添加和删除项目，对吗？谢谢。作为记录，@FishBasketGordo提供了一个更加充实的示例。
Dictionary
无效，因为没有泛型参数的
RootItem
是一个不完整的类型。这一点很好。我错过了。我使用Visual Studio编写这些代码示例。仍然不太正确。。。你不能构建一个
字典
——你必须给它一个具体的类型，然后所有或你的子列表现在都是相同的类型。但是现在，你只能有一个类型T的子列表。这是我想到的，但是OP也想要一个
字典
，我认为这是不可能的；您可以有一个基本的非泛型
RootItem
类，但在这个过程中您会失去一些类型安全性…很抱歉我缺乏编程知识！那么，当您在等号的右侧声明introt和stringRoot时，您基本上是在调用Root（字符串名称）函数吗？或类中的根（字符串名）“thing”被认为是构造函数吗？它是一个构造函数。每当您看到
new
操作符时，您都在处理构造函数。另外，您可以通过查看类本身来判断它是一个构造函数，因为它与类的名称相同，并且没有显式的返回类型。
Dictionary<string, IRoot> hair = new Dictionary<string, IRoot>();
hair.Add(
  new RootItem<int>()
      {
        Name = "None",
        Children = new List<int>() {1, 2, 3, 4}
      }
);

hair.Add(
  new RootItem<decimal>()
      {
        Name = "None",
        Children = new List<decimal>() {1m, 2m, 3m, 4m}
      }
);

    static void Main(string[] args)
    {
        Dictionary<string, IRootCollection> values = new Dictionary<string, IRootCollection>();

        values["strings"] = new RootCollection<string>();
        (values["strings"] as RootCollection<string>).Add("foo");
        (values["strings"] as RootCollection<string>).Add("bar");

        values["ints"] = new RootCollection<int>();
        (values["ints"] as RootCollection<int>).Add(45);
        (values["ints"] as RootCollection<int>).Add(86);
    }

    interface IRootCollection { }
    class RootCollection<T> : List<T>, IRootCollection { }