重学c#系列——list(十二)

前言

简单介绍一下list。

正文

这里以list为介绍。

private static readonly T[] s_emptyArray = new T[0];public List(){this._items = List<T>.s_emptyArray;}

list 本质是一个数组。

同样我们可以指定容量，如果我们知道了我们大概需要多少数据，那么我们可以指定一下，这样避免了resize的损耗。

就跟我们操作系统一样，提前申请内存大小。所以我们程序一般都有一个申请内存，实际使用内存，内存碎片这几个概念。

添加也是很简单哈。

public void Add(T item){++this._version;T[] items = this._items;int size = this._size;if ((uint) size < (uint) items.Length){this._size = size + 1;items[size] = item;}elsethis.AddWithResize(item);}

判断是否满了，如果没满直接存到数组里面去，如果满了，那么resize一下。

看下resize。

private void AddWithResize(T item){int size = this._size;this.EnsureCapacity(size + 1);this._size = size + 1;this._items[size] = item;}

然后看一下扩容步骤。

private void EnsureCapacity(int min){if (this._items.Length >= min)return;int num = this._items.Length == 0 ? 4 : this._items.Length * 2;if ((uint) num > 2146435071U)num = 2146435071;if (num < min)num = min;this.Capacity = num;}

首先在做了一次判断，判断是否容量够用，所以是size+1。

if (this._items.Length >= min)return;

这里就有人问了外面不是判断了，为什么里面还有判断。

这个就是一些人喜欢谈性能的地方了，认为多此一举，如果里面不判断那么就不是一个成熟的方法，提现不出方法的封闭性,因为方法的作用是之和参数打交道，外面是什么其实是不管的。

那么可以看出，一开始是4，然后后面就是翻倍了。

然后重点看下:

this.Capacity = num;

这个this.Capacity 并不是普通的变量，而是一个属性哈，不然你都纳闷它是怎么扩容了。

public int Capacity{get => _items.Length;set{if (value < _size){ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.value, ExceptionResource.ArgumentOutOfRange_SmallCapacity);}if (value != _items.Length){if (value > 0){T[] newItems = new T[value];if (_size > 0){Array.Copy(_items, newItems, _size);}_items = newItems;}else{_items = s_emptyArray;}}}}

首先判断了不能缩容，如果缩容直接异常，其次我们注意道这个Capacity 是piblic的，也就是说我们在外部就可以直接调用。

后面逻辑就很简单创建一个新的数组，然后复制就ok了,然后重新赋值_items。

那么来看一下remove吧。

public bool Remove(T item){int index = IndexOf(item);if (index >= 0){RemoveAt(index);return true;}return false;}

首先是找到其位置:

public int IndexOf(T item)=> Array.IndexOf(_items, item, 0, _size);int IList.IndexOf(object? item){if (IsCompatibleObject(item)){return IndexOf((T)item!);}return -1;}

可以看一下这个IsCompatibleObject，还是很有趣的。

private static bool IsCompatibleObject(object? value){// Non-null values are fine.  Only accept nulls if T is a class or Nullable<U>.// Note that default(T) is not equal to null for value types except when T is Nullable<U>.return (value is T) || (value == null && default(T) == null);}

从这个说明，其实我们是可以传空对象的。

static void Main(string[] args){List<object> lists = new List<object>();lists.Add(null);Console.WriteLine(lists.Count);lists.Remove(null);Console.ReadLine();}

那么来看一下removeat吧。

public void RemoveAt(int index){if ((uint)index >= (uint)_size){ThrowHelper.ThrowArgumentOutOfRange_IndexException();}_size--;if (index < _size){Array.Copy(_items, index + 1, _items, index, _size - index);}if (RuntimeHelpers.IsReferenceOrContainsReferences<T>()){_items[_size] = default!;}_version++;}

这里可以看出list的remove操作还是性能损耗很大的，尤其是大的list。

这里有没有注意道一个_version，这个有什么作用呢?

当遍历的时候我们就用的到。

internal Enumerator(List<T> list){_list = list;_index = 0;_version = list._version;_current = default;}public void Dispose(){}public bool MoveNext(){List<T> localList = _list;if (_version == localList._version && ((uint)_index < (uint)localList._size)){_current = localList._items[_index];_index++;return true;}return MoveNextRare();}private bool MoveNextRare(){if (_version != _list._version){ThrowHelper.ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion();}_index = _list._size + 1;_current = default;return false;}

重点看上面的list，上面表面了，当我们使用foreach 进行遍历的时候，如果我们进行了删除或者添加，那么_version就会发生变化，那么可想而知会抛出异常。

例子:

static void Main(string[] args){List<object> lists = new List<object>();lists.Add("123456");lists.Add("1231246");lists.Add("dsadadsads");lists.Add("eqewqew");foreach (var item in lists){if (item.ToString() == "1231246"){lists.Remove(item);}}Console.ReadLine();}

然后就会抛出异常了。

那么这里就不介绍find了，find 就是遍历数组，找出是否相等。

哦，对了讲另外一个故事。

public int Count => _size;

count-1 就是当前插入的位置。

那么如果你想删除某个元素的时候，那么你可以进行removeat 删除，这样避免了find。

那么非常值得注意的是如果删除了其他元素，如果那么元素的位置小于你记录的位置，那么应该是位置进行减一。

结

以上仅是个人整理，如有错误望请指点。这个系列后面也会整理一下集合相关的源码。