标签：ack 改变 实现 cat block root tip alc copy
Core里面的List沿用的framework的结构，整个core的体系是把项目的组织方式改变了，变得更灵活，更可配置，不像framework那么死板。但底层的数据结构和中间代码CLR并没有很大的改变。
在framework源码中的位置
首先我们来看构造函数和一些内部的变量，然后默认的_defaultCapacity数组长度是4，构造函数上也有说明，一旦加入元素，capacity会增加到16，然后以2倍的乘数增长。
List的内部是一个私有的T[] _items对象，在无参的构造函数中，可以看到_items = _emptyArray，也就是被赋值了静态的空数组，这算是个小技巧，List实例的很多方法都涉及到空数组参数，这样设置一个静态只读的空数组，大家都可以共用这个对象。如果一旦被插入数据，或者修改数组的Capacity就会进行再次实例化到对应Capacity。
_size记录的是当前数组内，有赋值的数量，也就是我们用的Count属性，数组的实际容量肯定是大于等于_size的。
public class List<T> : IList<T>, System.Collections.IList, IReadOnlyList<T> { private const int _defaultCapacity = 4; private T[] _items; [ContractPublicPropertyName("Count")] private int _size; private int _version; [NonSerialized] private Object _syncRoot; static readonly T[] _emptyArray = new T[0]; // Constructs a List. The list is initially empty and has a capacity // of zero. Upon adding the first element to the list the capacity is // increased to 16, and then increased in multiples of two as required. public List() { _items = _emptyArray; } }
// Constructs a List, copying the contents of the given collection. The // size and capacity of the new list will both be equal to the size of the // given collection. public List(IEnumerable<T> collection) { if (collection==null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.collection); ICollection<T> c = collection as ICollection<T>; if( c != null) { int count = c.Count; if (count == 0) { _items = _emptyArray; } else { _items = new T[count]; c.CopyTo(_items, 0); _size = count; } } else { _size = 0; _items = _emptyArray; // This enumerable could be empty. Let Add allocate a new array, if needed. // Note it will also go to _defaultCapacity first, not 1, then 2, etc. using(IEnumerator<T> en = collection.GetEnumerator()) { while(en.MoveNext()) { Add(en.Current); } } } }
这里如果集合不为空，设置对应_size变量为目标集合的数量，然后调用CopyTo 方法进行拷贝，CopyTo 内部调用System.Array.Copy,此方法等效于标准 C/C++ 函数 memmove，而不是 memcpy。此方法的运算复杂度为 O(n)，其中 n 是 length。
MethodImplAttribute(MethodImplOptions.InternalCall)]用于说明该方法的具体实现可以从CLR内部找到。也就是代码到了这个程度已经脱离了C#范围，是clr内部的实现了。
Capacity的属性如果用户不手动设置，一般会使用EnsureCapacity来自动的根据集合大小进行调整。
public int Capacity { get { return _items.Length; } set { if (value < _size) { ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.value, ExceptionResource.ArgumentOutOfRange_SmallCapacity); } Contract.EndContractBlock(); if (value != _items.Length) { if (value > 0) { T[] newItems = new T[value]; if (_size > 0) { Array.Copy(_items, 0, newItems, 0, _size); } _items = newItems; } else { _items = _emptyArray; } } } } // Read-only property describing how many elements are in the List. public int Count { get { Contract.Ensures(Contract.Result<int>() >= 0); return _size; } } private void EnsureCapacity(int min) { if (_items.Length < min) { int newCapacity = _items.Length == 0? _defaultCapacity : _items.Length * 2; // Allow the list to grow to maximum possible capacity (~2G elements) before encountering overflow. // Note that this check works even when _items.Length overflowed thanks to the (uint) cast if ((uint)newCapacity > Array.MaxArrayLength) newCapacity = Array.MaxArrayLength; if (newCapacity < min) newCapacity = min; Capacity = newCapacity; } }
EnsureCapacity方法的参数min是目前能接受的最小容量，就是操作后数组的长度。
如果目前的数组长度小于min就返回，如果新的newCapacity大于最大数组允许的长度就为最大长度。如果翻倍后还是小于min，那么就把newCapacity设置为min。
从代码可知，使用索引获取和设置都是O(1)的复杂度
public T this[int index] { get { // Following trick can reduce the range check by one if ((uint) index >= (uint)_size) { ThrowHelper.ThrowArgumentOutOfRangeException(); } Contract.EndContractBlock(); return _items[index]; } set { if ((uint) index >= (uint)_size) { ThrowHelper.ThrowArgumentOutOfRangeException(); } Contract.EndContractBlock(); _items[index] = value; _version++; } } public void Add(T item) { if (_size == _items.Length) EnsureCapacity(_size + 1); _items[_size++] = item; _version++; } // Inserts an element into this list at a given index. The size of the list // is increased by one. If required, the capacity of the list is doubled // before inserting the new element. // public void Insert(int index, T item) { // Note that insertions at the end are legal. if ((uint) index > (uint)_size) { ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_ListInsert); } Contract.EndContractBlock(); if (_size == _items.Length) EnsureCapacity(_size + 1); if (index < _size) { Array.Copy(_items, index, _items, index + 1, _size - index); } _items[index] = item; _size++; _version++; }
AddRange分为默认的和指定索引的AddRange，
// Adds the elements of the given collection to the end of this list. If // required, the capacity of the list is increased to twice the previous // capacity or the new size, whichever is larger. // public void AddRange(IEnumerable<T> collection) { Contract.Ensures(Count >= Contract.OldValue(Count)); InsertRange(_size, collection); } // Inserts the elements of the given collection at a given index. If // required, the capacity of the list is increased to twice the previous // capacity or the new size, whichever is larger. Ranges may be added // to the end of the list by setting index to the List‘s size. // public void InsertRange(int index, IEnumerable<T> collection) { if (collection==null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.collection); } if ((uint)index > (uint)_size) { ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_Index); } ICollection<T> c = collection as ICollection<T>; if( c != null ) { // if collection is ICollection<T> int count = c.Count; if (count > 0) { EnsureCapacity(_size + count); if (index < _size) { Array.Copy(_items, index, _items, index + count, _size - index); } // If we‘re inserting a List into itself, we want to be able to deal with that. if (this == c) { // Copy first part of _items to insert location Array.Copy(_items, 0, _items, index, index); // Copy last part of _items back to inserted location Array.Copy(_items, index+count, _items, index*2, _size-index); } else { T[] itemsToInsert = new T[count]; c.CopyTo(itemsToInsert, 0); itemsToInsert.CopyTo(_items, index); } _size += count; } } else { using(IEnumerator<T> en = collection.GetEnumerator()) { while(en.MoveNext()) { Insert(index++, en.Current); } } } _version++; }
这里的步骤是先确保容量足够，然后调用Array.Copy为将要插入的数据余出空间。然后再次调用把新插入的数组赋值到_items。
Remove和RemoveRange实际都是调用Array.Copy方法，这里removeAll的循环判断稍微有点绕，但是仔细研究下就能懂。
public bool Remove(T item) { int index = IndexOf(item); if (index >= 0) { RemoveAt(index); return true; } return false; } void System.Collections.IList.Remove(Object item) { if(IsCompatibleObject(item)) { Remove((T) item); } }
// Removes the element at the given index. The size of the list is // decreased by one. public void RemoveAt(int index) { if ((uint)index >= (uint)_size) { ThrowHelper.ThrowArgumentOutOfRangeException(); } _size--; if (index < _size) { Array.Copy(_items, index + 1, _items, index, _size - index); //相当于把数组index后面的元素都向前赋值 } _items[_size] = default(T); _version++; } // Removes a range of elements from this list. // public void RemoveRange(int index, int count) { if (index < 0) { ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum); } if (count < 0) { ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.count, ExceptionResource.ArgumentOutOfRange_NeedNonNegNum); } if (_size - index < count) ThrowHelper.ThrowArgumentException(ExceptionResource.Argument_InvalidOffLen); Contract.EndContractBlock(); if (count > 0) { int i = _size; _size -= count; if (index < _size) { Array.Copy(_items, index + count, _items, index, _size - index); } Array.Clear(_items, _size, count); _version++; } }
// This method removes all items which matches the predicate. // The complexity is O(n). public int RemoveAll(Predicate<T> match) { if( match == null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.match); } int freeIndex = 0; // the first free slot in items array // Find the first item which needs to be removed. while( freeIndex < _size && !match(_items[freeIndex])) freeIndex++; if( freeIndex >= _size) return 0; int current = freeIndex + 1; while( current < _size) { // Find the first item which needs to be kept. while( current < _size && match(_items[current])) current++; if( current < _size) { // copy item to the free slot. _items[freeIndex++] = _items[current++]; } } Array.Clear(_items, freeIndex, _size - freeIndex); int result = _size - freeIndex; _size = freeIndex; _version++; return result; }
标签：ack 改变 实现 cat block root tip alc copy
原文地址：https://www.cnblogs.com/qixinbo/p/12899800.html
