C#学习常用类--SortedDictionary<TKey,TValue>类

精选转载

郊居岁暮 2016-12-21 14:09:41 博主文章分类：.Net属性

文章标签 SortedDictionay 文章分类 .Net 后端开发

SortedDictionary<TKey,TValue>类

表示根据键进行排序的键/值对的集合。

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

继承层次结构

System.Object
System.Collections.Generic.SortedDictionary<TKey,TValue>

语法：

[SerializableAttribute]
public class SortedDictionary<TKey, TValue> : IDictionary<TKey,TValue>, 
ICollection<KeyValuePair<TKey,TValue>>, IEnumerable<KeyValuePair<TKey,TValue>>, 
IEnumerable, IDictionary, ICollection, IReadOnlyDictionary<TKey,TValue>, 
IReadOnlyCollection<KeyValuePair<TKey,TValue>>

类型参数

TKey
字典中的键的类型。

TValue
字典中的值的类型。

构造函数

	名称	说明
	SortedDictionary<TKey,TValue>()	初始化 SortedDictionary<TKey,TValue> 类的一个新实例，该实例为空并对键类型使用默认 IComparer<T> 实现。
	SortedDictionary<TKey,TValue>(IComparer<TKey>)	初始化 SortedDictionary<TKey,TValue> 类的一个新实例，该实例为空并对比较键使用指定 IComparer<T> 实现。
	SortedDictionary<TKey,TValue>(IDictionary<TKey,TValue>)	初始化 SortedDictionary<TKey,TValue> 类的新实例，该实例包含从指定的 IDictionary<TKey,TValue> 中复制的元素，并使用键类型的默认 IComparer<T> 实现。
	SortedDictionary<TKey,TValue>(IDictionary<TKey,TValue>,IComparer<TKey>)	初始化 SortedDictionary<TKey,TValue> 类的新实例，该实例包含从指定的 IDictionary<TKey,TValue> 中复制的元素，并使用指定的 IComparer<T> 实现来比较键。

属性

	名称	说明
	Comparer	获取用于对 IComparer<T> 的元素进行排序的 SortedDictionary<TKey,TValue>。
	Count	获取包含在 SortedDictionary<TKey,TValue> 中的键/值对的数目。
	Item[TKey]	获取或设置与指定的键关联的值。
	Keys	获得一个包含 SortedDictionary<TKey,TValue> 中的键的集合。
	Values	获得一个包含 SortedDictionary<TKey,TValue> 中的值的集合。

方法

	名称	说明
	Add(TKey,TValue)	将带有指定键和值的元素添加到 SortedDictionary<TKey,TValue> 中。
	Clear()	从 SortedDictionary<TKey,TValue> 中移除所有元素。
	ContainsKey(TKey)	确定是否 SortedDictionary<TKey,TValue> 包含带有指定键的元素。
	ContainsValue(TValue)	确定 SortedDictionary<TKey,TValue> 是否包含具有指定值的元素。
	CopyTo(KeyValuePair<TKey,TValue>[],Int32)	从指定的索引处开始，将 SortedDictionary<TKey,TValue> 的元素复制到指定的 KeyValuePair<TKey,TValue> 结构的数组中。
	Equals(Object)	确定指定的对象是否等于当前对象。（继承自 Object。）
	Finalize()	在垃圾回收将某一对象回收前允许该对象尝试释放资源并执行其他清理操作。（继承自 Object。）
	GetEnumerator()	返回循环访问 SortedDictionary<TKey,TValue> 的枚举数。
	GetHashCode()	作为默认哈希函数。（继承自 Object。）
	GetType()	获取当前实例的 Type。（继承自 Object。）
	MemberwiseClone()	创建当前 Object 的浅表副本。（继承自 Object。）
	Remove(TKey)	从 SortedDictionary<TKey,TValue> 中移除带有指定键的元素。
	ToString()	返回表示当前对象的字符串。（继承自 Object。）
	TryGetValue(TKey,TValue)	获取与指定键关联的值。

显式接口实现

	名称	说明
	ICollection<KeyValuePair<TKey,TValue>>.Add(KeyValuePair<TKey,TValue>)	将某项添加到 ICollection<T> 中。
	ICollection<KeyValuePair<TKey,TValue>>.Contains(KeyValuePair<TKey,TValue>)	确定是否 ICollection<T> 包含一个指定键和值。
	ICollection<KeyValuePair<TKey,TValue>>.Remove(KeyValuePair<TKey,TValue>)	从 ICollection<T> 中移除指定元素的第一个匹配项。
	IEnumerable<KeyValuePair<TKey,TValue>>.GetEnumerator()	返回循环访问集合的枚举数。
	ICollection.CopyTo(Array,Int32)	从特定的数组索引处开始，将 ICollection<T> 的元素复制到一个数组中。
	IDictionary.Add(Object,Object)	向 IDictionary 添加一个带有所提供的键和值的元素。
	IDictionary.Contains(Object)	确定是否 IDictionary 包含带有指定键的元素。
	IDictionary.GetEnumerator()	返回 IDictionaryEnumerator 的 IDictionary。
	IDictionary.Remove(Object)	从 IDictionary 中移除带有指定键的元素。
	IEnumerable.GetEnumerator()	返回一个循环访问集合的枚举器。
	ICollection<KeyValuePair<TKey,TValue>>.IsReadOnly	获取一个值，该值指示 ICollection<T> 是否为只读。
	IDictionary<TKey,TValue>.Keys	获取包含 ICollection<T> 的键的 IDictionary<TKey,TValue>。
	IDictionary<TKey,TValue>.Values	获取一个 ICollection<T>，它包含 IDictionary<TKey,TValue> 中的值。
	IReadOnlyDictionary<TKey,TValue>.Keys	获取包含在 SortedDictionary<TKey,TValue> 中的键的集合
	IReadOnlyDictionary<TKey,TValue>.Values	获取包含在 SortedDictionary<TKey,TValue> 中的值的集合
	ICollection.IsSynchronized	获取一个值，该值指示是否同步对 ICollection 的访问（线程安全）。
	ICollection.SyncRoot	获取可用于同步对 ICollection 的访问的对象。
	IDictionary.IsFixedSize	获取一个值，该值指示 IDictionary 是否具有固定大小。
	IDictionary.IsReadOnly	获取一个值，该值指示 IDictionary 是否为只读。
	IDictionary.Item[Object]	获取或设置具有指定键的元素。
	IDictionary.Keys	获取包含 ICollection 的键的 IDictionary。
	IDictionary.Values	获取一个 ICollection，它包含 IDictionary 中的值。

扩展方法

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

备注

SortedDictionary<TKey,TValue> 泛型类是与 O(log n) 检索二进制搜索树其中 n 是在字典中的元素数目。在这一方面，它是类似于 SortedList<TKey,TValue> 泛型类。这两个类具有相似的对象模型，并且都具有 O(log n) 检索。两个类的不同之处是在内存使用，并且插入和删除的速度︰

SortedList<TKey,TValue> 使用较少的内存比 SortedDictionary<TKey,TValue>。
SortedDictionary<TKey,TValue> 更快的插入和移除操作的未排序的数据︰ O(log n) 而不是 O (n) 为 SortedList<TKey,TValue>。
如果从已排序的数据，同时填充的列表 SortedList<TKey,TValue> 快于 SortedDictionary<TKey,TValue>。

每个键/值对都可以作为 KeyValuePair<TKey,TValue> 结构，或指定为 DictionaryEntry 通过非泛型 IDictionary 接口。

密钥必须是固定不变，前提是它们被用作中的键进行 SortedDictionary<TKey,TValue>。中的所有键 SortedDictionary<TKey,TValue> 必须是唯一的。键不能为 null, ，但值则可以为，如果值类型 TValue 是引用类型。

SortedDictionary<TKey,TValue> 需要一个比较器实现，以执行关键的比较。您可以指定的一个实现 IComparer<T> 泛型接口的使用构造函数接受 comparer 参数; 如果未指定的实现，默认 genericcomparer Comparer<T>.Default 使用。如果类型 TKey 实现 System.IComparable<T> 泛型接口，则默认比较器使用该实现。

foreach C# 语言的语句 (for each c + + 中 For Each 在 Visual Basic 中) 返回集合中的元素的类型的对象。由于每个元素的 SortedDictionary<TKey,TValue> 是一个键/值对，元素类型不是键的类型或值的类型。相反，元素类型是 KeyValuePair<TKey,TValue>。下面的代码演示 C#、 c + + 和 Visual Basic 语法。

foreach( KeyValuePair<string, string> kvp in myDictionary )
{
    Console.WriteLine("Key = {0}, Value = {1}", kvp.Key, kvp.Value);
}

foreach 语句是枚举器，它允许仅从集合读取，不向其写入周围的包装。

示例

下面的代码示例创建一个空 SortedDictionary<TKey,TValue> 具有字符串键和使用的字符串 Add 方法来添加一些元素。该示例演示 Add 方法抛出异常 ArgumentException 时尝试添加重复的键。

该示例使用 Item 属性（在 C# 中为索引器）来检索值，演示 KeyNotFoundException 请求的键不存在，并且可以替换与某个键相关联的值时引发。

该示例演示如何使用 TryGetValue 方法作为更高效的方法来检索值，如果某个程序必须经常尝试在字典中，不，演示如何使用 ContainsKey 方法来测试某个键是否存在，然后再调 Add 方法。

该示例演示如何枚举的键和值字典中的以及如何枚举键和值单独使用 Keys 属性和 Values 属性。

最后，该示例演示 Remove 方法。

using System;using System.Collections.Generic;public class Example
{    public static void Main()
    {       
     // Create a new sorted dictionary of strings, with string
        // keys.
        SortedDictionary<string, string> openWith = 
            new SortedDictionary<string, string>();        
        // Add some elements to the dictionary. There are no 
        // duplicate keys, but some of the values are duplicates.
        openWith.Add("txt", "notepad.exe");
        openWith.Add("bmp", "paint.exe");
        openWith.Add("dib", "paint.exe");
        openWith.Add("rtf", "wordpad.exe");        
        // The Add method throws an exception if the new key is 
        // already in the dictionary.
        try
        {
            openWith.Add("txt", "winword.exe");
        }        
        catch (ArgumentException)
        {
            Console.WriteLine("An element with Key = \"txt\" already exists.");
        }        
        // The Item property is another name for the indexer, so you 
        // can omit its name when accessing elements. 
        Console.WriteLine("For key = \"rtf\", value = {0}.", 
            openWith["rtf"]);        
        // The indexer can be used to change the value associated
        // with a key.
        openWith["rtf"] = "winword.exe";
        Console.WriteLine("For key = \"rtf\", value = {0}.", 
            openWith["rtf"]);        
        // If a key does not exist, setting the indexer for that key
        // adds a new key/value pair.
        openWith["doc"] = "winword.exe";        
        // The indexer throws an exception if the requested key is
        // not in the dictionary.
        try
        {
            Console.WriteLine("For key = \"tif\", value = {0}.", 
                openWith["tif"]);
        }        
        catch (KeyNotFoundException)
        {
            Console.WriteLine("Key = \"tif\" is not found.");
        }        
        // When a program often has to try keys that turn out not to
        // be in the dictionary, TryGetValue can be a more efficient 
        // way to retrieve values.
        string value = "";        
        if (openWith.TryGetValue("tif", out value))
        {
            Console.WriteLine("For key = \"tif\", value = {0}.", value);
        }        
        else
        {
            Console.WriteLine("Key = \"tif\" is not found.");
        }        
        // ContainsKey can be used to test keys before inserting 
        // them.
        if (!openWith.ContainsKey("ht"))
        {
            openWith.Add("ht", "hypertrm.exe");
            Console.WriteLine("Value added for key = \"ht\": {0}", 
                openWith["ht"]);
        }        
        // When you use foreach to enumerate dictionary elements,
        // the elements are retrieved as KeyValuePair objects.
        Console.WriteLine();        
        foreach( KeyValuePair<string, string> kvp in openWith )
        {
            Console.WriteLine("Key = {0}, Value = {1}", 
                kvp.Key, kvp.Value);
        }        
        // To get the values alone, use the Values property.
        SortedDictionary<string, string>.ValueCollection valueColl = 
            openWith.Values;        
        // The elements of the ValueCollection are strongly typed
        // with the type that was specified for dictionary values.
        Console.WriteLine();        
        foreach( string s in valueColl )
        {
            Console.WriteLine("Value = {0}", s);
        }       
         // To get the keys alone, use the Keys property.
        SortedDictionary<string, string>.KeyCollection keyColl = 
            openWith.Keys;        
        // The elements of the KeyCollection are strongly typed
        // with the type that was specified for dictionary keys.
        Console.WriteLine();        
        foreach( string s in keyColl )
        {
            Console.WriteLine("Key = {0}", s);
        }        
        // Use the Remove method to remove a key/value pair.
        Console.WriteLine("\nRemove(\"doc\")");
        openWith.Remove("doc");       
         if (!openWith.ContainsKey("doc"))
        {
            Console.WriteLine("Key \"doc\" is not found.");
        }
    }
}
/* This code example produces the following output:

An element with Key = "txt" already exists.
For key = "rtf", value = wordpad.exe.
For key = "rtf", value = winword.exe.
Key = "tif" is not found.
Key = "tif" is not found.
Value added for key = "ht": hypertrm.exe

Key = bmp, Value = paint.exe
Key = dib, Value = paint.exe
Key = doc, Value = winword.exe
Key = ht, Value = hypertrm.exe
Key = rtf, Value = winword.exe
Key = txt, Value = notepad.exe

Value = paint.exe
Value = paint.exe
Value = winword.exe
Value = hypertrm.exe
Value = winword.exe
Value = notepad.exe

Key = bmp
Key = dib
Key = doc
Key = ht
Key = rtf
Key = txt

Remove("doc")
Key "doc" is not found.
 */

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