C#集合类型大揭秘 【转载】

【地址】https://www.cnblogs.com/songwenjie/p/9185790.html

集合是.NET FCL(Framework Class Library)的重要组成部分，咱们日常撸C#代码时免不了和集合打交道，FCL提供了丰富易用的集合类型，给咱们撸码提供了极大的便利。正是由于这种与生俱来的便利性，使得咱们对集合既熟悉又陌生。不少同窗可能一直仍是停留在使用的层面上，那么今天咱们一块儿来深刻学习一下C#语言中的各类集合。

首先咱们看一下 FCL 给咱们提供的集合接口：

FCL提供了泛型和非泛型两大类集合类型。由于非泛型集合装箱和拆箱带来的性能开销问题，和泛型集合相比，已经变得愈来愈鸡肋。因此咱们也侧重于泛型集合的分析，可是二者差异不大。

IEnumerable和IEnumerator

IEnumerable接口是全部集合类型的祖宗接口，其做用至关于Object类型之于其它类型。若是某个类型实现了IEnumerable接口，就意味着它能够被迭代访问，也就能够称之为集合类型（可枚举）。IEnumerable接口定义很是简单，只有一个GetEnumerator()方法用于获取IEnumerator类型的迭代器。

咱们能够将迭代器想象成数据库的游标，即序列（集合）中的某个位置，迭代器只能在序列（集合）中向前移动。每调用一次MoveNext()，若是序列（集合）中还有下一个元素，则迭代器移动到下一个元素；Current用于获取序列（集合）中的当前元素；由于迭代器调用一次代码只须要获取一个元素，这意味着咱们须要肯定访问到了序列（集合）中的哪一个位置。Reset()用于重置这种状态，可是基本上不会使用Reset()重置状态。

同一个序列（集合）可能同时存在多个迭代器操做，至关于同时对一个集合进行多个遍历。这种状况下可能会出现迭代彼此交错。那么如何解决呢？

集合类不直接支持 IEnumerator 和
IEnumerator 接口。而是直接支持 IEnumerable接口，其惟一方法是 GetEnumerator，此方法用于返回支持 IEnumerator 的对象。每次调用GetEnumerator()方法时都须要建立一个新的对象，同时迭代器必须保存自身的状态，记录此时已经迭代到哪个元素。这样迭代器就像是序列中的游标。能够有多个游标，移动其中任何一个均可以枚举集合，与其余迭代器互不影响。

foreach是怎么实现的？

for依赖对 Length 属性和索引运算符 ([]) 的支持。借助 Length 属性，C# 编译器可使用 for 语句迭代数组中的每一个元素。for适用于长度固定且始终支持索引运算符的数组，但并非全部类型集合的元素数量都是已知的。此外，许多集合类（包括 Stack、Queue 和 Dictionary）都不支持按索引检索元素。所以，须要使用一种更为通用的方法来迭代元素集合。假设能够肯定第一个、第二个和最后一个元素，那么就没有必要知道元素数量，也没有必要支持按索引检索元素。foreach在这种背景下应运而生。实际上，foreach内部使用迭代器的MoveNext和Current完成元素的遍历。

List<int> list = new List<int>(); List<int>.Enumerator enumerator = list.GetEnumerator(); try { int number; while (enumerator.MoveNext()) { number = enumerator.Current; Console.WriteLine(number); } } finally { enumerator.Dispose(); }

实现自定义集合

咱们能够本身实现IEnumerable接口和IEnumerator接口实现自定义集合。

实现自定义可枚举类型：

public class MySet : IEnumerable { internal object[] values; public MySet(object[] values) { this.values = values; } public IEnumerator GetEnumerator() { return new MySetIterator(this); } }

手写实现自定义迭代器：

public class MySetIterator : IEnumerator { MySet set; /// <summary> /// 保存迭代到的位置 /// </summary> int position; internal MySetIterator(MySet set) { this.set = set; position = -1; } public object Current { get { if(position==-1||position==set.values.Length) { throw new InvalidOperationException(); } int index = position; return set.values[index]; } } public bool MoveNext() { if(position!=set.values.Length) { position++; } return position < set.values.Length; } public void Reset() { position = -1; } }

测试程序：

object[] values = { "a", "b", "c", "d", "e" }; MySet mySet = new MySet(values); foreach (var item in mySet) { Console.WriteLine(item); }

这个例子也证实了foreach内部使用迭代器的MoveNext和Current完成遍历。

上面的例子中手写实现迭代器是十分麻烦的，在c#1.0中这是惟一的方式。在c#2.0中，咱们可使用yield语法糖简化迭代器。

public IEnumerator GetEnumerator() { for (int i = 0; i < values.Length; i++) { yield return values[i]; } }

IEnumerable和IEnumerator虽然实现简单，只有简单的几个成员，可是却支撑起了C#语言中集合这座高楼大厦。

ICollection和ICollection

从第一张图中，咱们能够得知ICollection继承于IEnumerable接口，而且扩展了IEnumerable接口。

主要扩展的功能有：

1. 新增了属性Count,用于记录集合元素个数
2. 支持添加元素和移除元素
3. 支持是否包含某元素
4. 支持清空集合等等

对于任何实现了ICollection接口的集合，咱们均可以经过第1条Count属性获取当前集合的元素数，因此这些集合也被称为计数集合。

IList 和IList

IList接口直接继承于ICollection接口和IEnumerable接口，而且扩展了经过索引操做集合的功能。

主要扩展的功能有：

1. 经过索引获取集合中某个元素
2. 经过元素获取元素在集合中的索引值
3. 经过索引插入元素到集合指定位置
4. 移除集合指定索引处的元素

IDictionary<tkey, tvalue="">和IDictionary

IDictionary接口直接继承于ICollection接口和IEnumerable接口，存储的元素是键值对，扩展了经过键操做键值对集合的功能。

主要扩展的功能有：

1. 经过键KEY获取值VALUE
2. 插入新的键值对{KEY:VALUE}
3. 是否包含KEY
4. 经过KEY移除键值对元素

主要的集合的接口介绍完了，下面咱们来看一下具体的集合类型。

关联性泛型集合类

1.Dictionary<tkey,tvalue>

Dictionary<tkey,tvalue>的查询数据所花费的时间是全部集合类里面最快的，由于其内部使用了散列函数加双数组来实现，因此其查询数据操做的时间复杂度能够认为是O（1）。Dictionary<tkey,tvalue>的实现是一种典型的牺牲空间换取时间（双数组）的作法。

Dictionary<tkey,tvalue>添加新元素的实现：

Dictionary<tkey,tvalue>内部有两个数组，一个数组名为buckets，用于存放由多个同义词组成的静态链表头指针（链表的第一个元素在数组中的索引号，当它的值为-1时表示此哈希地址不存在元素）；另外一个数组为entries，它用于存放哈希表中的实际数据，同时这些数据经过next指针构成多个单链表。entries数组中所存放的是Entry结构体，Entry结构体由4个部分组成，以下所示：

Dictionary<tkey,tvalue>计算key的哈希值使用的是取余法，这种方式可能会产生冲突，因此须要进行冲突解决。Dictionary<tkey,tvalue>解决冲突的方式是连接法。

咱们能够根据源码来模拟推导一下这个过程：

当添加第一个元素时，此时会分配哈希表buckets数组和entries数组的空间和初始大小，默认为3。对key=1进行哈希求值，假设第一个元素的哈希值=9，而后targetBucket = 9%buckets.Length(3)的值为0，因此第一个元素应该放在entries数组的第一位。最后对哈希表buckets数组赋值，数组索引为0，值为0。此时内部结构如图所示：

而后插入第二个元素，对key=2进行哈希求值，假设第二个元素的哈希值=3，而后targetBucket = 3%buckets.Length (默认是3)的值为0，因此第二个元素应该放在entries数组的第一位。可是entries数组的第一位已经存在元素了，这就发生了冲突。Dictionary<tkey,tvalue>解决冲突的方式是连接法，把发生冲突的元素连接以前元素的后面，经过next属性来指定冲突关系，最后更新哈希表buckets数组。此时内部结构如图所示：

咱们能够经过Dictionary<tkey,tvalue>查找元素的实现来证实咱们上面的分析是正确的。

Dictionary<tkey,tvalue>查找元素的实现：

Dictionary<tkey,tvalue>之因此能实现快速查找元素，其内部使用哈希表来存储元素对应的位置，咱们能够经过哈希值快速地从哈希表中定位元素所在的位置索引，从而快速获取到key对应的Value值。物极必反，Dictionary<tkey,tvalue>的缺点也很明显，就是里面的数据是无序排列的，因此按照必定顺序遍历查找数据效率是很是低的。

2.SortedDictionary<tkey,tvalue>

SortedDictionary<tkey,tvalue>和Dictionary<tkey,tvalue>相似，至于区别咱们从名称上就能够看出来，Dictionary<tkey,tvalue>是无序的，SortedDictionary<tkey,tvalue>则是有序的。key要保证惟一，并且还要有序排列，这让咱们很天然的就想到了搜索二叉树。SortedDictionary<tkey,tvalue>使用一种平衡搜索二叉树——红黑树，做为存储结构。由于基于二分查找，因此添加、查找、删除元素的时间复杂度是O(log n)。相对于下面提到的SortedList<tkey,tvalue>来讲，SortedDictionary<tkey,tvalue>在添加和删除元素时更快一些。若是想要快速查询的同时又能很好的支持排序的话，而且添加和删除元素也比较频繁，可使用SortedDictionary<tkey,tvalue>。

SortedDictionary<tkey,tvalue>添加新元素的实现：

3.SortedList<tkey,tvalue>

在既须要快速查找又须要顺序排列的场景下，Dictionary<tkey,tvalue>就无能为力了，由于Dictionary<tkey,tvalue>使用了散列函数，并不支持线性排序。咱们可使用SortedList<tkey,tvalue>集合类来应对这种场景。

SortedList<tkey,tvalue>集合内部是使用数组实现的，添加和删除元素的时间复杂度是O(n)，查找元素利用了二分查找，因此查找元素的时间复杂度是O(log n)。因此SortedList<tkey,tvalue>虽然支持了有序排列，可是倒是以牺牲查找效率为代价的。

SortedList<tkey,tvalue>和SortedDictionary<tkey,tvalue>同时支持快速查询和排序，SortedList<tkey,tvalue> 优点在于使用的内存比 SortedDictionary<tkey,tvalue> 少；可是SortedDictionary<tkey,tvalue>可对未排序的数据执行更快的插入和移除操做：它的时间复杂度为 O(log n)，而 SortedList<tkey,tvalue> 为 O(n)。因此SortedList<tkey,tvalue>适用于既须要快速查找又须要顺序排列可是添加和删除元素较少的场景。

内部实现结构：

根据Key获取Value的实现：

IndexOfKey实现：

添加新元素：

添加操做：

非关联性泛型集合类

1.List

泛型的List 类提供了不限制长度的集合类型，List内部实现使用数据结构是数组。咱们都知道数组是长度固定的，那么List不限制长度一定须要维护这个数组。实际上List维护了必定长度的数组（默认为4），当插入元素的个数超过4或初始长度时，会去从新建立一个新的数组,这个新数组的长度是初始长度的2倍，而后将原来的数组赋值到新的数组中。

咱们能够经过ILSpy看一下List源码证实咱们上面所说的：

List内部重要变量：

新增元素操做：

新增元素确认数组容量：

真正的数组扩容操做：

数组扩容的场景涉及到对象的建立和赋值，是比较消耗性能的。因此若是能指定一个合适的初始长度，能避免频繁的对象建立和赋值。再者，由于内部的数据结构是数组，插入和删除操做须要移动元素位置，因此不适合频繁的进行插入和删除操做；可是能够经过数组下标查找元素。因此List适合读多写少的场景。

2.LinkedList

上面咱们提到List适合读多写少的场景，那么一定有一个List适合写多读少的场景，就是这货了——LinkedList。至于为何适合写多读少，熟悉数据结构的同窗应该已经猜到了。由于LinkedList的内部实现使用的是链表结构，并且仍是双向链表。直接看源码：

由于内部实现结构是链表，因此能够在某一个节点前或节点后插入新的元素。

链表节点定义：

咱们以在某个节点前插入新元素为例：

具体的插入操做，注意操做步骤不能颠倒：

3.HashSet

HashSet是一个无序的可以保持惟一性的集合。咱们能够将HashSet看做是简化的Dictionary<tkey,tvalue>，只不过Dictionary<tkey,tvalue>存储的键值对对象，而HashSet存储的是普通对象。其内部实现也和Dictionary<tkey,tvalue>基本一致，也是散列函数加双数组实现的,区别是存储的Slot结构体再也不有key。

内部实现数据结构：

m_slots中所存放的是Slot结构体，Slot结构体由3个部分组成，以下所示：

添加新元素的具体实现：

和Dictionary<tkey,tvalue>添加新元素的实现基本一致。

4.SortedSet

SortedSet和HashSet,就像SortedDictionary<tkey,tvalue>和Dictionary<tkey,tvalue>同样。SortedSet支持元素按顺序排列，内部实现也是红黑树，而且SortedSet对于红黑树的操做方法和SortedDictionary<tkey,tvalue>彻底相同。因此再也不作过多的分析。

5.Stack

栈是一种后进先出的结构，C#的栈是借助数组实现的，考虑到栈后进先出的特性，使用数组来实现貌似是水到渠成的事。

入栈操做：

弹栈操做：

6.Queue

队列是一种先进先出的结构，C#的队列也是借助数组实现的，有了前面的经验，借助数组实现必然会有数组扩容。C#的队列实现实际上是循环队列的方式，能够简单的理解为将队列的头尾相接。至于为何要这么作？为了节省存储空间和减小元素的移动。由于元素出队列时后面的元素跟着前移是很是消耗性能的，可是不跟着向前移动的话，前面就会一直存在空闲的空间浪费内存。因此使用循环队列来解决这种问题。

入队操做：

出队操做：

线程安全的集合类

须要咱们注意的是，上面咱们所介绍的集合并非线程安全的，在多线程环境下，可能会出现线程安全问题。在多线程读的状况下，咱们使用普通集合便可。在多线程添加/更新/删除时，咱们能够采用手动锁定的方式确保线程安全，可是应该注意加锁的范围和粒度，加锁不当可能会致使程序性能低下甚至产生死锁。

更好的选择的是使用的C#提供的线程安全集合（命名空间：System.Collections.Concurrent）。线程安全集合使用几种算法来最小化线程阻塞。

1. ConcurrentQueue： 线程安全版本的Queue
2. ConcurrentStack：线程安全版本的Stack
3. ConcurrentBag：线程安全的对象集合
4. ConcurrentDictionary：线程安全的Dictionary

总结

写着写着忽然发现跑到数据结构上来了。程序=数据结构+算法。上面提到的集合类型，咱们须要在不一样的场景进行合适的选择，其实本质上就是选择合适的数据结构。

参考：

https://www.cnblogs.com/jesse2013/p/CollectionsInCSharp.html

https://www.c-sharpcorner.com/article/concurrent-collections-in-net-concurrentdictionary-part-one/

http://www.cnblogs.com/jeffwongishandsome/archive/2012/09/09/2677293.html

http://www.cnblogs.com/edisonchou/p/4706253.html