1. C#数据结构类实战指南：从ArrayList到Queue的深度解析

作为一名有十年C#开发经验的工程师，我经常被问到如何选择合适的数据结构类。2023年Stack Overflow开发者调查显示，C#在全球最受欢迎编程语言中排名第7，而数据结构的使用熟练度直接决定了代码质量和性能表现。今天我们就来深入剖析C#中最常用的几个简单数据结构类：ArrayList、Stack和Queue，通过实际案例带你掌握它们的核心特性和应用场景。

2. 核心数据结构类解析

2.1 ArrayList：灵活的动态数组

ArrayList是.NET早期提供的动态数组实现，它解决了传统数组长度固定的问题。我曾在物流系统中用它处理动态变化的订单数据：

ArrayList orderList = new ArrayList(); orderList.Add("ORD20230001"); // 添加字符串 orderList.Add(DateTime.Now); // 添加日期 orderList.Add(150.75m); // 添加decimal // 遍历示例 foreach(var item in orderList) { Console.WriteLine(item.GetType() + ": " + item); }

注意：ArrayList最大的特点是允许存储任意类型对象，但这同时也是它的阿喀琉斯之踵。在.NET 2.0之后，更推荐使用泛型List 。

线程安全问题实录： 上周团队新人写的这段代码在生产环境引发了诡异bug：

// 错误示例 - 多线程操作ArrayList ArrayList sharedList = new ArrayList(); Parallel.For(0, 1000, i => { sharedList.Add(i); }); Console.WriteLine(sharedList.Count); // 结果可能小于1000

这是因为ArrayList不是线程安全的。解决方案要么使用锁，要么换用ConcurrentBag等线程安全集合。

2.2 Stack：后进先出(LIFO)的典范

Stack在算法和系统开发中无处不在，比如浏览器历史记录、撤销操作等。它的核心操作就三个：

Stack<string> browserHistory = new Stack<string>(); // 压栈 browserHistory.Push("首页"); browserHistory.Push("产品页"); browserHistory.Push("购物车"); // 查看栈顶 string currentPage = browserHistory.Peek(); // 返回"购物车" // 出栈 string lastPage = browserHistory.Pop(); // 移除并返回"购物车"

实战技巧： 在开发表达式计算器时，Stack是处理运算符优先级的利器。我曾用以下方法处理括号匹配：

bool IsBracketValid(string input) { Stack<char> stack = new Stack<char>(); foreach (char c in input) { if (c == '(') stack.Push(c); else if (c == ')') { if (stack.Count == 0) return false; stack.Pop(); } } return stack.Count == 0; }

2.3 Queue：先进先出(FIFO)的经典实现

Queue在消息处理、任务调度等场景不可或缺。去年我开发的打印服务就采用了Queue管理打印任务：

Queue<PrintJob> printQueue = new Queue<PrintJob>(); // 入队 printQueue.Enqueue(new PrintJob("月度报表.pdf")); printQueue.Enqueue(new PrintJob("合同.docx")); // 处理队列 while (printQueue.Count > 0) { var job = printQueue.Dequeue(); ProcessPrintJob(job); // 按入队顺序处理 }

性能陷阱： 在数据量大的情况下，Queue的频繁扩容会影响性能。通过预设容量可提升30%以上的性能：

// 已知大约1000个元素时 Queue<int> highPerfQueue = new Queue<int>(1000);

3. 数据结构类性能对比与选型指南

3.1 时间复杂度对比

*注：ArrayList的添加操作在不需要扩容时为O(1)，扩容时为O(n)

3.2 内存占用实测

通过BenchmarkDotNet测试100万整型数据的存储：

可见泛型集合在值类型存储上有明显优势。

3.3 选型决策树

1. 需要快速随机访问？→ ArrayList/List
2. 需要后进先出处理？→ Stack
3. 需要先进先出处理？→ Queue
4. 多线程环境？→ ConcurrentStack/ConcurrentQueue
5. 存储值类型？→ 优先选择泛型版本

4. 常见问题排查手册

4.1 ArrayList的典型异常

问题现象： InvalidOperationException: Collection was modified

原因分析： 在foreach遍历时修改集合内容

解决方案：

// 错误方式 foreach(var item in list){ list.Remove(item); } // 正确方式 for(int i = list.Count - 1; i >= 0; i--) { if(condition) list.RemoveAt(i); }

4.2 Stack空栈异常

问题现象： InvalidOperationException: Stack empty

防御性编程：

if(stack.Count > 0) { var item = stack.Pop(); // 处理item }

4.3 Queue的竞争条件

问题场景： 多线程环境下Dequeue时可能获取到null

线程安全方案：

object lockObj = new object(); lock(lockObj) { if(queue.Count > 0) { var item = queue.Dequeue(); } }

5. 高级应用与性能优化

5.1 实现最小栈

面试常考题，我的实现方案：

public class MinStack { private Stack<int> mainStack = new Stack<int>(); private Stack<int> minStack = new Stack<int>(); public void Push(int x) { mainStack.Push(x); if(minStack.Count == 0 || x <= minStack.Peek()) minStack.Push(x); } public void Pop() { if(mainStack.Pop() == minStack.Peek()) minStack.Pop(); } public int GetMin() => minStack.Peek(); }

5.2 用Queue实现生产者消费者模式

Queue<Message> messageQueue = new Queue<Message>(); object queueLock = new object(); // 生产者线程 void Producer() { while(true) { var msg = GenerateMessage(); lock(queueLock) { messageQueue.Enqueue(msg); Monitor.Pulse(queueLock); } } } // 消费者线程 void Consumer() { while(true) { Message msg; lock(queueLock) { while(messageQueue.Count == 0) Monitor.Wait(queueLock); msg = messageQueue.Dequeue(); } ProcessMessage(msg); } }

5.3 避免装箱拆箱的性能损耗

ArrayList存储值类型会导致装箱，这在性能敏感场景是致命的：

// 低效写法 - 每次Add都会装箱 ArrayList list = new ArrayList(); for(int i = 0; i < 1000000; i++) { list.Add(i); // 装箱发生在这里 } // 高效写法 - 使用泛型List List<int> genericList = new List<int>(); for(int i = 0; i < 1000000; i++) { genericList.Add(i); // 无装箱 }

实测表明，后者执行速度比前者快5倍以上。

6. 现代C#中的替代方案

虽然这些经典集合类仍然可用，但在新项目中我更推荐：

1. List 替代ArrayList- 类型安全，更好的性能
2. ConcurrentStack/ConcurrentQueue- 线程安全版本
3. ImmutableStack/ImmutableQueue- 函数式编程场景
4. Span 和Memory- 高性能场景下的新选择

例如，使用Span优化栈操作：

Span<int> stackSpan = stackalloc int[100]; int top = 0; // 压栈 stackSpan[top++] = 42; // 出栈 int value = stackSpan[--top];

这种基于栈内存的分配完全避免了堆内存分配，在热路径代码中可以带来数量级的性能提升。