C# 数组动态添加新元素的 方法

《C# 数组动态添加新元素的方法》

在C#编程中，数组（Array）作为基础数据结构，常用于存储同类型元素的集合。然而，原生数组的长度在初始化后即固定，无法直接动态扩展。这一特性在需要频繁增减元素的场景中显得不够灵活。本文将系统探讨在C#中实现数组动态添加元素的多种方法，涵盖基础技巧到高级实践，帮助开发者根据实际需求选择最优方案。

一、原生数组的局限性

C#中的一维数组通过`new`关键字初始化时需指定长度，例如：

int[] fixedArray = new int[3]; // 长度为3的数组
fixedArray[0] = 1;
fixedArray[1] = 2;
fixedArray[2] = 3;
// fixedArray[3] = 4; // 抛出IndexOutOfRangeException

尝试访问超出索引范围的元素会触发运行时异常。若需添加第4个元素，必须创建新数组并复制原有数据：

int[] newArray = new int[fixedArray.Length + 1];
Array.Copy(fixedArray, newArray, fixedArray.Length);
newArray[newArray.Length - 1] = 4;

这种方法在频繁操作时效率低下，时间复杂度为O(n)，不适合大规模数据。

二、动态数组的替代方案

1. 使用`List`泛型集合

`.NET`框架提供的`List`类是动态数组的典型实现，内部通过可变大小的数组自动管理扩容。示例如下：

List dynamicList = new List();
dynamicList.Add(1);
dynamicList.Add(2);
dynamicList.AddRange(new[] { 3, 4 }); // 批量添加
Console.WriteLine(dynamicList.Capacity); // 输出当前容量

`List`的扩容机制：当元素数量超过当前容量时，系统会分配一个更大的新数组（通常为原容量的1.5~2倍），复制原有数据，并释放旧数组。此过程对开发者透明，但需注意频繁插入可能导致内存碎片。

2. 手动实现动态数组类

若需完全控制扩容逻辑，可自定义动态数组类。以下是一个简化实现：

public class DynamicArray
{
    private T[] _array;
    private int _size;
    private const int DefaultCapacity = 4;

    public DynamicArray()
    {
        _array = new T[DefaultCapacity];
        _size = 0;
    }

    public void Add(T item)
    {
        if (_size == _array.Length)
        {
            Resize(_array.Length * 2); // 扩容策略
        }
        _array[_size++] = item;
    }

    private void Resize(int newCapacity)
    {
        T[] newArray = new T[newCapacity];
        Array.Copy(_array, newArray, _size);
        _array = newArray;
    }

    public T this[int index] => _array[index];
    public int Count => _size;
}

使用示例：

var dynArray = new DynamicArray();
dynArray.Add("Hello");
dynArray.Add("World");
Console.WriteLine(dynArray[1]); // 输出"World"

此实现通过`Resize`方法在容量不足时自动扩容，开发者可调整扩容因子（如`*2`或`*1.5`）以平衡内存使用与性能。

3. 使用`ArrayList`（非泛型集合）

在.NET Framework中，`ArrayList`是早期动态数组的实现，支持存储任意类型对象（需装箱/拆箱）：

ArrayList arrayList = new ArrayList();
arrayList.Add(1);       // 装箱为object
arrayList.Add("Text");  // 允许混合类型
int num = (int)arrayList[0]; // 拆箱

由于类型安全和性能问题，建议在新项目中使用`List`替代`ArrayList`。

三、高性能场景优化

1. 预分配容量

若已知元素总数，可在初始化时指定容量，避免多次扩容：

List optimizedList = new List(1000); // 初始容量1000
for (int i = 0; i 

2. 使用`Span`和内存池（.NET Core 3.0+）

在高性能计算中，可通过`Span`和`ArrayPool`减少内存分配：

var pool = ArrayPool.Shared;
int[] rentedArray = pool.Rent(1024); // 从池中租用数组
try
{
    // 使用rentedArray处理数据
    Span span = rentedArray.AsSpan(0, 500);
    // ...操作span
}
finally
{
    pool.Return(rentedArray); // 归还数组
}

此模式适用于短生命周期、高频率的数组操作，可显著降低GC压力。

3. 链表结构替代

若需频繁在中间插入/删除元素，`LinkedList`可能是更优选择：

LinkedList linkedList = new LinkedList();
linkedList.AddLast("First");
linkedList.AddFirst("Zero");
linkedList.AddAfter(linkedList.First, "Between");

链表的时间复杂度为O(1)的插入/删除，但随机访问需O(n)遍历。

四、多线程环境下的动态数组

在并发场景中，需使用线程安全集合或同步机制：

1. 使用`ConcurrentBag`

ConcurrentBag bag = new ConcurrentBag();
Parallel.For(0, 100, i => bag.Add(i)); // 多线程添加
Console.WriteLine(bag.Count);

`ConcurrentBag`适用于生产者-消费者模式，但无序且不支持索引访问。

2. 手动加锁

private readonly object _lock = new object();
private List _threadSafeList = new List();

public void AddSafely(int item)
{
    lock (_lock)
    {
        _threadSafeList.Add(item);
    }
}

锁的粒度需根据场景权衡，过细的锁可能导致性能下降。

五、性能对比与选择建议

方案	扩容开销	线程安全	适用场景
`List`	中等（自动扩容）	否	单线程、通用场景
自定义动态数组	可控（自定义策略）	否	需精细控制扩容
`ConcurrentBag`	无（无序）	是	高并发添加
`LinkedList`	无（固定节点）	否	频繁中间插入

六、常见问题解答

Q1：为什么`List`的`Add`方法有时比预期慢？
A：当内部数组容量不足时，`List`会触发扩容，涉及新数组分配和数据复制。可通过预分配容量或使用`Capacity`属性优化。

Q2：如何清空动态数组？
A：`List`提供`Clear()`方法，会将`Count`置0但保留容量；若需释放内存，可设置`Capacity = 0`或创建新实例。

Q3：动态数组与栈/队列的区别？
A：动态数组（如`List`）支持随机访问，而栈（`Stack`）和队列（`Queue`）分别遵循LIFO和FIFO原则，操作更受限但语义明确。

七、总结

C#中实现数组动态添加的核心方法包括：

1. 优先使用`List`简化开发
2. 高性能场景采用自定义动态数组或内存池
3. 并发环境选择线程安全集合或同步机制
4. 根据操作频率（头部/中间/尾部插入）选择合适数据结构

理解底层扩容机制和选择合适的数据结构，能显著提升代码性能和可维护性。

关键词：C#动态数组、List、数组扩容、线程安全集合、内存池、ConcurrentBag、LinkedList、性能优化

简介：本文详细探讨C#中实现数组动态添加元素的多种方法，包括原生数组限制、List泛型集合使用、自定义动态数组实现、多线程环境处理及高性能优化技巧，通过代码示例和性能对比帮助开发者选择最佳方案。