C# 技术使用笔记：C#中字典（Dictionary）的使用

最新推荐文章于 2025-05-25 07:30:00 发布

caifox菜狐狸

最新推荐文章于 2025-05-25 07:30:00 发布

阅读量2.4k

点赞数 23

CC 4.0 BY-SA版权

分类专栏： C# 技术使用笔记文章标签： c# 笔记字典 Dictionary 遍历循环集合

本文链接：https://blog.csdn.net/caifox/article/details/146768804

C# 技术使用笔记专栏收录该内容

105 篇文章

订阅专栏

在 C# 程序设计中，字典是一种非常强大且常用的集合类型，它以键值对的形式存储数据，能够高效地实现数据的存储、检索和管理。无论是处理复杂的数据结构，还是实现高效的查找算法，字典都扮演着不可或缺的角色。掌握字典的使用方法，不仅可以提高代码的可读性和可维护性，还能显著提升程序的性能。本文将从字典的基础概念、声明与初始化、基本操作、遍历方法、高级用法，到常见问题与注意事项等多个方面，为你全面剖析 C# 字典的使用技巧，帮助你在实际开发中灵活运用字典，解决各种复杂问题。

1. 基础概念

1.1 定义与作用

字典（Dictionary）是C#中一种非常重要的集合类型，它存储键值对（Key-Value Pair），键（Key）是唯一的，而值（Value）可以重复。字典的主要作用是通过键快速检索对应的值，这种键值映射的方式使得数据的查找和管理更加高效。

高效查找：字典的查找速度非常快，其时间复杂度接近O(1)，这使得它在处理大量数据时具有显著的优势。例如，在一个包含100万条数据的字典中，查找一个特定键的值几乎可以在瞬间完成，而如果使用列表（List）进行查找，可能需要遍历整个列表，时间复杂度为O(n)。
数据组织：字典可以将相关的数据组织在一起，通过键来标识每个数据项。例如，可以使用字典来存储学生的成绩，其中键是学生的姓名，值是对应的分数。这种方式使得数据的管理和访问更加直观和方便。
动态扩展：字典的大小可以根据需要动态扩展，不需要预先指定容量。当添加新的键值对时，字典会自动调整内部结构以容纳更多的数据，这使得它在处理不确定数量的数据时非常灵活。

1.2 与其他集合对比

C#提供了多种集合类型，每种集合都有其独特的特点和适用场景。字典与其他常见集合类型（如数组、列表和集合）相比，具有以下区别：

数组（Array）：
- 特点：数组是一个固定大小的集合，元素通过索引访问，索引从0开始。数组的大小在创建时必须指定，且不能改变。
- 与字典的对比：数组的查找效率较低，需要通过索引逐个查找。而字典通过键查找值，效率更高。此外，数组的大小固定，而字典的大小可以动态扩展。
- 示例：如果需要存储一组固定数量的整数，可以使用数组；但如果需要存储键值对数据，字典是更好的选择。
列表（List）：
- 特点：列表是一个动态数组，可以动态添加和删除元素。列表的元素通过索引访问，索引从0开始。
- 与字典的对比：列表的查找效率较低，需要通过索引逐个查找。而字典通过键查找值，效率更高。此外，列表只能存储单一类型的值，而字典可以存储键值对。
- 示例：如果需要存储一组动态变化的整数，可以使用列表；但如果需要存储键值对数据，字典是更好的选择。
集合（HashSet）：
- 特点：集合是一个不包含重复元素的集合，元素无序存储。集合提供了高效的添加、删除和查找操作。
- 与字典的对比：集合只存储值，不存储键值对。字典通过键查找值，而集合只能通过值进行查找。集合的查找效率很高，但字典在处理键值对数据时更灵活。
- 示例：如果需要存储一组不重复的字符串，可以使用集合；但如果需要存储键值对数据，字典是更好的选择。

2. 字典的声明与初始化

2.1 使用字典类声明

在C#中，字典是通过Dictionary<TKey, TValue>类来实现的，其中TKey表示键的类型，TValue表示值的类型。声明一个字典的基本语法如下：

Dictionary<TKey, TValue> dictionaryName = new Dictionary<TKey, TValue>();

例如，如果要声明一个存储学生姓名（键）和成绩（值）的字典，可以这样写：

Dictionary<string, int> studentScores = new Dictionary<string, int>();

这里，string是键的类型，表示学生的姓名；int是值的类型，表示学生的成绩。

2.2 初始化字典

初始化字典有多种方式，以下是一些常见的方法：

2.2.1 使用`Add`方法逐个添加键值对

在声明字典后，可以使用Add方法逐个添加键值对。例如：

Dictionary<string, int> studentScores = new Dictionary<string, int>();
studentScores.Add("Alice", 90);
studentScores.Add("Bob", 85);
studentScores.Add("Charlie", 95);

这种方式适用于在运行时动态添加数据。

2.2.2 使用集合初始化器

从C# 3.0开始，可以使用集合初始化器来初始化字典，这种方式更加简洁。例如：

Dictionary<string, int> studentScores = new Dictionary<string, int>
{
    {"Alice", 90},
    {"Bob", 85},
    {"Charlie", 95}
};

这种方式在声明字典的同时直接添加了键值对，代码更加清晰易读。

2.2.3 使用`Dictionary`构造函数初始化

还可以通过Dictionary的构造函数来初始化字典，传入一个键值对的集合。例如：

var keyValuePairs = new[]
{
    new KeyValuePair<string, int>("Alice", 90),
    new KeyValuePair<string, int>("Bob", 85),
    new KeyValuePair<string, int>("Charlie", 95)
};

Dictionary<string, int> studentScores = new Dictionary<string, int>(keyValuePairs);

这种方式在某些情况下可以提供更多的灵活性，例如从其他数据结构中初始化字典。

2.2.4 使用`ToDictionary`方法

如果有一个列表或其他集合类型的数据，可以使用ToDictionary方法将其转换为字典。例如：

var students = new List<Student>
{
    new Student { Name = "Alice", Score = 90 },
    new Student { Name = "Bob", Score = 85 },
    new Student { Name = "Charlie", Score = 95 }
};

Dictionary<string, int> studentScores = students.ToDictionary(s => s.Name, s => s.Score);

这里，ToDictionary方法的第一个参数指定了键的提取方式，第二个参数指定了值的提取方式。这种方式适用于从已有数据结构中快速生成字典。

3. 字典的基本操作

3.1 添加键值对

向字典中添加键值对是字典操作中的常见需求。可以通过Add方法来实现，该方法接受两个参数：键和值。例如：

Dictionary<string, int> studentScores = new Dictionary<string, int>();
studentScores.Add("Alice", 90);
studentScores.Add("Bob", 85);

需要注意的是，字典中的键是唯一的，如果尝试添加一个已经存在的键，程序会抛出ArgumentException异常。为了避免这种情况，可以在添加之前使用ContainsKey方法检查键是否已经存在：

if (!studentScores.ContainsKey("Charlie"))
{
    studentScores.Add("Charlie", 95);
}

此外，还可以通过索引器的方式来添加键值对，这种方式更加简洁：

studentScores["David"] = 88;

如果键已经存在，这种方式会覆盖原有的值。

3.2 删除键值对

从字典中删除键值对可以通过Remove方法实现，该方法接受一个键作为参数，并返回一个布尔值，表示是否删除成功。例如：

bool isRemoved = studentScores.Remove("Bob");
if (isRemoved)
{
    Console.WriteLine("Bob's score has been removed.");
}
else
{
    Console.WriteLine("Bob's score does not exist.");
}

如果需要删除字典中的所有键值对，可以使用Clear方法：

studentScores.Clear();

这将清空整个字典，使其大小变为0。

3.3 查找键值对

查找键值对是字典的核心功能之一。可以通过ContainsKey方法来检查字典中是否存在某个键：

if (studentScores.ContainsKey("Alice"))
{
    Console.WriteLine("Alice's score exists.");
}
else
{
    Console.WriteLine("Alice's score does not exist.");
}

如果需要检查字典中是否存在某个值，可以使用ContainsValue方法：

if (studentScores.ContainsValue(90))
{
    Console.WriteLine("There is a student with a score of 90.");
}
else
{
    Console.WriteLine("No student has a score of 90.");
}

需要注意的是，ContainsValue方法的效率较低，因为它需要遍历整个字典来查找值。

如果需要获取某个键对应的值，可以通过索引器来实现：

if (studentScores.ContainsKey("Alice"))
{
    int score = studentScores["Alice"];
    Console.WriteLine($"Alice's score is {score}.");
}

此外，还可以使用TryGetValue方法来获取键对应的值，该方法接受两个参数：键和一个输出参数用于存储值，并返回一个布尔值，表示是否找到键：

if (studentScores.TryGetValue("Alice", out int score))
{
    Console.WriteLine($"Alice's score is {score}.");
}
else
{
    Console.WriteLine("Alice's score does not exist.");
}

这种方式更加安全，因为它不会抛出异常，即使键不存在。

4. 遍历字典

4.1 使用foreach遍历键值对

在C#中，foreach循环是遍历字典键值对的常用方式。通过foreach循环，可以方便地访问字典中的每个键值对。字典的KeyValuePair<TKey, TValue>结构提供了Key和Value两个属性，分别用于访问键和值。以下是一个示例代码：

Dictionary<string, int> studentScores = new Dictionary<string, int>
{
    {"Alice", 90},
    {"Bob", 85},
    {"Charlie", 95}
};

foreach (KeyValuePair<string, int> kvp in studentScores)
{
    Console.WriteLine($"Key: {kvp.Key}, Value: {kvp.Value}");
}

运行结果如下：

Key: Alice, Value: 90
Key: Bob, Value: 85
Key: Charlie, Value: 95

这种方式简洁明了，适用于大多数需要遍历字典的场景。

4.2 使用for循环遍历

虽然foreach循环是遍历字典的推荐方式，但在某些特殊情况下，也可以使用for循环来遍历字典。不过，需要注意的是，字典的键和值是通过Keys和Values属性分别存储的，它们是Dictionary<TKey, TValue>.KeyCollection和Dictionary<TKey, TValue>.ValueCollection类型，不能直接通过索引访问。因此，使用for循环遍历字典时，通常需要借助Keys或Values集合来实现。以下是一个示例代码：

Dictionary<string, int> studentScores = new Dictionary<string, int>
{
    {"Alice", 90},
    {"Bob", 85},
    {"Charlie", 95}
};

string[] keys = studentScores.Keys.ToArray();
for (int i = 0; i < keys.Length; i++)
{
    Console.WriteLine($"Key: {keys[i]}, Value: {studentScores[keys[i]]}");
}

运行结果如下：

Key: Alice, Value: 90
Key: Bob, Value: 85
Key: Charlie, Value: 95

这种方式相对复杂，但在某些需要对键或值进行特殊处理的场景下，可能会更加灵活。

5. 字典的高级用法

5.1 键的唯一性与值的重复性

在C#字典中，键的唯一性是其核心特性之一，而值则可以重复。这种特性使得字典在某些场景下具有独特的优势，但也需要注意一些细节。

键的唯一性：字典通过哈希表来实现键的唯一性。当向字典中添加键值对时，字典会根据键的哈希值来确定其存储位置。如果尝试添加一个已经存在的键，字典会抛出ArgumentException异常。这种机制确保了键的唯一性，使得可以通过键快速检索对应的值。例如，在一个存储用户信息的字典中，可以使用用户的ID作为键，这样可以通过ID快速查找用户的信息，而不用担心出现重复的ID。
值的重复性：与键不同，字典中的值是可以重复的。这意味着同一个值可以与多个键关联。例如，在一个存储学生课程成绩的字典中，多个学生可能拥有相同的课程成绩，但每个学生的姓名（键）是唯一的。这种特性使得字典可以灵活地存储和管理数据，但需要注意在某些场景下可能需要对值进行额外的处理。例如，如果需要统计某个值出现的次数，就需要遍历整个字典并统计对应值的出现次数。

5.2 多线程环境下的字典操作

在多线程环境下，对字典的操作需要特别注意线程安全问题。由于字典的内部结构可能会在添加、删除或查找操作时发生变化，因此在多线程并发访问时可能会导致数据不一致或其他问题。

线程安全问题：在多线程环境下，如果多个线程同时对字典进行写操作（如添加或删除键值对），可能会导致字典的内部结构被破坏，从而引发异常或数据不一致。例如，当一个线程正在添加键值对时，另一个线程可能同时删除了一个键值对，这可能会导致正在添加的键值对无法正确存储，或者导致字典的内部哈希表结构出现错误。
解决方法：为了确保线程安全，可以使用锁（如lock语句）来同步对字典的访问。通过在访问字典时加锁，可以确保同一时间只有一个线程可以对字典进行写操作，从而避免线程安全问题。例如：

Dictionary<string, int> studentScores = new Dictionary<string, int>();
object lockObject = new object();

void AddScore(string name, int score)
{
    lock (lockObject)
    {
        studentScores.Add(name, score);
    }
}

void RemoveScore(string name)
{
    lock (lockObject)
    {
        studentScores.Remove(name);
    }
}

在上述代码中，通过lock语句对字典的添加和删除操作进行了同步，确保了线程安全。需要注意的是，虽然使用锁可以解决线程安全问题，但可能会导致性能下降，特别是在高并发场景下。因此，在实际应用中需要根据具体场景权衡线程安全和性能之间的关系。

6. 常见问题与注意事项

6.1 键不存在时的处理

在使用字典时，经常会遇到尝试访问不存在的键的情况。这种情况下，如果不进行适当的处理，程序可能会抛出异常。以下是几种常见的处理方式：

使用ContainsKey方法检查：在访问字典中的键之前，可以使用ContainsKey方法来检查该键是否存在。如果键存在，则继续访问；如果键不存在，则可以进行相应的处理。例如：
```
if (studentScores.ContainsKey("David"))
{
    Console.WriteLine($"David's score is {studentScores["David"]}");
}
else
{
    Console.WriteLine("David's score does not exist.");
}
```
这种方式可以有效避免因键不存在而导致的异常。
使用TryGetValue方法：TryGetValue方法是另一种处理键不存在情况的推荐方式。该方法接受两个参数：键和一个输出参数用于存储值，并返回一个布尔值，表示是否找到键。如果键存在，则返回true，并将对应的值存储到输出参数中；如果键不存在，则返回false。例如：
```
if (studentScores.TryGetValue("David", out int score))
{
    Console.WriteLine($"David's score is {score}");
}
else
{
    Console.WriteLine("David's score does not exist.");
}
```
TryGetValue方法不仅避免了异常，而且比直接访问字典的索引器更高效，因为它只需要一次哈希计算。
提供默认值：在某些情况下，如果键不存在，可以为字典提供一个默认值。例如，可以使用GetValueOrDefault方法（需要引入System.Collections.Generic命名空间）来实现：
```
int score = studentScores.GetValueOrDefault("David", 0);
Console.WriteLine($"David's score is {score}");
```
如果键"David"不存在，则score将被赋值为默认值0。

6.2 字典容量与性能

字典的容量和性能是使用字典时需要考虑的重要因素。合理的容量设置可以提高字典的性能，避免不必要的内存分配和哈希表重组。

初始容量：在创建字典时，可以通过指定初始容量来优化性能。如果事先知道字典将存储的键值对数量，可以设置一个合适的初始容量。例如：
```
Dictionary<string, int> studentScores = new Dictionary<string, int>(100);
```
这里，初始容量被设置为100。如果字典的大小接近初始容量，这可以减少哈希表的重组次数，从而提高性能。如果初始容量设置得过大，可能会浪费内存；如果设置得过小，则可能导致频繁的哈希表重组。
自动扩容机制：当字典中的键值对数量超过当前容量时，字典会自动扩容。扩容操作涉及到重新计算哈希值和重新分配内存，这可能会导致性能下降。因此，合理设置初始容量可以减少扩容的次数，提高字典的整体性能。

性能测试：在实际应用中，可以通过性能测试来评估字典的性能。例如，可以使用Stopwatch类来测量字典的添加、查找和删除操作的时间。以下是一个简单的性能测试示例：

using System.Diagnostics;

Dictionary<string, int> studentScores = new Dictionary<string, int>(1000000);

Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();

for (int i = 0; i < 1000000; i++)
{
    studentScores.Add($"Student{i}", i);
}

stopwatch.Stop();
Console.WriteLine($"Adding 1,000,000 items took {stopwatch.ElapsedMilliseconds} ms");

stopwatch.Restart();
for (int i = 0; i < 1000000; i++)
{
    studentScores.TryGetValue($"Student{i}", out int score);
}

stopwatch.Stop();
Console.WriteLine($"Searching 1,000,000 items took {stopwatch.ElapsedMilliseconds} ms");

通过这种方式，可以了解字典在不同操作下的性能表现，从而优化字典的使用。

哈希冲突与负载因子：字典的性能还受到哈希冲突和负载因子的影响。哈希冲突是指不同的键具有相同的哈希值，这可能导致性能下降。负载因子是指字典中已使用的键值对数量与总容量的比值。当负载因子接近1时，字典会自动扩容。合理的负载因子可以平衡内存使用和性能。在C#中，默认的负载因子约为0.75，这在大多数情况下可以提供良好的性能。

7. 总结

在本教程中，我们深入探讨了 C# 中字典的使用方法，从基础概念到高级用法，再到常见问题与注意事项，全面覆盖了字典在实际开发中的应用场景。

7.1 字典的核心特性与优势

字典是一种基于键值对的集合类型，其核心特性是键的唯一性和通过键快速检索值的能力。字典的查找效率非常高，时间复杂度接近 O(1)，这使得它在处理大量数据时具有显著的优势。此外，字典的动态扩展能力使其能够灵活地适应数据量的变化，而无需预先指定容量。

7.2 字典的声明与初始化

我们详细介绍了字典的声明和初始化方法，包括使用 Add 方法逐个添加键值对、集合初始化器、Dictionary 构造函数和 ToDictionary 方法。这些方法各有优势，可以根据具体需求选择合适的初始化方式。

7.3 字典的基本操作

字典的基本操作包括添加、删除和查找键值对。通过 Add 方法可以添加新的键值对，但需要注意键的唯一性；Remove 方法用于删除键值对，而 Clear 方法可以清空整个字典。查找键值对时，ContainsKey 和 TryGetValue 方法是常用的工具，它们可以有效避免因键不存在而导致的异常。