C#集合框架核心教程：10分钟精通List、Queue、Stack的高效运用

# 1. C#集合框架概述

C#集合框架是.NET平台中用于存储和操作数据集合的一套类库。其设计目标是提供统一的接口和数据结构，以方便开发者处理数据集合。C#集合框架分为多种类型，如List、Queue、Stack等，每一类型都有其特定用途，且其内部实现和性能特点也不尽相同。

在这一章中，我们将对C#集合框架做基础性的介绍，包括框架中的核心概念和主要功能。首先，我们会探讨集合框架的体系结构和设计原则，然后深入理解各种集合类型的基本用法和适用场景。我们会通过实例演示来展示这些集合类型在实际应用中的灵活性和强大功能。这些基础概念是理解后续章节中更高级用法的前提，为接下来对C#集合框架的深入分析打下坚实的基础。

# 2. List集合的深入剖析与实践

## 2.1 List集合的内部机制

### 2.1.1 List集合的数据结构

List集合是一种基于数组的集合类型，它在内部使用动态数组来存储元素，支持快速的随机访问以及元素的动态添加和删除。List集合中的元素是有序的，这意味着每个元素都有一个与之对应的索引位置。

由于List集合是基于数组实现的，它在连续的内存空间中存储数据，这样做的好处是可以通过索引直接访问任何位置的元素，这一操作的时间复杂度为O(1)。然而，List集合在添加和删除元素时，可能需要进行数组的扩展和收缩操作，这会涉及到数组元素的移动，从而影响性能，尤其是在列表的末尾之外的位置进行添加和删除操作时。

### 2.1.2 List集合的性能特点

List集合的性能特点主要体现在以下几个方面：

- **时间复杂度**：对于随机访问操作，List集合的时间复杂度为O(1)；而对于添加或删除操作，如果操作的位置接近列表的末尾，时间复杂度为O(1)，但如果操作的位置接近列表的开始，则时间复杂度为O(n)，因为需要将目标位置之后的所有元素进行移动。

- **空间效率**：List集合利用动态数组实现，它会预留一定的空间以避免频繁的内存分配和数组扩容操作。这使得List集合在空间使用上相对高效，但同时也要考虑到预留空间可能导致内存的不完全利用。

- **内存连续性**：List集合的元素存储在连续的内存地址中，这有利于CPU缓存的利用，因此在某些情况下能够提供更快的访问速度。

## 2.2 List集合的操作详解

### 2.2.1 增删改查操作

List集合提供了一系列的方法来完成增删改查操作。以下是一些常用的方法及其描述：

- **Add**：向List集合的末尾添加一个元素。
- **Insert**：在指定的索引位置插入一个元素。
- **Remove**：移除指定的元素，如果存在多个相同的元素，只移除第一个。
- **RemoveAt**：移除指定索引位置的元素。
- **Clear**：清除List集合中的所有元素。
- **Find**：根据提供的谓词找到符合条件的第一个元素。
- **FindAll**：找到所有符合条件的元素并返回一个新的列表。

### 2.2.2 迭代器的使用

迭代器（Iterator）允许遍历集合中的元素，而不需要了解集合的内部表示。List集合实现了IEnumerable和IEnumerator接口，从而支持foreach循环等迭代操作。下面是一个使用迭代器遍历List集合的示例代码：

List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };

foreach (int number in numbers)
{
    Console.WriteLine(number);
}

// 或者使用迭代器
using (IEnumerator<int> enumerator = numbers.GetEnumerator())
{
    while (enumerator.MoveNext())
    {
        int current = enumerator.Current;
        Console.WriteLine(current);
    }
}

在上述代码中，我们首先创建了一个包含5个整数的List集合，然后通过foreach循环遍历集合中的每个元素。在使用迭代器时，我们获取了List集合的枚举器（Enumerator），并通过MoveNext方法逐个访问集合中的元素。

## 2.3 List集合在项目中的应用案例

### 2.3.1 排序和搜索场景

List集合在排序和搜索场景中非常有用，因为它提供了多种排序和搜索方法。List集合自带的排序方法是`Sort()`，它会直接修改原列表，使其元素按照默认的比较器（对于数值类型是升序，对于引用类型则需要实现IComparer接口）进行排序。以下是一个简单的排序示例：

List<int> numbers = new List<int> { 3, 1, 4, 1, 5, 9, 2 };

numbers.Sort(); // 对列表进行升序排序

foreach (int number in numbers)
{
    Console.WriteLine(number);
}

在搜索场景中，List集合提供了`BinarySearch`方法，该方法可以高效地在已排序的List中查找元素。使用此方法之前，必须确保列表已排序。否则，返回结果是不确定的。以下是一个使用`BinarySearch`方法的示例：

List<string> words = new List<string> { "apple", "banana", "cherry", "date" };
words.Sort(); // 需要先对列表进行排序

int index = words.BinarySearch("cherry"); // 返回索引为2

if (index >= 0)
{
    Console.WriteLine($"Found at index: {index}");
}
else
{
    Console.WriteLine("Element not found.");
}

### 2.3.2 处理复杂数据结构的实例

List集合不仅可以存储简单的数据类型，还可以存储对象。当存储自定义对象时，可以利用泛型类型参数来限定存储对象的类型，这样可以提供编译时的类型检查，防止类型错误。以下是一个处理复杂数据结构的示例：

class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    public Person(string name, int age)
    {
        Name = name;
        Age = age;
    }
}

List<Person> people = new List<Person>
{
    new Person("Alice", 30),
    new Person("Bob", 25),
    new Person("Charlie", 35)
};

// 使用LINQ查询年龄大于30的人
var olderThanThirty = people.Where(p => p.Age > 30);

foreach (var person in olderThanThirty)
{
    Console.WriteLine($"{person.Name} is {person.Age} years old.");
}

在这个例子中，我们创建了一个`Person`类来表示人，然后创建了一个存储`Person`对象的`List<Person>`。接着，我们使用LINQ的`Where`方法来筛选出年龄大于30岁的人，并遍历结果。

通过以上示例，我们可以看到List集合在处理复杂数据结构时的灵活性和强大功能。通过泛型集合，我们能够将任何类型的数据组合在一起，然后进行高效的管理和操作。

# 3. Queue集合的高效应用与技巧

## 3.1 Queue集合的工作原理

### 3.1.1 队列的基本概念

队列（Queue）是一种先进先出（First In First Out, FIFO）的数据结构，它有两个主要操作：入队（enqueue）和出队（dequeue）。在C#中，Queue集合广泛应用于任务调度、缓冲处理和事件驱动程序设计等领域。队列的核心优势在于其有序性和对数据处理的高效性，能够保证数据在处理时的顺序性和公平性。

### 3.1.2 Queue的性能分析

在实际应用中，Queue集合的性能对程序的响应时间有着直接的影响。由于队列的FIFO特性，元素的访问和操作非常快速，尤其是在处理大批量数据时，这种顺序访问模式可以减少内存的随机访问，提高程序的整体性能。然而，当涉及到频繁的增删操作时，需要考虑队列的扩容机制和内存分配效率。C#的Queue集合在内部已经优化了这些操作，以确保集合在动态变化时仍能保持较高的性能。

## 3.2 Queue集合的进阶用法

### 3.2.1 队列的并发处理

在多线程环境中，队列的并发处理成为了一个需要特别关注的问题。C#的Queue集合不是线程安全的，这意味着在多线程环境下直接操作Queue可能会导致数据不一致的问题。为了解决这一问题，可以使用锁机制来同步对Queue的操作，或者使用并发集合类如`ConcurrentQueue<T>`，该集合专为多线程设计，无需额外的锁即可保证线程安全。

var queue = new ConcurrentQueue<int>();

void EnqueueMethod(int item)
{
    queue.Enqueue(item);
}

void DequeueMethod()
{
    if (queue.TryDequeue(out int result))
    {
        Console.WriteLine(result);
    }
}

上述代码展示了如何使用`ConcurrentQueue<T>`进行线程安全的入队和出队操作。`TryDequeue`方法尝试出队，如果操作成功，则返回true并输出结果；否则返回false。

### 3.2.2 队列与异步编程

队列在异步编程模型中同样扮演着重要角色。C#中的异步编程通常结合`Task`或`async/await`模式进行。在异步处理中，队列可以作为任务的缓冲区，允许系统动态地调度和执行任务。结合异步编程，可以有效避免线程阻塞，提升程序的并发能力和响应性。

public async Task ProcessQueueAsync(Queue<int> taskQueue)
{
    while (taskQueue.Count > 0)
    {
        int task = await Task.Run(() => taskQueue.Dequeue());
        // Process task here...
    }
}

// Use the method in a task with the queue
Queue<int> taskQueue = new Queue<int>(...); // Initialize the queue with tasks
Task.Run(() => ProcessQueueAsync(taskQueue));

在此例中，`ProcessQueueAsync`方法是一个异步方法，它从队列中依次取出任务并异步执行。使用`Task.Run`，我们可以在一个新的任务中执行`ProcessQueueAsync`方法，从而不会阻塞主线程。

## 3.3 Queue集合在生产系统中的应用

### 3.3.1 消息队列的构建与管理

消息队列是生产者-消费者模型的一个典型应用，它允许系统中的不同组件通过消息传递进行通信。在.NET Core中，可以使用`System.Threading.Tasks.Dataflow`命名空间中的类来构建消息队列。消息队列在处理分布式系统的同步和异步消息传递时尤为重要，它能够有效地解耦生产者和消费者。

### 3.3.2 任务调度和工作流的实现

队列是实现任务调度和工作流管理的关键组件之一。在构建复杂的业务逻辑时，队列可以帮助我们按顺序处理一系列任务。C#中的`System.Threading.Timer`类可以用来实现定时任务调度，它可以配合队列使用，实现定时任务的排队和执行。

public class TaskScheduler
{
    private readonly Queue<Action> _taskQueue = new Queue<Action>();
    private Timer _timer;

    public void Schedule(Action task)
    {
        lock (_taskQueue)
        {
            _taskQueue.Enqueue(task);
        }
        // Initialize the timer or adjust it if necessary.
    }

    private void OnTimerCallback(object state)
    {
        Action task = null;
        lock (_taskQueue)
        {
            if (_taskQueue.Count > 0)
                task = _taskQueue.Dequeue();
        }

        if (task != null)
        {
            task();
        }
        else
        {
            _timer.Dispose();
            _timer = null;
        }
    }

    public TaskScheduler()
    {
        _timer = new Timer(OnTimerCallback, null, Timeout.Infinite, Timeout.Infinite);
    }
}

在上述代码中，`TaskScheduler`类维护了一个队列和一个计时器。当新的任务被安排时，它会添加到队列中。计时器触发回调函数`OnTimerCallback`，该函数会从队列中取出并执行任务。当队列为空时，计时器停止，以节省资源。

通过使用队列进行任务调度，可以保证任务按照预期顺序执行，这对于确保业务流程的正确性和可靠性至关重要。

# 4. Stack集合的深入理解和实践

## 4.1 Stack集合的数据结构和性能
### 4.1.1 栈的基本概念和操作

栈（Stack）是一种遵循后进先出（LIFO, Last In First Out）原则的数据结构。它仅允许在栈的一端进行插入或删除操作，这一端通常被称为"栈顶"。栈的操作主要包括压栈（push）、弹栈（pop）、查看栈顶元素（peek）和检查栈是否为空（isEmpty）。在C#中，Stack集合类已经提供了这些操作的实现。

Stack<int> stack = new Stack<int>();

// 压栈操作
stack.Push(1);
stack.Push(2);
stack.Push(3);

// 弹栈操作
int poppedValue = stack.Pop(); // 弹出的元素是3

// 查看栈顶元素
int topValue = stack.Peek(); // 返回的是2，但不从栈中移除

// 检查栈是否为空
bool isEmpty = stack.Count == 0; // 返回false，因为栈中还有元素

这些操作的时间复杂度均是O(1)，也就是说，每次操作的时间与栈内元素的数量无关。这使得栈结构在处理需要后进先出的数据管理场景中非常高效。

### 4.1.2 栈的内存管理和效率

栈的内存管理是自动的，C#中Stack类的实例对象在内部使用数组来实现。当元素被压入栈时，会在数组中分配空间。当元素被弹出时，相应的内存会被自动释放。栈的效率非常高，尤其是在操作的局部性原理方面，因为栈的访问模式与CPU的调用栈类似，能够很好地利用CPU缓存。

## 4.2 Stack集合在算法中的应用

### 4.2.1 前中后序遍历

在图和树的遍历算法中，栈是实现深度优先搜索（DFS, Depth-First Search）的基础。以二叉树的前序遍历为例，算法可以如下实现：

void PreOrderTraversal(TreeNode node) {
    if (node == null) return;
    Stack<TreeNode> stack = new Stack<TreeNode>();
    stack.Push(node);
    while (stack.Count > 0) {
        TreeNode currentNode = stack.Pop();
        Console.Write(currentNode.Value + " "); // 处理节点
        // 先压入右子节点，后压入左子节点，保证左子节点先被访问
        if (currentNode.Right != null) stack.Push(currentNode.Right);
        if (currentNode.Left != null) stack.Push(currentNode.Left);
    }
}

### 4.2.2 括号匹配问题的解决

栈可以用来解决括号匹配问题。对于一个给定的字符串，如果它包含正确的括号序列（例如“((()))”），算法可以通过维护一个栈来检查这一点：

bool AreBracketsMatched(string str) {
    Stack<char> stack = new Stack<char>();
    foreach (char c in str) {
        if (c == '(') {
            stack.Push(c);
        } else if (c == ')') {
            if (stack.Count == 0) return false; // 未找到匹配的左括号
            stack.Pop();
        }
    }
    return stack.Count == 0; // 如果栈为空，则括号匹配成功
}

## 4.3 Stack集合的实际项目应用

### 4.3.1 递归算法优化案例

递归算法虽然代码简洁，但在处理大数据集时可能会导致栈溢出错误。此时，可以将递归算法改为使用栈的迭代算法。例如，递归的树遍历可以转为非递归的栈实现：

void NonRecursivePreOrderTraversal(TreeNode root) {
    if (root == null) return;
    Stack<TreeNode> stack = new Stack<TreeNode>();
    stack.Push(root);
    while (stack.Count > 0) {
        TreeNode currentNode = stack.Pop();
        Console.Write(currentNode.Value + " ");
        // 先压入右子节点，后压入左子节点，保证左子节点先被访问
        if (currentNode.Right != null) stack.Push(currentNode.Right);
        if (currentNode.Left != null) stack.Push(currentNode.Left);
    }
}

### 4.3.2 表达式求值与解析

在表达式求值和解析中，栈可以用来处理运算符的优先级。例如，使用两个栈来解析和求值一个中缀表达式（如：3 + 5 * 2）：

int EvaluateExpression(string expr) {
    // 伪代码，省略细节
    Stack<int> values = new Stack<int>();
    Stack<char> ops = new Stack<char>();
    foreach (var token in Tokenize(expr)) {
        switch (token.Type) {
            case Operand:
                values.Push(token.Value);
                break;
            case Operator:
                while (ops.Count > 0 && Precedence(ops.Peek()) >= Precedence(token)) {
                    // 弹出运算符并计算结果
                    values.Push(DoOperation(ops.Pop(), values.Pop(), values.Pop()));
                }
                ops.Push(token.Value);
                break;
            // 其他情况处理...
        }
    }
    while (ops.Count > 0) {
        values.Push(DoOperation(ops.Pop(), values.Pop(), values.Pop()));
    }
    return values.Pop();
}

在上述伪代码中，表达式被拆分为操作数（Operand）和运算符（Operator）。算法通过一个运算符栈来确保高优先级的运算符先进行运算。

通过本章节的介绍，我们深入探讨了Stack集合在数据结构、算法以及实际项目中的应用。接下来，我们将继续探索Queue集合的高效应用与技巧。

# 5. 集合框架的综合对比与选型

## 5.1 List、Queue、Stack的对比分析

### 5.1.1 三者在不同场景下的适用性

在选择合适的数据结构时，List、Queue和Stack各自因其特点适用于不同的应用场景。

List集合由于其内部实现了动态数组，它非常适用于需要随机访问元素的场景。例如，当你需要存储一系列的用户对象，并经常通过用户ID来查询或修改特定用户信息时，List是不错的选择。List支持快速的元素添加和移除操作，尤其是在列表末尾。

Queue集合是一种先进先出（FIFO）的数据结构，它非常适合模拟排队系统，如打印队列、事件处理队列、网络请求队列等。当你需要处理请求、事件或其他数据项时，按照它们到来的顺序，而不需要中间访问或修改它们，Queue是一个理想的选择。

Stack集合是一个后进先出（LIFO）的数据结构，最适合用在诸如撤销/重做功能、函数调用栈、深度优先搜索等场景。在这些应用中，最新的操作或数据项需要首先被处理或访问。

### 5.1.2 性能对比和选择依据

List、Queue和Stack在性能上也有一些差异，这些差异可以成为选择的依据。

List通常在插入和移除操作时可能需要进行元素的移动以保持数组的连续性，这会带来额外的开销。但是它的随机访问性能是三者中最好的，因为它可以使用索引直接访问。

Queue由于其FIFO的特性，入队和出队操作都很快，但随机访问元素却不是其强项。它的内部实现通常使用循环数组或链表，使得入队和出队操作均摊复杂度为O(1)。

Stack的性能特点与Queue相似，也是入栈和出栈操作快，随机访问性能差。Stack操作通常使用数组或链表实现，并且保证了LIFO的特性。

## 5.2 其他集合类型简介

### 5.2.1 Dictionary和HashSet的简介

除了List、Queue和Stack之外，C#集合框架还包括Dictionary和HashSet等其他重要的集合类型。

Dictionary是一种键值对集合，它允许你通过键快速检索对应的值，因此在需要快速查找元素时非常有用。它内部通常使用哈希表实现，提供了常数时间复杂度的查找、插入和删除性能。Dictionary适用于实现映射表、字典等功能。

HashSet是一个不允许重复元素的集合，它提供了常数时间复杂度的元素查找、添加和删除性能。由于HashSet内部实现了哈希表，因此它非常适用于需要快速查找的场景，例如成员资格测试、去重等。

### 5.2.2 集合框架的扩展类型

C#集合框架为了满足各种不同场景的需求，提供了很多扩展类型，比如SortedList、ObservableCollection、ReadOnlyCollection等。

SortedList是一种既可以根据键排序也可以根据索引排序的集合类型。它在内部同样使用哈希表来存储数据，并且当数量超过一定阈值时，它会自动将其内部结构转换为红黑树以提高性能。

ObservableCollection是一个支持数据绑定的集合，它可以通知UI界面关于集合更改的情况，比如元素的添加、删除和整个集合的重置。这对于构建响应式用户界面非常有用。

ReadOnlyCollection提供了一个只读的包装，用于对外隐藏集合的修改操作，确保集合的封装性不被破坏。

## 5.3 如何选择合适的集合类型

### 5.3.1 需求分析和集合选择

选择合适的集合类型首先需要对应用的需求进行深入分析。考虑如下因素：

- 数据项的数量和大小：当处理大量数据时，内存使用和性能优化成为重要考量因素。
- 数据访问模式：需要随机访问数据，还是按照特定顺序访问数据。
- 数据的唯一性：是否需要存储唯一数据项，还是允许重复。
- 元素的生命周期：是否需要频繁添加和删除元素，或元素添加后不经常改变。

分析这些需求后，你可以根据上述各个集合类型的特点来做出决策。

### 5.3.2 集合框架的最佳实践

最佳实践包括合理选择集合类型和考虑集合间的互操作性。

- 当你需要使用键值对进行快速查找时，应考虑使用Dictionary。
- 当你的需求是对一系列操作进行排队时，Queue是一个好选择。
- 如果你需要快速访问数据的最新添加项，Stack会是一个不错的选择。
- 对于包含重复项的集合，可使用List或Queue，而对于需要唯一性检查的场景， HashSet是首选。
- 记得使用扩展类型，如SortedList、ReadOnlyCollection等，来满足更具体的需求。

同时，要注意集合的内存管理和线程安全问题，例如在多线程环境下使用Queue或Stack时，可能需要考虑其线程安全版本或使用同步机制来保证线程安全。

代码和逻辑分析：

// 示例：使用Dictionary存储键值对，并演示如何添加、查找和删除数据。
Dictionary<string, int> dictionary = new Dictionary<string, int>();
dictionary.Add("one", 1);
dictionary.Add("two", 2);
dictionary["three"] = 3; // 使用索引器语法添加键值对

// 查找元素
if (dictionary.TryGetValue("two", out int value))
{
    Console.WriteLine($"找到值：{value}");
}

// 删除元素
if (dictionary.ContainsKey("three"))
{
    dictionary.Remove("three");
}

// 迭代访问
foreach (KeyValuePair<string, int> kvp in dictionary)
{
    Console.WriteLine($"键：{kvp.Key}, 值：{kvp.Value}");
}

**代码逻辑解读：**

- 创建一个Dictionary实例，用于存储字符串键和整数值。
- 使用Add方法和索引器语法向字典中添加键值对。
- 使用TryGetValue方法来安全地查找并获取字典中的值。
- 使用ContainsKey方法来检查字典中是否存在特定的键，然后使用Remove方法来删除键值对。
- 使用foreach循环遍历字典中的所有项，并打印键和值。

**参数说明：**

- `Dictionary<string, int>`：表示键为字符串类型，值为整型的字典。
- `TryGetValue`：尝试获取与指定键关联的值，并将输出值存储在提供的变量中，如果成功返回true，否则返回false。
- `Add`：将带有指定键和值的元素添加到字典中，如果键已存在，则抛出异常。
- `ContainsKey`：确定字典是否包含特定的键。
- `Remove`：从字典中移除具有指定键的元素。

上述代码段演示了Dictionary的基本用法，包括添加、查找和删除元素。它还展示了如何安全地进行操作以避免运行时错误。

# 6. C#集合框架高级特性

在C#编程中，集合框架不仅仅局限于基本的数据存储，它还提供了一些高级特性，这些特性可以帮助开发者在构建复杂应用程序时，提高代码的效率、安全性和可维护性。本章节将探讨LINQ与集合框架的结合，线程安全集合的使用，以及集合的自定义与扩展。

## 6.1 LINQ与集合框架的结合

### 6.1.1 LINQ技术概述

语言集成查询（LINQ）是C#中一种强大的数据查询机制，它提供了一组标准查询操作符，允许开发者以声明方式编写代码，从而操作内存中的数据结构或外部数据源。LINQ可以用于查询List、Queue、Stack等集合框架中的数据。

LINQ查询通常由三个主要部分组成：
1. 数据源（Data Source）：提供数据的集合。
2. 查询表达式（Query Expression）：包含一个或多个查询子句的表达式，它描述了数据的筛选、排序和其他操作。
3. 查询执行（Query Execution）：将查询表达式转换成可执行代码并返回结果。

### 6.1.2 LINQ在集合操作中的应用

使用LINQ可以简化对集合的操作，比如过滤、排序、分组和连接等。下面是一个简单的示例，展示了如何使用LINQ查询集合中的数据：

using System;
using System.Collections.Generic;
using System.Linq;

class Program
{
    static void Main()
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

        // 使用LINQ查询大于5的数字
        var query = from n in numbers
                    where n > 5
                    select n;

        // 执行查询并输出结果
        foreach (int n in query)
        {
            Console.WriteLine(n);
        }
    }
}

在上述代码中，我们定义了一个包含10个整数的`List<int>`集合，并使用LINQ查询表达式来找出大于5的所有数字，然后遍历并打印这些数字。

LINQ不仅限于简单查询，还支持复杂的查询操作，例如连接两个集合、排序、分组以及执行聚合函数等。

## 6.2 并发集合与线程安全

### 6.2.1 线程安全集合的种类和使用

在多线程环境中，确保数据的一致性和线程安全是非常重要的。C#提供了一些线程安全的集合类，比如`ConcurrentQueue<T>`、`ConcurrentBag<T>`和`ConcurrentDictionary<TKey, TValue>`等，它们允许多个线程同时读写而不会导致数据竞争条件。

例如，`ConcurrentQueue<T>`是一个线程安全的队列实现，适用于在生产者-消费者模式中传递消息。

using System.Collections.Concurrent;

class Program
{
    static void Main()
    {
        var queue = new ConcurrentQueue<int>();

        // 生产者线程
        new Thread(() =>
        {
            for (int i = 0; i < 100; i++)
            {
                queue.Enqueue(i);
            }
        }).Start();

        // 消费者线程
        new Thread(() =>
        {
            int result;
            while (queue.TryDequeue(out result))
            {
                Console.WriteLine(result);
            }
        }).Start();
    }
}

在该示例中，我们创建了一个`ConcurrentQueue<int>`队列，并在两个不同的线程中分别模拟生产者和消费者的行为。由于使用了线程安全的集合，因此不需要额外的同步机制。

### 6.2.2 并发集合的性能考量

虽然线程安全的集合为多线程操作提供了便利，但是它们通常比标准集合有更高的性能开销。开发者在使用时需要根据实际的应用场景权衡其利弊。例如，如果集合操作的读写比例较高，那么使用线程安全集合可能会降低整体性能。

## 6.3 集合的自定义与扩展

### 6.3.1 自定义集合类型的方法

在某些特定情况下，C#提供的标准集合类型可能无法满足特定需求，这时开发者可能需要自定义集合类型。自定义集合类需要继承自`System.Collections.Generic.Collection<T>`，并重写相应的方法，如`Add`, `Remove`, `Contains`等。

下面是一个简单的自定义集合类的示例：

using System.Collections.Generic;
using System.Linq;

public class CustomList<T> : List<T>
{
    // 添加自定义方法
    public IEnumerable<T> Filter(Predicate<T> filter)
    {
        return this.Where(item => filter(item)).ToList();
    }
}

在这个示例中，`CustomList<T>`扩展了`List<T>`的功能，添加了一个`Filter`方法，该方法可以根据给定的条件筛选元素。

### 6.3.2 扩展现有集合类型的策略

除了创建全新的集合类外，还可以通过实现接口来扩展现有集合类型的功能。例如，如果需要对集合元素进行缓存，可以实现`IEnumerable<T>`接口来添加缓存功能。

using System;
using System.Collections.Generic;
using System.Collections;

public class CachingList<T> : IEnumerable<T>
{
    private List<T> _list;
    private List<T> _cache;

    public CachingList(List<T> list)
    {
        _list = list;
        _cache = new List<T>();
    }

    public IEnumerator<T> GetEnumerator()
    {
        if (_cache.Count == 0)
        {
            _cache = _list.ToList();
        }
        return _cache.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

在上面的示例中，`CachingList<T>`通过实现`IEnumerable<T>`接口，为`List<T>`添加了缓存功能。当枚举器首次被访问时，它会将列表的元素缓存起来，从而减少之后访问时的计算开销。

通过自定义集合或扩展现有集合，开发者可以构建更符合特定需求的数据结构，提升应用程序的整体性能和灵活性。