.net源碼分析 – List

時間 2019-11-18

標籤源碼分析 list 简体版

原文原文鏈接

經過分析源碼能夠更好理解List<T>的工做方式，幫助咱們寫出更穩定的代碼。 git

List<T>源碼地址: https://github.com/dotnet/corefx/blob/master/src/System.Collections/src/System/Collections/Generic/List.cs。 github

接口

List<T>實現的接口：IList<T>, IList, IReadOnlyList<T> 數組

其實.net framework通過多代發展，List的接口確實是有點多了，添加新功能時爲了兼容老功能，一些舊的接口又不能丟掉，因此看上去有點複雜。先把這些接口捋一下：安全

IEnumerator是枚舉器接口，擁有枚舉元素的功能，成員有Current, MoveNext, Reset，這三個函數可使集合支持遍歷。多線程

IEnumerable是支持枚舉接口，實現這接口表示支持遍歷，成員就是上面的IEnumerator。函數

ICollection是集合接口，支持着集合的Count屬性和CopyTo操做，另外還有同步的屬性IsSynchronized（判斷是否線程安全）和SyncRoot（lock的對象）。性能

IList是集合的操做接口，支持索引器，Add, Remove, Insert, Contains等操做。 ui

泛型部分基本是上面這些接口的泛型實現，不過IList<T>的一些操做放到ICollection<T>裏了，可能微軟也以爲對於集合的一些操做放到ICollection更合理吧。 this

IReadOnlyCollection<T>是.net 4.5加進來的，能夠認爲是IList<T>的只讀版。 spa

變量

 1 private const int _defaultCapacity = 4;
 2 
 3 private T[] _items;
 4 
 5 private int _size;
 6 
 7 private int _version;
 8 
 9 private Object _syncRoot;
10 
11 static readonly T[] _emptyArray = new T[0];

_defaultCapacity意思是new List<T>時默認大小是4。

_items就是存List<T>元素的數組了，List<T>也是基於數組實現的。

_size指元素個數。

_version看字面意思是版本，具體用處下面看，與遍歷集合時常常碰到的集合被修改異常有關。

_syncRoot上面有說到，內置的用於lock的對象，若是在多線程時只是操做這個集合就能夠lock這個來保證線程安全，固然通常來講這個是內部用的，雖然對List<T>自己來講沒什麼用，這個不取的話是不會把對象new出來的，對於鎖咱們更經常使用的是在外面new一個readonly的object。

emptyArray這是個靜態只讀的空數組，全部沒有元素的List<T>都是用這個，因此兩個List<int>的_items實際上是同樣的，都是這個_emptyArray。

構造函數

有三個構造函數

1 public List()
2 {
3     _items = _emptyArray;
4 }

最經常使用的，_items直接指向靜態空數組。

 1 public List(int capacity)
 2 {
 3     if (capacity < 0) throw new ArgumentOutOfRangeException(nameof(capacity), capacity, SR.ArgumentOutOfRange_NeedNonNegNum);
 4     Contract.EndContractBlock();
 5 
 6     if (capacity == 0)
 7         _items = _emptyArray;
 8     else
 9         _items = new T[capacity];
10 }

能夠經過capacity指定大小

 1 public List(IEnumerable<T> collection)
 2 {
 3     if (collection == null)
 4         throw new ArgumentNullException(nameof(collection));
 5     Contract.EndContractBlock();
 6 
 7     ICollection<T> c = collection as ICollection<T>;
 8     if (c != null)
 9     {
10         int count = c.Count;
11         if (count == 0)
12         {
13             _items = _emptyArray;
14         }
15         else
16         {
17             _items = new T[count];
18             c.CopyTo(_items, 0);
19             _size = count;
20         }
21     }
22     else
23     {
24         _size = 0;
25         _items = _emptyArray;
26         // This enumerable could be empty.  Let Add allocate a new array, if needed.
27         // Note it will also go to _defaultCapacity first, not 1, then 2, etc.
28 
29         using (IEnumerator<T> en = collection.GetEnumerator())
30         {
31             while (en.MoveNext())
32             {
33                 Add(en.Current);
34             }
35         }
36     }
37 }

初始添加一個集合，先看是不是ICollection，看上面知道這個接口有Copy的功能，copy到_items裏。若是不是ICollection，不過因爲是IEnumerable，因此能夠遍歷，一個一個加到_items裏。

屬性

Count 返回的是_size，這個是元素的實際個數，不是數組大小。

IsSynchronized是false，表示並不是用SyncRoot 來實現同步。List<T>不是線程安全，須要咱們本身用鎖搞定，

IsReadOnly也是false, 那爲何要繼承IReadOnlyList<T>呢，是爲了提供一個轉換成只讀List的機會，好比有的方法不但願傳進來的List能夠修改，就能夠把參數設成IReadOnlyList。

 1 Object System.Collections.ICollection.SyncRoot
 2 {
 3     get
 4     {
 5         if (_syncRoot == null)
 6         {
 7             System.Threading.Interlocked.CompareExchange<Object>(ref _syncRoot, new Object(), null);
 8         }
 9         return _syncRoot;
10     }
11 }

SyncRoot經過原子操做獲得一個對象，對於List<T>來講並無用，對於某些集合比較有用，好比SyncHashtable，就是經過syncRoot來實現線程安全。

比較重要的Capacity:

 1 public int Capacity
 2 {
 3     get
 4     {
 5         Contract.Ensures(Contract.Result<int>() >= 0);
 6         return _items.Length;
 7     }
 8     set
 9     {
10         if (value < _size)
11         {
12             throw new ArgumentOutOfRangeException(nameof(value), value, SR.ArgumentOutOfRange_SmallCapacity);
13         }
14         Contract.EndContractBlock();
15 
16         if (value != _items.Length)
17         {
18             if (value > 0)
19             {
20                 var items = new T[value];
21                 Array.Copy(_items, 0, items, 0, _size);
22                 _items = items;
23             }
24             else
25             {
26                 _items = _emptyArray;
27             }
28         }
29     }
30 }

Capacity取的就是數組的長度，另外咱們能夠經過Capacity給List設置大小，即便這個List裏面已經有元素，會先new一個目標大小的數組，而後經過Array.Copy把現有元素複製到新數組裏。但通常狀況下這些不用咱們設置Capacity，添加新元素時發現長度不夠會自動擴大數組。Capacity是int型，說明最大是int.MaxValue，大約2G個，若是咱們直接給List設置int.MaxValue就要看你的內存夠不夠2G*4也就是8G了，不夠的話會報OutofMemory Exception。其實我的以爲這裏Capacity用uint是否是更好。

用100M個，內存佔用400M多

一樣100M個，因爲是long，內存佔了800M多

方法

看幾個重要的方法：

1 public void Add(T item)
2 {
3     if (_size == _items.Length) EnsureCapacity(_size + 1);
4     _items[_size++] = item;
5     _version++;
6 }

當前數組大小和元素個數相等時代表再Add的話大小不夠了，須要先經過EnsureCapacity擴容, _size+1指明瞭一個最小的擴容目標。

 1 private void EnsureCapacity(int min)
 2 {
 3     if (_items.Length < min)
 4     {
 5         int newCapacity = _items.Length == 0 ? _defaultCapacity : _items.Length * 2;
 6         // Allow the list to grow to maximum possible capacity (~2G elements) before encountering overflow.
 7         // Note that this check works even when _items.Length overflowed thanks to the (uint) cast
 8         //if ((uint)newCapacity > Array.MaxArrayLength) newCapacity = Array.MaxArrayLength;
 9         if (newCapacity < min) newCapacity = min;
10         Capacity = newCapacity;
11     }
12 }

擴容方法，若是數組長度是0的話則用_defaultCapacity也就是4來作爲數組長度，不然則以當前元素個數的2倍去擴大。若是新獲得的長度比傳進來的min小的話則就用min，也就是選大的，這種狀況在InsertRange時有可能發生，由於insert的list極可能比當前list的元素個數多。

Add函數裏還有個_version++，這個_version能夠在不少方法裏看到，如remove, insert, sort等，但凡要修改集合都須要_version++。那這個_version有什麼用呢？

 1 public void ForEach(Action<T> action)
 2 {
 3     if (action == null)
 4     {
 5         throw new ArgumentNullException(nameof(action));
 6     }
 7 
 8     int version = _version;
 9 
10     for (int i = 0; i < _size; i++)
11     {
12         if (version != _version)
13         {
14             break;
15         }
16         action(_items[i]);
17     }
18 
19     if (version != _version)
20         throw new InvalidOperationException(SR.InvalidOperation_EnumFailedVersion);
21 }