编程中的每一个决定都会对性能和清晰度产生无声的影响。 在 C# 中，这样重要的选择之一就是选择正确的数据结构。

数据结构是基础支柱。 这些结构是数据生存、呼吸和交互的地方，决定了代码的效率和可读性。 但是，与所有工具一样，必须谨慎使用它们。 C# 的美妙之处在于其丰富的数据结构，每种数据结构都是针对特定场景而设计的。

性能影响

在复杂的编程舞蹈中，数据结构的选择会影响性能。 不匹配可能会导致内存过度使用、减慢操作速度或导致不必要的复杂性。

可读性和可维护性

结构良好的代码是给未来的礼物——复杂开发迷宫中的灯塔。 正确的数据结构不仅可以简化当前任务，还可以确保未来的编辑和更新顺利进行。

C# 中的数组

数组是几乎所有编程语言（包括 C#）都提供的基础数据结构。 在 C# 中，它们是一个固定大小的集合，可以容纳多个相同类型的项目。 数组的大小在创建时确定，之后无法更改。

内存注意事项

连续内存：数组的关键特征之一是它们占用连续的内存块。 这种连续的性质提供了更快的访问速度，但如果没有大的连续块可用，有时会在分配过程中带来挑战。

固定大小：由于数组具有固定大小，因此如果分配的大小未充分利用，则可能会发生内存浪费。 相反，如果数组已满，则必须创建一个更大的新数组，并复制数据，这可能效率低下。

开销：数组的内存开销较低，因为它们不需要存储附加信息，例如指向下一个元素的指针（如链表中所示）。

需要注意的事项

索引超出范围：最常见的陷阱之一是访问索引超出范围的数组。 这将抛出 IndexOutOfRangeException。

大小不可变：数组不能调整大小。 如果您需要动态大小，您可能必须考虑使用像 List<T> 这样的集合。

默认值：创建数组时，其元素会自动初始化为元素类型的默认值（例如，整数为 0，对象引用为 null）。

多维数组：C# 支持多维数组，但与单维数组相比，使用它们可能更具挑战性，特别是在可读性方面。

代码示例

// Declaring and initializing a single-dimensional array
int[] numbers = new int[5] {1, 2, 3, 4, 5};

// Declaring and working with a multidimensional array
int[,] matrix = new int[2, 2] 
{
    {1, 2},
    {3, 4}
};
int element = matrix[1,1];  // This will be 4

最佳使用建议

当元素数量固定时使用数组。 它们的恒定时间访问和低开销使它们成为具有静态数据大小的场景的最佳选择。

警惕数组边界以避免运行时错误。

如果您不确定大小要求或者您预计大小会频繁变化，则其他集合（例如 List<T>）可能更合适。

C# 中的列表：灵活的集合

C# 中的 List<T> 是一种动态数据结构，可以根据需要增长或缩小，从而在数据存储和操作方面具有很大的灵活性。

内存注意事项

内部数组：在内部，List<T> 由数组支持。 当列表中的数据超出当前数组的容量时，列表将分配一个更大的数组并将数据复制过去。 此操作在时间和内存方面可能会很昂贵。

容量与计数：List<T> 有两个属性：计数和容量。 Count 表示 List<T> 中实际包含的元素数量，Capacity 表示内部数据结构在不调整大小的情况下可以容纳的元素数量。 设置初始容量（如果已知）以避免不必要的大小调整通常是一个好习惯。

需要注意的事项

插入成本：虽然将元素添加到列表末尾平均是 O(1) 操作，但在特定索引或开头插入在最坏的情况下可能是 O(n)，因为它可能需要移位元素。

查找成本：通过索引直接访问的时间复杂度为 O，但在最坏的情况下通过值搜索元素的时间复杂度为 O(n)。

线程安全：List<T> 本质上不是线程安全的。 如果多个线程同时访问一个列表实例并且至少有一个线程修改它，则应使用同步机制（如锁）来确保数据完整性。

非唯一条目：与集合不同，列表允许非唯一条目。 根据具体情况，这既可能是一个优点，也可能是一个陷阱。

代码示例

// Initializing a list with an initial capacity
List<int> numbersList = new List<int>(100);  // Capacity set to 100

// Adding elements
numbersList.Add(1); 
numbersList.AddRange(new int[] {2, 3, 4});

// Searching for elements
bool containsThree = numbersList.Contains(3);
int indexOfThree = numbersList.IndexOf(3);  // Returns -1 if not found

最佳使用建议

对于需要频繁调整大小或元素数量不可预测的操作，List<T> 是一个合适的选择。

如果可以预测元素数量，请设置初始容量以减少内存开销。

在多线程应用程序中使用列表时，请始终注意线程安全。

C# 中的哈希表

HashSet<T> 是一个旨在保存唯一元素的集合。 它使用哈希表来实现插入、删除和搜索的恒定时间复杂度，使其对于某些操作非常高效。

内存注意事项

哈希表开销：虽然 HashSet<T> 可以为基本操作提供恒定的时间复杂度，但它是通过使用哈希表实现的，而哈希表由于存储哈希值和管理冲突而具有固有的内存开销。

动态调整大小：就像数组和列表一样，当 HashSet<T> 增长超出其当前容量时，它需要调整大小，这涉及分配更大的内存块并重新散列元素。

稀疏分配：由于哈希的工作原理，底层存储中的所有槽位可能不会被填满，从而导致一定程度的内存浪费。

需要注意的事项

元素唯一性：HashSet<T> 的核心特性是能够维护元素的唯一性。 如果您尝试添加重复项，集合将保持不变，并且 Add 方法将返回 false。

哈希函数：HashSet<T> 的效率很大程度上取决于存储类型的哈希函数。 设计不当的哈希函数可能会导致许多冲突，从而大大降低性能。

无序：HashSet<T> 中的元素没有保证的顺序。 如果排序很重要，请考虑使用 SortedSet<T>。

空值：HashSet<T> 可以为引用类型存储一个空引用。 但是，尝试添加多个空值不会引发错误，但也不会修改集合。

代码示例

// Initializing and adding elements to a HashSet
HashSet<int> uniqueNumbers = new HashSet<int>();
uniqueNumbers.Add(1);
uniqueNumbers.Add(2);
uniqueNumbers.Add(1);  // No error, but the HashSet remains {1, 2}

// Checking for an element's existence is an O(1) operation on average
bool containsTwo = uniqueNumbers.Contains(2);

最佳使用建议

当确保元素的唯一性是主要考虑因素并且需要频繁查找、插入或删除时，请使用 HashSet<T>。

如果处理自定义对象，请始终注意哈希函数。 确保其得到良好实施，以尽量减少碰撞。

如果您需要一个在确保唯一性的同时保留顺序的集合，请选择 SortedSet<T> 或其他适当的数据结构。

C# 中的字典：键值存储

C# 中的字典由 Dictionary<TKey, TValue> 类提供。 它充当映射或哈希表，允许高效检索、添加和删除值键对。

内存注意事项

哈希表结构：与 HashSet<T> 类似，字典是使用哈希表实现的，这意味着由于哈希和冲突管理，它们具有类似的开销。

配对开销：字典中的每个条目都包含一个键值对，与列表或集合等单值集合相比，导致内存使用量略多。

动态调整大小：与大多数基于哈希的集合一样，字典一旦超出其容量，就会调整大小。 这涉及分配更大的内存块、重新散列键，并且可能涉及性能成本。

需要注意的事项

唯一键：字典中的键必须是唯一的。 如果您尝试添加带有已存在键的条目，字典将抛出 ArgumentException。

键散列：字典的效率很大程度上取决于其键的散列机制。 自定义键类型的构造不当的哈希函数可能会导致频繁的冲突，从而降低字典操作的效率。

不保证顺序：尽管 .NET 的最新版本已努力维护 Dictionary<TKey, TValue> 中的插入顺序，但这并不是一个有保证的功能。 如果顺序很重要，请考虑使用 OrderedDictionary 或 SortedList<TKey, TValue>。

访问不存在的键：尝试使用不存在的键检索值将导致 KeyNotFoundException。 在检索之前，请务必使用 ContainsKey 方法检查密钥是否存在。

代码示例

// Initializing and adding key-value pairs to a Dictionary
Dictionary<string, int> studentGrades = new Dictionary<string, int>();
studentGrades["John"] = 85;
studentGrades["Jane"] = 90;

// Retrieving values using a key
int johnsGrade = studentGrades["John"];  // Will be 85

// Safely retrieving values
if (studentGrades.ContainsKey("Alice"))
{
    int aliceGrade = studentGrades["Alice"];
}

最佳使用建议

当您需要基于特定键快速查找时，尤其是在处理大型数据集时，请选择 Dictionary<TKey, TValue>。

对于自定义键类型，请投入时间设计强大的哈希函数，以确保字典的高效运行。

始终通过检查键是否存在或使用 TryGetValue 等方法来处理潜在的异常，尤其是 KeyNotFoundException。

C# 中的 Queue<T>：先进先出专家

Queue<T> 是一个集合，旨在以先进先出 (FIFO) 顺序存储元素。 它提供快速且可预测的添加和删除项目操作。

内存注意事项

动态调整大小：队列增长超出其当前容量，这涉及分配更大的内存块。

数组支持的存储：标准 Queue<T> 在底层使用数组，在需要调整大小时会带来开销。

需要注意的事项

线程安全：Queue<T> 本质上不是线程安全的。 并发访问需要替代策略或集合。

下溢：尝试从空队列中出列会引发异常。

代码示例

// Initializing and adding elements to a Queue
Queue<int> numbers = new Queue<int>();
numbers.Enqueue(1);
numbers.Enqueue(2);
int first = numbers.Dequeue();  // Returns 1

最佳使用建议

以 FIFO 方式处理项目时使用 Queue<T>。

如果需要并发访问，请考虑 ConcurrentQueue<T>。

C# 中的 Stack<T>：后进先出大师

Stack<T> 是遵循后进先出 (LIFO) 顺序的集合。 在从末尾添加或删除项目时，它特别有效。

内存注意事项

数组支持的存储：与队列一样，堆栈在内部使用数组，在动态调整大小期间引入开销。

需要注意的事项

线程安全：标准堆栈不是线程安全的。 对于并发操作，请考虑 ConcurrentStack<T>。

下溢：尝试从空堆栈中弹出将引发异常。

代码示例

// Working with a Stack
Stack<int> numbers = new Stack<int>();
numbers.Push(1);
numbers.Push(2);
int last = numbers.Pop();  // Returns 2

最佳使用建议

Stack<T> 非常适合撤消/重做功能等场景。

当多个线程同时访问堆栈时，使用并发集合。

C# 中的 LinkedList<T>：双端链接器

LinkedList<T> 表示双向链表，从两端提供 O(1) 次插入或删除。

内存注意事项

指针开销：每个节点都包含其数据和两个指针（用于下一个和前一个节点），比数组或 List<T> 消耗更多内存。

需要注意的事项

遍历时间：通过索引访问元素意味着遍历列表，比数组中直接索引访问慢。

代码示例

// Using a LinkedList
LinkedList<int> linkedList = new LinkedList<int>();
linkedList.AddLast(1);
linkedList.AddFirst(0);
int first = linkedList.First.Value;  // Returns 0

最佳使用建议

非常适合频繁插入和删除的场景。

不适合直接基于索引的访问。

C# 中的 SortedSet<T>：有序唯一值收集器

SortedSet<T> 依靠二叉搜索树以排序顺序维护唯一元素，确保 log(n) 插入和检索时间。

内存注意事项

基于树的存储：底层二叉树结构引入了用于管理层次结构和顺序的指针开销。

需要注意的事项

元素唯一性：不允许重复。 添加它们不会产生任何效果。

比较开销：集合依赖比较来维持顺序，这对于复杂类型可能会很慢。

代码示例

// SortedSet in action
SortedSet<int> sortedNumbers = new SortedSet<int> { 2, 1, 3 };
sortedNumbers.Add(2);  // No change, as 2 already exists

最佳使用建议

非常适合需要独特的排序元素的情况。

注意自定义对象的比较成本。

C# 中的 SortedDictionary<TKey, TValue>：有序对组织者

SortedDictionary<TKey, TValue> 按键的排序顺序保存键值对，确保大多数操作的 log(n) 次。

内存注意事项

基于树的存储：与 SortedSet<T> 一样，该字典使用树，增加了指针和树管理的开销。

需要注意的事项

唯一键：仅允许使用唯一键。

比较成本：对键进行排序会带来开销，尤其是对于复杂的类型。

代码示例

// Working with SortedDictionary
SortedDictionary<int, string> sortedDict = new SortedDictionary<int, string>();
sortedDict.Add(2, "Two");
sortedDict.Add(1, "One");
string first = sortedDict[1];  // Returns "One"

最佳使用建议

非常适合排序键值存储。

警惕关键比较的成本。

C# 中的 SortedList<TKey, TValue>：索引二重奏守护者

SortedList<TKey, TValue> 与 SortedDictionary<TKey, TValue> 类似，但它由数组支持，使得索引访问速度更快。

内存注意事项

动态调整大小：底层数组可能需要调整大小，从而引入开销。

需要注意的事项

内存消耗：使用两个数组（键和值），与单个数组相比，内存使用量可以增加一倍。

插入开销：在中间插入需要元素移位，这可能会很慢。

代码示例

// Using SortedList
SortedList<int, string> sortedList = new SortedList<int, string>();
sortedList.Add(2, "Two");
sortedList.Add(1, "One");
string first = sortedList[1];  // Returns "One"

最佳使用建议

最适合频繁索引访问和偶尔写入的场景。

避免在列表中间频繁插入。