C# 在数据结构中存储数据

Question

我有这样的数据......

1 -> a 10
     b xyz
     c 40 
12 -> a 20
     b os 
8 -> ..............

如何将这些数据存储在数据结构中。哪个 DS 适合 在 C# 中。

1,12,8 是对象编号。 & a,b,c 是那里的属性键值对。

它是 .. 文件的内部文件表示。所以我想存储它以供进一步操作。

Answer 1

匿名类和隐式类型数组 通过消除类的需要来缩短代码 源代码中的模板和显式类型。 此功能的一个大缺点是元素是只读的。

除了将其粘贴到您的源文件中之外，此示例中没有遗漏其他代码。

简洁、匿名的数据结构

    // Strongly-typed anonymous data structure.

    var allData = new[] { // array of parts
        new { Num = 1, Details = new[] { // each part is keyed by object num
                new {KeyChar = 'a', StringValue = "10"} , // key/value pair details
                new {KeyChar = 'b', StringValue = "xyz"} ,
                new {KeyChar = 'c', StringValue = "40"} } 
        },
        new { Num = 12, Details = new[] { 
                new {KeyChar = 'a', StringValue = "20"} ,
                new {KeyChar = 'b', StringValue = "os"} }
        },
        new { Num = 8, Details = new[] { 
            new {KeyChar = 'n', StringValue = "etc..."} }
        }
    };

类型由您的一致数据声明自动推断并由 C# 3.x+ 编译器生成到 IL 中。

示例用法

迭代你的数据结构并打印它....

    foreach (var part in allData) {
        Console.WriteLine("Object #" + part.Num + " contains the details: ");
        foreach (var detail in part.Details)
            Console.WriteLine(" - key: " + detail.KeyChar + ", value: " + detail.StringValue);
    }

规定

• var ，对于隐式类型的变量，不能在类范围内使用(即制作字段) - 它仅限于方法范围(即作为局部变量)。

• 使用匿名类型时需要注意一些事项，例如:Can't return anonymous type from method? Really?

• MSDN documentation描述了一些额外的行为和“陷阱”。

  - 匿名实例是只读的，因此您将需要一种不同的方式来存储和持久化修改。这可能会使其无法满足您的要求。

• 但是，将这个答案作为一个选项包括在内很有趣，因为我今天学到了一些新东西，如果没有别的的话。 :)

---

编辑/更新:可写版本

(修改为等效的可写数据结构)

上述数据结构的等效可写版本如下，using System.Collections.Generic; :

// Initialization (present data is read/writable)
Dictionary<int, List<Detail>> manageableData = new Dictionary<int, List<Detail>>() 
{
    {1, new List<Detail>() { 
        new Detail {KeyChar = 'a', StringValue="10"},
        new Detail {KeyChar = 'b', StringValue="xyz"}, 
        new Detail {KeyChar = 'c', StringValue="40"}  
        } },

    {12, new List<Detail>() { 
        new Detail {KeyChar = 'a', StringValue="20"},
        new Detail {KeyChar = 'b', StringValue="os"}
        } }
};


// Can continue populating after initialization. E.g...
manageableData.Add(8, new List<Detail>() {
        new Detail {KeyChar = 'n', StringValue="etc..."},
        new Detail {KeyChar = 'z', StringValue="etc..."}
});

声明了一个小的辅助类，使详细数据的初始化更具可读性； Detail辅助类替换了可能简单的 KeyValuePair<char, string> .根据口味。

public class Detail {
    public char KeyChar { get; set; }
    public string StringValue { get; set; }
}

...有效地允许我们使用new Detail {KeyChar = 'b', StringValue="xyz"}对于细节项目的初始化而不是 new KeyValuePair<char, string>('b', "xyz") .

示例用法

迭代你的数据结构并打印它....

foreach (var part in manageableData) {
    Console.WriteLine("Object #" + part.Key + " contains the details: ");
    foreach (var detail in part.Value)
        Console.WriteLine(" - key: " + detail.KeyChar + ", value: " + detail.StringValue);
}

---

可写数据结构的另一种变体(不那么抽象)

(没有不必要的抽象——只有原始集合)

如果没有自定义 Detail 类，您将像这样嵌套字典

Dictionary<int, Dictionary<char, string>> data2 = new Dictionary<int, Dictionary<char, string>>() 
{
    {1, new Dictionary<char, string>() { 
        {'a', "10"},
        {'b', "xyz"}, 
        {'c', "40"}  
        } }
};

data2.Add(8, new Dictionary<char,string>() {
        {'n', "etc..."},
        {'z', "etc..."}
});

// SAMPLE USAGE:
// Once again, very minor changes to the mechanism of accessing the data structure:

foreach (var part in data2) {
    Console.WriteLine("Object #" + part.Key + " contains the details: ");
    foreach (var detail in part.Value)
        Console.WriteLine(" - key: " + detail.Key + ", value: " + detail.Value);
}

---

为可读性命名为“Aliasing”

这是用于存储文件对象和属性的普通嵌套字典方案。

// initialize
Dictionary<int, Dictionary<char, string>> data1 = new Dictionary<int, Dictionary<char, string>>() 
{
    {1, new Dictionary<char, string>() { 
        {'a', "10"},
        {'b', "xyz"}, 
        {'c', "40"}  
        }}
};
// populate 
data1.Add(8, new Dictionary<char, string>() {
    {'n', "etc..."},
    {'z', "etc..."}
    });

制作更具描述性/可读性的版本

有很多方法可以使嵌套数据结构更具可读性。这是一个显示一些可读性差异的示例。这可能不是最聪明的方法，因为它只是为了别名而添加了几个类型，但仍然......

这是与上面完全相同的数据结构，但使用“别名”名称:

// initialize
FileObjects data2 = new FileObjects() 
{
    {1, new ObjectAttributes() { 
        {'a', "10"},
        {'b', "xyz"}, 
        {'c', "40"}  
        }}
};
// populate 
data2.Add(8, new ObjectAttributes() {
    {'n', "etc..."},
    {'z', "etc..."}
    });

以下“别名”定义有效地将原始泛型(通过继承)重命名为更具描述性的类型并隐藏了类型参数。

public class ObjectAttributes : Dictionary<char, string> { }
public class FileObjects : Dictionary<int, ObjectAttributes> { }

在这种方法变得可行之前，您可能需要更多嵌套数据。