C# ArrayList 深度指南：掌握非泛型动态数组的艺术

2026-02-09 06:09:53 0条评论 3次阅读 0人点赞

作为一名深耕 .NET 生态多年的开发者，你是否曾经在处理遗留系统，或者在与某些旧版 COM 组件交互时，再次遇到了 ArrayList？在 2026 年的今天，虽然泛型集合（如 List）已经成为我们的默认选择，但理解 ArrayList 对于维护庞大的企业级遗产代码库、理解 .NET 内存管理的演变，甚至在某些极端的动态场景下，依然具有不可替代的价值。在这篇文章中，我们将深入探讨 C# 中的 ArrayList，不仅回顾其核心机制，更会结合现代开发理念，探讨如何在 AI 辅助编程时代更高效地处理这些“老朋友”。

为什么我们在 2026 年还在讨论 ArrayList？

随着云原生和边缘计算的普及，我们经常需要在极端的资源受限环境（如 IoT 边缘设备）中运行代码。在这些场景下，理解底层内存分配机制变得至关重要。ArrayList 是 .NET 集合体系的基石之一，它位于 System.Collections 命名空间下。虽然它是非泛型的，但它完美地展示了动态数组的权衡策略。

我们可以把 ArrayList 想象成一个可以随意伸缩的“软容器”。它本质上是一个 object 类型的数组包装器，这种设计赋予了它惊人的灵活性——你可以把整数、字符串、甚至自定义对象混在一起存放。但在现代高性能编程中，这种“随意”往往伴随着昂贵的代价，即装箱和拆箱操作。让我们深入探究其内部机制，看看如何规避这些风险。

核心机制：Count 与 Capacity 的动态博弈

在使用 ArrayList 时，最容易被新手（甚至是一些经验丰富的开发者在赶 Deadlines 时）忽视的，就是 Count（数量）和 Capacity（容量）的区别。

  • Count：ArrayList 中当前实际包含的元素个数。
  • Capacity：当前分配的内部数组的大小，即不需要重新分配内存就能容纳的元素总数。

这里有一个关键的内部机制： 当元素数量超过 Capacity 时，ArrayList 会自动扩容。在 .NET 的现代实现中，这个策略通常是翻倍。虽然这均摊了时间复杂度，但在一次扩容发生的瞬间，CPU 和内存的开销是巨大的。
让我们思考一下这个场景： 假设我们正在开发一个实时数据处理系统，每一毫秒的性能都很关键。如果在系统运行的关键路径上，ArrayList 突然触发扩容，可能会导致请求超时。为了解决这个问题，我们可以在预估数据量的前提下，在构造函数中指定初始容量，这是一种极其有效的预防性优化手段。

// 代码示例 1：观察 Count 和 Capacity 的动态变化以及手动优化
using System;
using System.Collections;

class Program
{
    static void Main()
    {
        // 步骤 1：创建一个默认的 ArrayList
        // 初始 Capacity 通常为 0 (首次 Add 后变为 4)
        ArrayList dynamicList = new ArrayList();
        
        Console.WriteLine($"初始状态 -> Count: {dynamicList.Count}, Capacity: {dynamicList.Capacity}");

        // 模拟批量添加数据
        for(int i = 1; i  8)
        Console.WriteLine($"添加 5 个元素后 -> Count: {dynamicList.Count}, Capacity: {dynamicList.Capacity}");
        
        // 步骤 2：生产环境中的最佳实践 - 显式优化
        // 如果你知道不再增加元素，或者为了节省内存
        dynamicList.TrimToSize();
        Console.WriteLine($"TrimToSize() 后 -> Count: {dynamicList.Count}, Capacity: {dynamicList.Capacity}");
        
        // 步骤 3：反向操作 - 预分配优化
        // 如果在维护遗留系统时发现性能瓶颈，查看是否有类似优化机会
        ArrayList preAllocated = new ArrayList(1000); // 直接预分配 1000
        Console.WriteLine($"预分配 1000 -> Capacity: {preAllocated.Capacity}");
    }
}

类型安全的陷阱：装箱与拆箱的隐形成本

既然 ArrayList 这么灵活，为什么现代 C# 开发指南会严正警告我们慎用它？这主要归因于两个核心问题：类型安全和性能损耗。

ArrayList 存储的是 INLINECODE15883fa4 类型。这意味着当你把一个值类型（如 INLINECODEb4c7b001）存入时，CLR 必须在堆上分配一个新对象并将值复制进去，这就是 装箱。当你读取它时，又必须进行 拆箱 并检查类型。这不仅消耗 CPU 周期，还会在堆上产生大量的内存碎片，增加 GC（垃圾回收）的压力。

让我们来看一段在生产环境中可能导致崩溃的代码：

// 代码示例 2：装箱拆箱演示及运行时风险
using System;
using System.Collections;

class Program
{
    static void Main()
    {
        ArrayList numberList = new ArrayList();
        
        // 装箱：值类型 int 被包装为 object
        numberList.Add(100); 
        numberList.Add(200);
        
        // 这是一个常见的错误场景：如果不小心混入了其他类型
        numberList.Add("Oops, I‘m a string"); 

        try {
            foreach(var item in numberList)
            {
                // 拆箱：object 转换回 int
                // 当遍历到 "Oops..." 时，这里会抛出 InvalidCastException
                int num = (int)item;
                Console.WriteLine(num);
            }
        }
        catch (InvalidCastException ex)
        {
            // 在 2026 年，我们更倾向于使用 AI 辅助工具在 Code Review 阶段发现此类隐患
            Console.WriteLine($"捕获到运行时错误: {ex.Message}");
        }
    }
}

现代开发视角：迭代器失效与并发修改

在我们最近的一个云原生项目重构中，我们发现了一个由 ArrayList 遍历修改引起的间歇性 Bug。这也是新手最容易遇到的陷阱之一：在遍历集合时修改集合。

ArrayList 的迭代器非常敏感。如果你在 INLINECODE3711e8b9 循环中调用 INLINECODE0d948e9d 或 INLINECODE9afe0f8e，程序会立即抛出 INLINECODEe3b20395，因为集合的版本号发生了变化。

我们是如何解决的？

// 代码示例 3：正确的集合修改策略
using System;
using System.Collections;

class Program
{
    static void Main()
    {
        ArrayList tasks = new ArrayList();
        tasks.Add("Task 1");
        tasks.Add("Task 2 (Pending)");
        tasks.Add("Task 3");
        tasks.Add("Task 4 (Pending)");

        Console.WriteLine("原始列表:");
        PrintList(tasks);

        // --- 错误的做法 ---
        // foreach (var task in tasks)
        // {
        //     if (task.ToString().Contains("Pending"))
        //         tasks.Remove(task); // 报错！集合已被修改；可能无法执行枚举操作。
        // }

        // --- 正确的做法 1：倒序遍历删除 ---
        // 这适用于 ArrayList 这种通过索引访问的集合
        Console.WriteLine("
执行清理操作 (移除 Pending): ");
        for (int i = tasks.Count - 1; i >= 0; i--)
        {
            // 使用 string.Contains 或模式匹配
            if (tasks[i] is string s && s.Contains("Pending"))
            {
                tasks.RemoveAt(i);
            }
        }

        Console.WriteLine("
清理后的列表:");
        PrintList(tasks);
    }

    static void PrintList(ArrayList list)
    {
        foreach (var item in list)
        {
            Console.Write($"[{item}] ");
        }
        Console.WriteLine();
    }
}

进阶场景： ArrayList 在复杂对象处理中的应用

尽管 List 更优，但在处理某些完全未知的异构数据源（例如解析老旧的 CSV 文件或处理动态 JSON 反序列化后的遗留对象）时，ArrayList 仍然有一席之地。

以下示例展示了如何高效地处理包含不同类型对象的 ArrayList，并使用现代 C# 的模式匹配来安全地提取数据。

// 代码示例 4：异构数据处理与模式匹配
using System;
using System.Collections;

class Program
{
    static void Main()
    {
        // 模拟一个从旧系统导入的混合数据集
        ArrayList legacyData = new ArrayList();
        legacyData.Add("Customer ID");
        legacyData.Add(10025); // ID
        legacyData.Add(99.5);  // Score (double)
        legacyData.Add(true);  // IsActive (bool)
        legacyData.Add(null);  // Middle Name

        Console.WriteLine("--- 遗留数据分析 ---");

        // 使用现代 C# 的模式匹配来处理 Object 类型的安全转化
        foreach (var item in legacyData)
        {
            switch (item)
            {
                case int i:
                    Console.WriteLine($"整型数据: {i} (已校验)");
                    break;
                case double d:
                    Console.WriteLine($"浮点数据: {d:F2}");
                    break;
                case string s:
                    Console.WriteLine($"字符串数据: {s}");
                    break;
                case null:
                    Console.WriteLine("空值: (跳过处理)");
                    break;
                default:
                    Console.WriteLine($"未知类型: {item}");
                    break;
            }
        }
    }
}

2026 年的技术选型：何时何地不再使用它？

作为负责任的架构师，我们需要明确何时彻底放弃 ArrayList。在我们的技术雷达中，ArrayList 已经处于“维护模式”或“淘汰区”。

替代方案对比：

  • 通用场景: 必须使用 List。它消除了装箱拆箱，提供了编译时类型检查，且在现代 .NET 运行时中经过了 JIT 优化。
  • 不可变数据: 如果数据一旦生成就不应改变（这在并发和分布式系统中越来越重要），请使用 INLINECODE55fcf163 或 INLINECODEfd3e02c6。
  • 高性能场景: 对于极度敏感的代码路径，考虑使用 INLINECODEf0c4fabd 或 INLINECODEb57ae28e，甚至 stackalloc 来完全避免堆分配。

让我们看一个简单的对比，感受一下泛型集合在代码简洁度上的优势：

// 现代方式
List modernList = new List { 1, 2, 3 };
modernList.Add(4); // 无需装箱

// 遗留方式
ArrayList legacyList = new ArrayList();
legacyList.Add(1); // 装箱发生
legacyList.Add("Two"); // 类型不安全，编译器无法报错

总结

虽然 ArrayList 在现代 C# 开发中已不再是首选，但深入理解它的底层原理——从动态扩容策略到装箱拆箱的成本——是每一位资深 .NET 工程师的必修课。这不仅能帮助我们维护那些遗留在生产环境中的关键代码，更能让我们知其然并知其所以然，更好地珍惜 List 等现代工具带来的便利。

在你的下一个项目中，如果你再次看到 ArrayList，请不要急于将其全部替换（除非时间和预算允许）。相反，利用 AI 编程工具（如 Cursor 或 GitHub Copilot）辅助你分析其使用场景，评估其对性能的实际影响，然后做出最理性的技术决策。保持好奇，持续编码，我们将在下一篇文章中继续探索 .NET 集合的深层奥秘。

声明：本站所有文章，如无特殊说明或标注，均为本站原创发布。任何个人或组织，在未征得本站同意时，禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益，可联系我们进行处理。如需转载，请注明文章出处豆丁博客和来源网址。https://shluqu.cn/38736.html
点赞
0.00 平均评分 (0% 分数) - 0 票

相关文章美国1G带宽/1T流量高速vps $17.99/年