C#学习常用类（1003）---ConcurrentDictionary<TKey,TValue>

ConcurrentDictionary类

表示可由多个线程同时访问的键/值对的线程安全集合。

命名空间:                   System.Collections.Concurrent
程序集:         mscorlib（位于 mscorlib.dll）

继承层次结构

System.Object
System.Collections.Concurrent.ConcurrentDictionary

语法：

[SerializableAttribute]
[ComVisibleAttribute(false)]
[HostProtectionAttribute(SecurityAction.LinkDemand, Synchronization = true, 
ExternalThreading = true)]
public class ConcurrentDictionary : IDictionary, 
ICollection>, IEnumerable>, 
IEnumerable, IDictionary, ICollection, IReadOnlyDictionary, 
IReadOnlyCollection>

类型参数

• TKey

• 字典中的键的类型。

• TValue

• 字典中的值的类型。

构造函数

	名称	说明
	ConcurrentDictionary()	初始化 ConcurrentDictionary 类的新实例，该实例为空，具有默认的并发级别和默认的初始容量，并为键类型使用默认比较器。
	ConcurrentDictionary(IEnumerable>)	初始化 ConcurrentDictionary 类的新实例，该实例包含从指定的 IEnumerable 中复制的元素，具有默认的并发级别和默认的初始容量，并为键类型使用默认比较器。
	ConcurrentDictionary(IEnumerable>,IEqualityComparer)	初始化 ConcurrentDictionary 类的新实例，该实例包含从指定的 IEnumerable 中复制的元素，具有默认的并发级别和默认的初始容量，并使用指定的 IEqualityComparer。
	ConcurrentDictionary(IEqualityComparer)	初始化 ConcurrentDictionary 类的新实例，该实例为空，具有默认的并发级别和容量，并使用指定的 System.Collections.Generic.IEqualityComparer。
	ConcurrentDictionary(Int32,IEnumerable>,IEqualityComparer)	初始化 ConcurrentDictionary 类的新实例，该实例包含从指定的 IEnumerable 中复制的元素并使用指定的 System.Collections.Generic.IEqualityComparer。
	ConcurrentDictionary(Int32,Int32)	初始化 ConcurrentDictionary 类的新实例，该实例为空，具有指定的并发级别和容量，并为键类型使用默认比较器。
	ConcurrentDictionary(Int32,Int32,IEqualityComparer)	初始化 System.Collections.Concurrent.ConcurrentDictionary 类的新实例，该实例为空，具有指定的并发级别和指定的初始容量，并使用指定的 System.Collections.Generic.IEqualityComparer。

属性

	名称	说明
	Count	获取包含在 System.Collections.Concurrent.ConcurrentDictionary 中的键/值对的数目。
	IsEmpty	获取一个值，该值指示 System.Collections.Concurrent.ConcurrentDictionary 是否为空。
	Item[TKey]	获取或设置与指定的键关联的值。
	Keys	获得一个包含 System.Collections.Generic.Dictionary 中的键的集合。
	Values	获取包含 System.Collections.Generic.Dictionary 中的值的集合。

方法

	名称	说明
	AddOrUpdate(TKey,TValue,Func)	如果该键不存在，则将键/值对添加到 ConcurrentDictionary 中；如果该键已经存在，则通过使用指定的函数更新 ConcurrentDictionary 中的键/值对。
	AddOrUpdate(TKey,Func,Func)	如果该键不存在，则使用指定函数将键/值对添加到 ConcurrentDictionary；如果该键已存在，则使用该函数更新 ConcurrentDictionary 中的键/值对。
	Clear()	将所有键和值从 ConcurrentDictionary 中移除。
	ContainsKey(TKey)	确定是否 ConcurrentDictionary 包含指定键。
	Equals(Object)	确定指定的对象是否等于当前对象。（继承自 Object。）
	Finalize()	在垃圾回收将某一对象回收前允许该对象尝试释放资源并执行其他清理操作。（继承自 Object。）
	GetEnumerator()	返回循环访问 ConcurrentDictionary 的枚举数。
	GetHashCode()	作为默认哈希函数。（继承自 Object。）
	GetOrAdd(TKey,TValue)	如果该键不存在，则将键/值对添加到 ConcurrentDictionary 中。
	GetOrAdd(TKey,Func)	如果该键不存在，则通过使用指定的函数将键/值对添加到 ConcurrentDictionary 中。
	GetType()	获取当前实例的 Type。（继承自 Object。）
	MemberwiseClone()	创建当前 Object 的浅表副本。（继承自 Object。）
	ToArray()	将 System.Collections.Concurrent.ConcurrentDictionary 中存储的键和值对复制到新数组中。
	ToString()	返回表示当前对象的字符串。（继承自 Object。）
	TryAdd(TKey,TValue)	尝试将指定的键和值添加到 System.Collections.Concurrent.ConcurrentDictionary 中。
	TryGetValue(TKey,TValue)	尝试从 System.Collections.Concurrent.ConcurrentDictionary 获取与指定的键关联的值。
	TryRemove(TKey,TValue)	尝试从 System.Collections.Concurrent.ConcurrentDictionary 中移除并返回具有指定键的值。
	TryUpdate(TKey,TValue,TValue)	将指定键的现有值与指定值进行比较，如果相等，则用第三个值更新该键。

扩展方法

	名称	说明
	Aggregate>(Func,KeyValuePair,KeyValuePair>)	已重载。对一个序列应用累加器函数。（由 Enumerable 定义。）
	Aggregate,TAccumulate>(TAccumulate,Func<TAccumulate,KeyValuePair,TAccumulate>)	已重载。对一个序列应用累加器函数。 将指定的种子值用作累加器初始值。（由 Enumerable 定义。）
	Aggregate,TAccumulate,TResult>(TAccumulate,Func<TAccumulate,KeyValuePair,TAccumulate>,Func)	已重载。对一个序列应用累加器函数。 将指定的种子值用作累加器的初始值，并使用指定的函数选择结果值。（由 Enumerable 定义。）
	All>(Func,Boolean>)	确定是否对序列中的所有元素都满足条件。（由 Enumerable 定义。）
	Any>()	已重载。确定序列是否包含任何元素。（由 Enumerable 定义。）
	Any>(Func,Boolean>)	已重载。  确定序列中是否存在元素满足条件。（由 Enumerable 定义。）
	AsEnumerable>()	返回输入类型化为 IEnumerable。（由 Enumerable 定义。）
	AsParallel()	已重载。启用查询的并行化。（由 ParallelEnumerable 定义。）
	AsParallel>()	已重载。启用查询的并行化。（由 ParallelEnumerable 定义。）
	AsQueryable()	已重载。将转换 IEnumerable 到 IQueryable。（由 Queryable 定义。）
	AsQueryable>()	已重载。将转换泛型 IEnumerable 于泛型 IQueryable。（由 Queryable 定义。）
	Average>(Func,Decimal>)	已重载。计算序列的平均值 Decimal 通过调用对输入序列中的每个元素的转换函数获得的值。（由 Enumerable 定义。）
	Average>(Func,Double>)	已重载。计算序列的平均值 Double 通过调用对输入序列中的每个元素的转换函数获得的值。（由 Enumerable 定义。）
	Average>(Func,Int32>)	已重载。计算序列的平均值 Int32 通过调用对输入序列中的每个元素的转换函数获得的值。（由 Enumerable 定义。）
	Average>(Func,Int64>)	已重载。计算序列的平均值 Int64 通过调用对输入序列中的每个元素的转换函数获得的值。（由 Enumerable 定义。）
	Average>(Func,Nullable>)	已重载。可以为 null 的序列的平均值，计算 Decimal 通过调用对输入序列中的每个元素的转换函数获得的值。（由 Enumerable 定义。）
	Average>(Func,Nullable>)	已重载。可以为 null 的序列的平均值，计算 Double 通过调用对输入序列中的每个元素的转换函数获得的值。（由 Enumerable 定义。）
	Average>(Func,Nullable>)	已重载。可以为 null 的序列的平均值，计算 Int32 通过调用对输入序列中的每个元素的转换函数获得的值。（由 Enumerable 定义。）
	Average>(Func,Nullable>)	已重载。可以为 null 的序列的平均值，计算 Int64 通过调用对输入序列中的每个元素的转换函数获得的值。（由 Enumerable 定义。）
	Average>(Func,Nullable>)	已重载。可以为 null 的序列的平均值，计算 Single 通过调用对输入序列中的每个元素的转换函数获得的值。（由 Enumerable 定义。）
	Average>(Func,Single>)	已重载。计算序列的平均值 Single 通过调用对输入序列中的每个元素的转换函数获得的值。（由 Enumerable 定义。）
	Cast()	将强制转换的元素 IEnumerable 为指定的类型。（由 Enumerable 定义。）
	Concat>(IEnumerable>)	连接两个序列。（由 Enumerable 定义。）
	Contains>(KeyValuePair)	已重载。确定序列是否包含指定的元素使用的默认相等比较器。（由 Enumerable 定义。）
	Contains>(KeyValuePair,IEqualityComparer>)	已重载。确定序列是否使用指定的包含指定的元素 IEqualityComparer。（由 Enumerable 定义。）
	Count>()	已重载。返回序列中的元素数。（由 Enumerable 定义。）
	Count>(Func,Boolean>)	已重载。返回一个数字来表示多少个元素指定序列中的满足条件。（由 Enumerable 定义。）
	DefaultIfEmpty>()	已重载。返回单一实例集合中指定的序列或类型参数的默认值的元素，如果序列为空。（由 Enumerable 定义。）
	DefaultIfEmpty>(KeyValuePair)	已重载。返回单一实例集合中指定的序列或指定的值的元素，如果序列为空。（由 Enumerable 定义。）
	Distinct>()	已重载。通过使用的默认相等比较器对值进行比较从序列返回非重复元素。（由 Enumerable 定义。）
	Distinct>(IEqualityComparer>)	已重载。返回序列中通过使用指定的非重复元素 IEqualityComparer 对值进行比较。（由 Enumerable 定义。）
	ElementAt>(Int32)	返回序列中的指定索引处的元素。（由 Enumerable 定义。）
	ElementAtOrDefault>(Int32)	返回序列中指定索引处的元素；如果索引超出范围，则返回默认值。（由 Enumerable 定义。）
	Except>(IEnumerable>)	已重载。通过使用默认的相等比较器对值进行比较，生成两个序列的差集。（由 Enumerable 定义。）
	Except>(IEnumerable>,IEqualityComparer>)	已重载。使用指定的生成两个序列的差集 IEqualityComparer 对值进行比较。（由 Enumerable 定义。）
	First>()	已重载。返回一个序列的第一个元素。（由 Enumerable 定义。）
	First>(Func,Boolean>)	已重载。返回序列中满足指定条件的第一个元素。（由 Enumerable 定义。）
	FirstOrDefault>()	已重载。返回序列中的第一个元素；如果序列中不包含任何元素，则返回默认值。（由 Enumerable 定义。）
	FirstOrDefault>(Func,Boolean>)	已重载。返回序列中满足条件的第一个元素；如果未找到这样的元素，则返回默认值。（由 Enumerable 定义。）
	GroupBy,TKey>(Func,TKey>)	已重载。根据指定的键选择器函数对序列的元素进行分组。（由 Enumerable 定义。）
	GroupBy,TKey>(Func,TKey>,IEqualityComparer)	已重载。根据指定的键选择器函数并将进行比较的键使用指定的比较器对序列的元素进行分组。（由 Enumerable 定义。）
	GroupBy,TKey,TElement>(Func,TKey>,Func,TElement>)	已重载。根据指定的键选择器函数和项目的元素的每个组通过使用指定的函数对序列的元素进行分组。（由 Enumerable 定义。）
	GroupBy,TKey,TElement>(Func,TKey>,Func,TElement>,IEqualityComparer)	已重载。根据键选择器函数对序列的元素进行分组。 通过使用比较器对键进行比较，并且通过使用指定的函数对每个组的元素进行投影。（由 Enumerable 定义。）
	GroupBy,TKey,TResult>(Func,TKey>,Func<TKey,IEnumerable>,TResult>)	已重载。根据指定的键选择器函数对序列中的元素进行分组，并且从每个组及其键中创建结果值。（由 Enumerable 定义。）
	GroupBy,TKey,TResult>(Func,TKey>,Func<TKey,IEnumerable>,TResult>,IEqualityComparer)	已重载。根据指定的键选择器函数对序列中的元素进行分组，并且从每个组及其键中创建结果值。 通过使用指定的比较器对键进行比较。（由 Enumerable 定义。）
	GroupBy,TKey,TElement,TResult>(Func,TKey>,Func,TElement>,Func<TKey,IEnumerable,TResult>)	已重载。根据指定的键选择器函数对序列中的元素进行分组，并且从每个组及其键中创建结果值。 通过使用指定的函数对每个组的元素进行投影。（由 Enumerable 定义。）
	GroupBy,TKey,TElement,TResult>(Func,TKey>,Func,TElement>,Func<TKey,IEnumerable,TResult>,IEqualityComparer)	已重载。根据指定的键选择器函数对序列中的元素进行分组，并且从每个组及其键中创建结果值。 通过使用指定的比较器对键值进行比较，并且通过使用指定的函数对每个组的元素进行投影。（由 Enumerable 定义。）
	GroupJoin,TInner,TKey,TResult>(IEnumerable,Func,TKey>,Func,Func,IEnumerable,TResult>)	已重载。基于键相等对两个序列的元素进行关联，并对结果进行分组。 使用默认的相等比较器对键进行比较。（由 Enumerable 定义。）
	GroupJoin,TInner,TKey,TResult>(IEnumerable,Func,TKey>,Func,Func,IEnumerable,TResult>,IEqualityComparer)	已重载。基于键相等对两个序列的元素进行关联，并对结果进行分组。 指定 IEqualityComparer 用来对键进行比较。（由 Enumerable 定义。）
	Intersect>(IEnumerable>)	已重载。通过使用默认的相等比较器对值进行比较，生成两个序列的交集。（由 Enumerable 定义。）
	Intersect>(IEnumerable>,IEqualityComparer>)	已重载。使用指定的生成两个序列的交集 IEqualityComparer 对值进行比较。（由 Enumerable 定义。）
	Join,TInner,TKey,TResult>(IEnumerable,Func,TKey>,Func,Func,TInner,TResult>)	已重载。基于匹配键对两个序列的元素关联。 使用默认的相等比较器对键进行比较。（由 Enumerable 定义。）
	Join,TInner,TKey,TResult>(IEnumerable,Func,TKey>,Func,Func,TInner,TResult>,IEqualityComparer)	已重载。基于匹配键对两个序列的元素关联。 指定 IEqualityComparer 用来对键进行比较。（由 Enumerable 定义。）
	Last>()	已重载。返回一个序列的最后一个元素。（由 Enumerable 定义。）
	Last>(Func,Boolean>)	已重载。返回序列中满足指定条件的最后一个元素。（由 Enumerable 定义。）
	LastOrDefault>()	已重载。返回序列中的最后一个元素；如果序列中不包含任何元素，则返回默认值。（由 Enumerable 定义。）
	LastOrDefault>(Func,Boolean>)	已重载。返回序列中满足条件的最后一个元素；如果未找到这样的元素，则返回默认值。（由 Enumerable 定义。）
	LongCount>()	已重载。返回 Int64 ，它表示序列中的元素的总数。（由 Enumerable 定义。）
	LongCount>(Func,Boolean>)	已重载。返回 Int64 表示序列中的多少个元素满足条件。（由 Enumerable 定义。）
	Max>()	已重载。泛型序列中返回的最大值。（由 Enumerable 定义。）
	Max>(Func,Decimal>)	已重载。调用转换函数对序列的每个元素并返回最大 Decimal 值。（由 Enumerable 定义。）
	Max>(Func,Double>)	已重载。调用转换函数对序列的每个元素并返回最大 Double 值。（由 Enumerable 定义。）
	Max>(Func,Int32>)	已重载。调用转换函数对序列的每个元素并返回最大 Int32 值。（由 Enumerable 定义。）
	Max>(Func,Int64>)	已重载。调用转换函数对序列的每个元素并返回最大 Int64 值。（由 Enumerable 定义。）
	Max>(Func,Nullable>)	已重载。调用转换函数对序列的每个元素并返回最大可以为 null Decimal 值。（由 Enumerable 定义。）
	Max>(Func,Nullable>)	已重载。调用转换函数对序列的每个元素并返回最大可以为 null Double 值。（由 Enumerable 定义。）
	Max>(Func,Nullable>)	已重载。调用转换函数对序列的每个元素并返回最大可以为 null Int32 值。（由 Enumerable 定义。）
	Max>(Func,Nullable>)	已重载。调用转换函数对序列的每个元素并返回最大可以为 null Int64 值。（由 Enumerable 定义。）
	Max>(Func,Nullable>)	已重载。调用转换函数对序列的每个元素并返回最大可以为 null Single 值。（由 Enumerable 定义。）
	Max>(Func,Single>)	已重载。调用转换函数对序列的每个元素并返回最大 Single 值。（由 Enumerable 定义。）
	Max,TResult>(Func,TResult>)	已重载。调用泛型序列的每个元素的转换函数并返回最大结果值。（由 Enumerable 定义。）
	Min>()	已重载。泛型序列中返回的最小值。（由 Enumerable 定义。）
	Min>(Func,Decimal>)	已重载。调用转换函数对序列的每个元素，并返回所需的最低 Decimal 值。（由 Enumerable 定义。）
	Min>(Func,Double>)	已重载。调用转换函数对序列的每个元素，并返回所需的最低 Double 值。（由 Enumerable 定义。）
	Min>(Func,Int32>)	已重载。调用转换函数对序列的每个元素，并返回所需的最低 Int32 值。（由 Enumerable 定义。）
	Min>(Func,Int64>)	已重载。调用转换函数对序列的每个元素，并返回所需的最低 Int64 值。（由 Enumerable 定义。）
	Min>(Func,Nullable>)	已重载。调用转换函数对序列的每个元素，并返回最小值可以为 null Decimal 值。（由 Enumerable 定义。）
	Min>(Func,Nullable>)	已重载。调用转换函数对序列的每个元素，并返回最小值可以为 null Double 值。（由 Enumerable 定义。）
	Min>(Func,Nullable>)	已重载。调用转换函数对序列的每个元素，并返回最小值可以为 null Int32 值。（由 Enumerable 定义。）
	Min>(Func,Nullable>)	已重载。调用转换函数对序列的每个元素，并返回最小值可以为 null Int64 值。（由 Enumerable 定义。）
	Min>(Func,Nullable>)	已重载。调用转换函数对序列的每个元素，并返回最小值可以为 null Single 值。（由 Enumerable 定义。）
	Min>(Func,Single>)	已重载。调用转换函数对序列的每个元素，并返回所需的最低 Single 值。（由 Enumerable 定义。）
	Min,TResult>(Func,TResult>)	已重载。调用泛型序列的每个元素的转换函数，并返回最小的结果值。（由 Enumerable 定义。）
	OfType()	筛选的元素 IEnumerable 根据指定的类型。（由 Enumerable 定义。）
	OrderBy,TKey>(Func,TKey>)	已重载。按根据某个键按升序对序列的元素进行排序。（由 Enumerable 定义。）
	OrderBy,TKey>(Func,TKey>,IComparer)	已重载。按使用指定的比较器按升序对序列的元素进行排序。（由 Enumerable 定义。）
	OrderByDescending,TKey>(Func,TKey>)	已重载。按根据某个键按降序对序列的元素进行排序。（由 Enumerable 定义。）
	OrderByDescending,TKey>(Func,TKey>,IComparer)	已重载。使用指定的比较器按降序对序列的元素排序。（由 Enumerable 定义。）
	Reverse>()	反转序列中元素的顺序。（由 Enumerable 定义。）
	Select,TResult>(Func,TResult>)	已重载。将序列中的每个元素投影到新表单。（由 Enumerable 定义。）
	Select,TResult>(Func,Int32,TResult>)	已重载。通过合并元素的索引投影到一个新窗体的序列的每个元素。（由 Enumerable 定义。）
	SelectMany,TResult>(Func,IEnumerable>)	已重载。一个序列的每个元素投影 IEnumerable 并将合并为一个序列将结果序列。（由 Enumerable 定义。）
	SelectMany,TResult>(Func,Int32,IEnumerable>)	已重载。一个序列的每个元素投影 IEnumerable, ，并将合并为一个序列将结果序列。 每个源元素的索引用于该元素的投影表。（由 Enumerable 定义。）
	SelectMany,TCollection,TResult>(Func,IEnumerable>,Func,TCollection,TResult>)	已重载。一个序列的每个元素投影 IEnumerable, 将平展为一个序列，将结果序列，其中调用结果选择器函数对每个元素。（由 Enumerable 定义。）
	SelectMany,TCollection,TResult>(Func,Int32,IEnumerable>,Func,TCollection,TResult>)	已重载。一个序列的每个元素投影 IEnumerable, 将平展为一个序列，将结果序列，其中调用结果选择器函数对每个元素。 每个源元素的索引用于该元素的中间投影表。（由 Enumerable 定义。）
	SequenceEqual>(IEnumerable>)	已重载。确定两个序列是否相等的元素进行比较通过使用相应类型的默认相等比较器。（由 Enumerable 定义。）
	SequenceEqual>(IEnumerable>,IEqualityComparer>)	已重载。确定两个序列是否通过使用指定的比较它们的元素相等 IEqualityComparer。（由 Enumerable 定义。）
	Single>()	已重载。返回序列的唯一元素；如果该序列并非恰好包含一个元素，则会引发异常。（由 Enumerable 定义。）
	Single>(Func,Boolean>)	已重载。返回序列中满足指定条件的唯一元素；如果有多个这样的元素存在，则会引发异常。（由 Enumerable 定义。）
	SingleOrDefault>()	已重载。返回一个序列，或默认值的唯一元素，如果序列为空，则为如果序列中存在多个元素，则此方法将引发异常。（由 Enumerable 定义。）
	SingleOrDefault>(Func,Boolean>)	已重载。返回序列中满足指定条件的唯一元素；如果这类元素不存在，则返回默认值；如果有多个元素满足该条件，此方法将引发异常。（由 Enumerable 定义。）
	Skip>(Int32)	跳过指定的数量的序列中的元素，然后返回剩余元素。（由 Enumerable 定义。）
	SkipWhile>(Func,Boolean>)	已重载。只要指定的条件为 true，然后返回剩余元素，跳过序列中的元素。（由 Enumerable 定义。）
	SkipWhile>(Func,Int32,Boolean>)	已重载。只要指定的条件为 true，然后返回剩余元素，跳过序列中的元素。 将在谓词函数的逻辑中使用元素的索引。（由 Enumerable 定义。）
	Sum>(Func,Decimal>)	已重载。计算的序列的和 Decimal 通过调用对输入序列中的每个元素的转换函数获得的值。（由 Enumerable 定义。）
	Sum>(Func,Double>)	已重载。计算的序列的和 Double 通过调用对输入序列中的每个元素的转换函数获得的值。（由 Enumerable 定义。）
	Sum>(Func,Int32>)	已重载。计算的序列的和 Int32 通过调用对输入序列中的每个元素的转换函数获得的值。（由 Enumerable 定义。）
	Sum>(Func,Int64>)	已重载。计算的序列的和 Int64 通过调用对输入序列中的每个元素的转换函数获得的值。（由 Enumerable 定义。）
	Sum>(Func,Nullable>)	已重载。计算可以为 null 的序列的和 Decimal 通过调用对输入序列中的每个元素的转换函数获得的值。（由 Enumerable 定义。）
	Sum>(Func,Nullable>)	已重载。计算可以为 null 的序列的和 Double 通过调用对输入序列中的每个元素的转换函数获得的值。（由 Enumerable 定义。）
	Sum>(Func,Nullable>)	已重载。计算可以为 null 的序列的和 Int32 通过调用对输入序列中的每个元素的转换函数获得的值。（由 Enumerable 定义。）
	Sum>(Func,Nullable>)	已重载。计算可以为 null 的序列的和 Int64 通过调用对输入序列中的每个元素的转换函数获得的值。（由 Enumerable 定义。）
	Sum>(Func,Nullable>)	已重载。计算可以为 null 的序列的和 Single 通过调用对输入序列中的每个元素的转换函数获得的值。（由 Enumerable 定义。）
	Sum>(Func,Single>)	已重载。计算的序列的和 Single 通过调用对输入序列中的每个元素的转换函数获得的值。（由 Enumerable 定义。）
	Take>(Int32)	从序列的开头返回指定的数量的连续元素。（由 Enumerable 定义。）
	TakeWhile>(Func,Boolean>)	已重载。返回序列中的元素，只要指定的条件为真。（由 Enumerable 定义。）
	TakeWhile>(Func,Int32,Boolean>)	已重载。返回序列中的元素，只要指定的条件为真。 将在谓词函数的逻辑中使用元素的索引。（由 Enumerable 定义。）
	ToArray>()	创建一个数组，从 IEnumerable。（由 Enumerable 定义。）
	ToDictionary,TKey>(Func,TKey>)	已重载。创建 Dictionary 从 IEnumerable 根据指定的键选择器函数。（由 Enumerable 定义。）
	ToDictionary,TKey>(Func,TKey>,IEqualityComparer)	已重载。创建 Dictionary 从 IEnumerable 根据指定的键选择器函数和键比较器。（由 Enumerable 定义。）
	ToDictionary,TKey,TElement>(Func,TKey>,Func,TElement>)	已重载。创建 Dictionary 从 IEnumerable 根据指定的键选择器和元素选择器函数。（由 Enumerable 定义。）
	ToDictionary,TKey,TElement>(Func,TKey>,Func,TElement>,IEqualityComparer)	已重载。创建 Dictionary 从 IEnumerable 根据指定的键选择器函数、 比较器和元素选择器函数。（由 Enumerable 定义。）
	ToList>()	创建 List 从 IEnumerable。（由 Enumerable 定义。）
	ToLookup,TKey>(Func,TKey>)	已重载。创建 Lookup 从 IEnumerable 根据指定的键选择器函数。（由 Enumerable 定义。）
	ToLookup,TKey>(Func,TKey>,IEqualityComparer)	已重载。创建 Lookup 从 IEnumerable 根据指定的键选择器函数和键比较器。（由 Enumerable 定义。）
	ToLookup,TKey,TElement>(Func,TKey>,Func,TElement>)	已重载。创建 Lookup 从 IEnumerable 根据指定的键选择器和元素选择器函数。（由 Enumerable 定义。）
	ToLookup,TKey,TElement>(Func,TKey>,Func,TElement>,IEqualityComparer)	已重载。创建 Lookup 从 IEnumerable 根据指定的键选择器函数、 比较和元素选择器函数。（由 Enumerable 定义。）
	Union>(IEnumerable>)	已重载。通过使用默认的相等比较器生成的两个序列的并集。（由 Enumerable 定义。）
	Union>(IEnumerable>,IEqualityComparer>)	已重载。使用指定的生成两个序列的并集 IEqualityComparer。（由 Enumerable 定义。）
	Where>(Func,Boolean>)	已重载。基于谓词筛选值序列。（由 Enumerable 定义。）
	Where>(Func,Int32,Boolean>)	已重载。基于谓词筛选值序列。 将在谓词函数的逻辑中使用每个元素的索引。（由 Enumerable 定义。）
	Zip,TSecond,TResult>(IEnumerable,Func,TSecond,TResult>)	适用于两个序列，生成结果的序列的相应元素指定的函数。（由 Enumerable 定义。）

备注

对于非常大 ConcurrentDictionary 对象时，您可以将最大数组大小增加到 2 千兆字节 (GB) 的 64 位系统上通过将配置元素设置为 true 在运行时环境中。

说明
ConcurrentDictionary 实现 IReadOnlyCollection 和 IReadOnlyDictionary 开头的接口 .NET Framework 4.6; 在以前版本的.NET Framework 中， ConcurrentDictionary 类未实现这些接口。

如 System.Collections.Generic.Dictionary 类， ConcurrentDictionary 实现 IDictionary 接口。 此外， ConcurrentDictionary 提供了几种方法中添加或更新键/值对在字典中下, 表中所述。

任务	使用此方法	用法说明
如果它尚不在字典中存在向字典中，添加新的密钥	TryAdd	如果当前不在字典中存在该键，此方法将添加指定的键/值对。 该方法返回 true 或 false 具体取决于是否已添加新对。
如果该注册表项具有特定值，更新为现有键在字典中值	TryUpdate	此方法检查是否密钥具有指定的值，如果它存在，则用新值更新该键。 它相当于 CompareExchange 方法，但它的用于字典的元素。
无条件地将键/值对存储在字典中，覆盖已存在的键的值	索引器的资源库︰ dictionary[key] = newValue
将键/值对添加到字典中，或如果键已存在，更新基于键的现有值的键的值	AddOrUpdate(TKey,Func,Func) - 或 - AddOrUpdate(TKey,TValue,Func)	AddOrUpdate(TKey,Func,Func) 接受的键和两个委托。 如果键在字典; 中不存在，则使用第一个委托它接受键并返回应添加的键的值。 如果该键不存在; 它使用第二个委托它接受的键和其当前值，并返回应为项设置的新值。  AddOrUpdate(TKey,TValue,Func) 接受键、 值要添加，以及更新委托。 这是与以前的重载中，相同之处在于它不使用委托来添加的键。
获取此键在字典中，向字典中添加值并将其返回如果该键不存在的值	GetOrAdd(TKey,TValue) - 或 - GetOrAdd(TKey,Func)	这些重载提供延迟初始化为键/值对在字典中，添加的值，仅当不存在。  GetOrAdd(TKey,TValue) 采用键不存在要添加的值。  GetOrAdd(TKey,Func) 将一个委托，可将生成的值，如果键不存在。

所有这些操作是原子，而且都是线程安全方面的所有其他操作 ConcurrentDictionary 类。 唯一的例外是，它是接受一个委托，委托的方法 AddOrUpdate 和 GetOrAdd。 修改和向字典中，写入操作 ConcurrentDictionary 使用细粒度锁定，以确保线程安全。 （dictionary 上的读取操作是以无锁方式执行。） 但是，外部锁以避免出现问题而引起执行下一个锁未知的代码调用这些方法的委托。 因此，这些委托执行的代码并不受到的原子性操作。

下面的示例演示如何构造 ConcurrentDictionary 对象。

class CD_Ctor
{        // Demonstrates:
        //      ConcurrentDictionary ctor(concurrencyLevel,
        // initialCapacity)
        //      ConcurrentDictionary[TKey]
        static void Main()
        {            
// We know how many items we want to insert into the ConcurrentDictionary.
// So set the initial capacity to some prime number above that, to ensure that
// the ConcurrentDictionary does not need to be resized while initializing it.
            int NUMITEMS = 64;
            int initialCapacity = 101;           
// The higher the concurrencyLevel, the higher the theoretical number of operations
// that could be performed concurrently on the ConcurrentDictionary.  However, global
// operations like resizing the dictionary take longer as the concurrencyLevel rises. 
// For the purposes of this example, we'll compromise at numCores * 2.
            int numProcs = Environment.ProcessorCount;            
            int concurrencyLevel = numProcs * 2;            
// Construct the dictionary with the desired concurrencyLevel and initialCapacity
ConcurrentDictionary cd = new ConcurrentDictionary(concurrencyLevel
, initialCapacity);            // Initialize the dictionary
            for (int i = 0; i < NUMITEMS; i++) cd[i] = i * i;

            Console.WriteLine("The square of 23 is {0} (should be {1})", 
            cd[23], 23 * 23);
        }
}

备注：转自https://msdn.microsoft.com/zh-cn/library/dd287191(v=vs.110).aspx

转载于:https://blog.51cto.com/jiaojusuimu/1880317