原始碼版本為 .NET Framework 4.6.1

本系列持續更新，敬請關注

有投入，有產出。

陣列是C#中最基礎的一種資料型別，一旦初始化之後，容量便已經確定。若想要動態擴充容量，那麼集合可以滿足這點需求。ArrayList是C#最常用也是最基礎的一個動態陣列。

ArrayList在System.Collections中，實現了IList介面（IList：表示可按照索引進行訪問的非泛型集合物件）。

如此來，ArrayList可以乾點什麼事情呢？
1. 可以動態擴容；
2. 插入/刪除 比較便捷；

為了防止廢話過多而導致翻船，上程式碼：

• ArrayList中的資料是由一個內部陣列來進行維護的，一個私有的Object資料（Object 你就是萬能的造物主啊~）

private Object[] _item[];
private int _size;//ArrayList的容量
private const int _defaultCapacity = 4;//預設的容量
private static readonly Object[] emptyArray = EmptyArray<Object>.Value; //預設的空陣列

- 新增元素：Add(Object) ，AddRange(ICollection)，Insert(Int32, Object)，InsertRange(Int32, ICollection)。

1. Add(Object)：將物件新增到 ArrayList 的結尾處。

     public virtual int Add(Object value) {
            Contract.Ensures(Contract.Result<int>() >= 0);//後置契約，返回值必須大於等於0
            //動態擴容的核心方法，當ArrayList的容量等於內部存放資料的陣列長度時，進行擴容
            if (_size == _items.Length) EnsureCapacity(_size + 1);
            _items[_size] = value;//在ArrayList末尾索引處寫入值
 

            _version++;
            return _size++;//返回陣列ArrayList的容量
        }

     //動態擴容的核心方法，一次擴容長度為初始容量的2倍，容量不得超出long的最大範圍
     private void EnsureCapacity(int min) {
            if (_items.Length < min) {
                int newCapacity = _items.Length == 0 
                    ? _defaultCapacity: _items.Length * 2;
                //Array.MaxArrayLength為long的最大值
                if ((uint)newCapacity > Array.MaxArrayLength) 
                    newCapacity = Array.MaxArrayLength;
                if (newCapacity < min) newCapacity = min;

                Capacity = newCapacity;
            }
        }

     //自動擴容的實現原理是 建立一個更大容量新的組數，將原陣列的資料搬至新組數
        public virtual int Capacity {
            get {
                Contract.Ensures(Contract.Result<int>() >= Count);
                return _items.Length;
            }
            set {
                if (value < _size) {
                    throw new ArgumentOutOfRangeException("value", 
                        Environment.GetResourceString("ArgumentOutOfRange_SmallCapacity"));
                }
                Contract.Ensures(Capacity >= 0);
                Contract.EndContractBlock();

                if (value != _items.Length) {
                    if (value > 0) {
                        Object[] newItems = new Object[value];
                        if (_size > 0) { 
                            Array.Copy(_items, 0, newItems, 0, _size);
                        }
                        _items = newItems;
                    }
                    else {
                        _items = new Object[_defaultCapacity];
                    }
                }            
            }
        }

2. AddRange(ICollection)：新增 ICollection 的元素到 ArrayList 的末尾。該方法在內部呼叫了InsertRange(Int32, ICollection)方法

    public virtual void AddRange(ICollection c) {
            InsertRange(_size, c);
        }

3. Insert(Int32, Object)    ：將元素插入 ArrayList 的指定索引處。

    public virtual void Insert(int index, Object value) {
            if(index < 0 || index > _size)
                throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_ArrayListInsert"));
            Contract.EndContractBlock();

            //擴容檢查
            if(_size == _items.Length) EnsureCapacity(_size + 1);

            //插入到指定索引處，可以看出，由於需要移動元素的位置，相對於Add直接插入到末尾來說，效率慢了點
            if(index < _size){
                Array.Copy(_items, index, _items, index + 1, _size - index);
            }

            _items[index] = value;
            _size++;
            _version++;
        }

4. InsertRange(Int32, ICollection)：將ICollection中的元素插入到 ArrayList 中指定索引處。

    public virtual void InsertRange(int index, ICollection c) {
            if (c==null)
                throw new ArgumentNullException("c", Environment.GetResourceString("ArgumentNull_Collection"));
            if (index < 0 || index > _size) 
                throw new ArgumentOutOfRangeException("index", Environment.GetResourceString("ArgumentOutOfRange_Index"));
            Contract.EndContractBlock();//契約結尾

            int count = c.Count;//即將要新增到ArrayList的元素數量
            if (count > 0) {
                //每次新增元素，都會進行擴容判斷
                EnsureCapacity(_size + count);
                //友誼的小船說翻就翻，看看微軟大神在功能與效能上所做的取捨吧
                if (index < _size) {
                    //移動元素位置
                    Array.Copy(_items, index, _items, index + count, _size - index);
                }

                //後面這段沒有用for迴圈，也許是微軟大神為了程式碼的重用吧？
                //建立新陣列用於儲存即將插入ArrayList的元素
                Object[] itemsToInsert = new Object[count];
                c.CopyTo(itemsToInsert, 0);
                //將元素插入對應的索引處
                itemsToInsert.CopyTo(_items, index);
                _size += count;
                _version++;
            }
        }

- 移除元素：Remove(Object)，RemoveAt(Int32)，RemoveRange(Int32, Int32)，Clear()。

1. Remove(Object)：從 ArrayList 中移除特定物件的第一個匹配項。在內部呼叫了IndexOf(Int32)和RemoveAt(Int32)。

     public virtual void Remove(Object obj) {
            Contract.Ensures(Count >= 0);

            //呼叫IndexOf(Int32)獲取元素的索引
            int index = IndexOf(obj);

            if(index >= 0)
                RemoveAt(index);
        }

2.RemoveAt(Int32)：移除 ArrayList 的指定索引處的元素。

     public virtual void RemoveAt(int index) {
            if (index < 0 || index >= _size) 
                throw new ArgumentOutOfRangeException("index", 
                Environment.GetResourceString("ArgumentOutOfRange_Index"));
            Contract.Ensures(Count >= 0);
            Contract.EndContractBlock();

            _size--;//移除元素，容量自減1
            //移除元素也會導致元素位置的變動，導致效率降低
            if (index < _size) {
                Array.Copy(_items, index + 1, _items, index, _size - index);
            }
            _items[_size] = null;
            _version++;
        }

3.RemoveRange(Int32, Int32)：從 ArrayList 中移除一定範圍的元素。

     public virtual void Clear() {
            if (_size > 0)
            {
                //快刀斬亂麻
                Array.Clear(_items, 0, _size);
                _size = 0;
            }
            _version++;
        }

- 排序：Sort()，Sort(IComparer)，Sort(Int32, Int32, IComparer)，Reverse()，Reverse(Int32, Int32)

1. Sort()：將整個 ArrayList 中的元素進行排序。在ArrayList的排序方法全部在內部呼叫了Sort(Int32, Int32, IComparer)，進行排序。
2. Sort(IComparer)：使用指定的比較器對整個 ArrayList 中的元素進行排序。
3. Sort(Int32, Int32, IComparer)：使用指定的比較器對 ArrayList 中某個範圍內的元素進行排序。

     public virtual void Sort(int index, int count, IComparer comparer) {
            if (index < 0)
                throw new ArgumentOutOfRangeException("index", 
                Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
            if (count < 0)
                throw new ArgumentOutOfRangeException("count", 
                Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
            if (_size - index < count)
                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
            Contract.EndContractBlock();

            //使用了基礎陣列排序
            Array.Sort(_items, index, count, comparer);
            _version++;
        }

4.Reverse()：將整個 ArrayList 中元素的順序反轉。

     public virtual void Reverse(int index, int count) {
            if (index < 0)
                throw new ArgumentOutOfRangeException("index", 
                Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
            if (count < 0)
                throw new ArgumentOutOfRangeException("count", 
                Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
            if (_size - index < count)
                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
            Contract.EndContractBlock();

            Array.Reverse(_items, index, count);
            _version++;
        }

5.Reverse(Int32, Int32)：將指定範圍中元素的順序反轉。

     public virtual void Reverse(int index, int count) {
            if (index < 0)
                throw new ArgumentOutOfRangeException("index", 
            Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
            if (count < 0)
                throw new ArgumentOutOfRangeException("count", 
            Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
            if (_size - index < count)
                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidOffLen"));
            Contract.EndContractBlock();

            Array.Reverse(_items, index, count);
            _version++;
        }

ArrayList可以說是C#中最簡單的一種資料結構了，再使用ArrayList時為了獲得一些效能上的提升，儘量在可預知的容量大小範圍內使用一個固定的初始容量來構建ArrayList了，以使在某些情況下，可以避免內部陣列的重複建立和資料位置的變換。