信息
您所需的主题如下所示。但此主题未包含在此库中。

Dictionary<TKey, TValue> 类

2013/12/13

表示键和值的集合。

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

Namespace:  System.Collections.Generic
程序集:  mscorlib(位于 mscorlib.dll 中)

public class Dictionary<TKey, TValue> : IDictionary<TKey, TValue>, 
	ICollection<KeyValuePair<TKey, TValue>>, IReadOnlyDictionary<TKey, TValue>, 
	IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, 
	IDictionary, ICollection, IEnumerable

类型参数

TKey

字典中的键的类型。

TValue

字典中的值的类型。

Dictionary<TKey, TValue> 类型公开以下成员。

  名称说明
公共方法Dictionary<TKey, TValue>()初始化 Dictionary<TKey, TValue> 类的新实例,该实例为空且具有默认的初始容量,并使用键类型的默认相等比较器。
公共方法Dictionary<TKey, TValue>(IDictionary<TKey, TValue>)初始化 Dictionary<TKey, TValue> 类的新实例,该实例包含从指定的 IDictionary<TKey, TValue> 中复制的元素并为键类型使用默认的相等比较器。
公共方法Dictionary<TKey, TValue>(IEqualityComparer<TKey>)初始化 Dictionary<TKey, TValue> 类的新实例,该实例为空且具有默认的初始容量,并使用指定的 IEqualityComparer<T>
公共方法Dictionary<TKey, TValue>(Int32)初始化 Dictionary<TKey, TValue> 类的新实例,该实例为空且具有指定的初始容量,并为键类型使用默认的相等比较器。
公共方法Dictionary<TKey, TValue>(IDictionary<TKey, TValue>, IEqualityComparer<TKey>)初始化 Dictionary<TKey, TValue> 类的新实例,该实例包含从指定的 IDictionary<TKey, TValue> 中复制的元素并使用指定的 IEqualityComparer<T>
公共方法Dictionary<TKey, TValue>(Int32, IEqualityComparer<TKey>)初始化 Dictionary<TKey, TValue> 类的新实例,该实例为空且具有指定的初始容量,并使用指定的 IEqualityComparer<T>
返回顶部

  名称说明
公共属性Comparer获取用于确定字典中的键是否相等的 IEqualityComparer<T>
公共属性Count获取包含在 Dictionary<TKey, TValue> 中的键/值对的数目。
公共属性Item获取或设置与指定的键相关联的值。
公共属性Keys获取包含 Dictionary<TKey, TValue> 中的键的集合。
公共属性Values获取包含 Dictionary<TKey, TValue> 中的值的集合。
返回顶部

  名称说明
公共方法Add将指定的键和值添加到字典中。
公共方法ClearDictionary<TKey, TValue> 中移除所有的键和值。
公共方法ContainsKey确定 Dictionary<TKey, TValue> 是否包含指定的键。
公共方法ContainsValue确定 Dictionary<TKey, TValue> 是否包含特定值。
公共方法Equals(Object)确定指定的 Object 是否等于当前的 Object (从 Object 继承。)
受保护的方法Finalize允许 Object 在垃圾回收器回收该对象之前尝试释放资源并执行其他清理操作。 (从 Object 继承。)
公共方法GetEnumerator返回循环访问 Dictionary<TKey, TValue> 的枚举数。
公共方法GetHashCode用作特定类型的哈希函数。 (从 Object 继承。)
公共方法GetType获取当前实例的 Type (从 Object 继承。)
受保护的方法MemberwiseClone创建当前 Object 的浅表副本。 (从 Object 继承。)
公共方法RemoveDictionary<TKey, TValue> 中移除具有指定键的值。
公共方法ToString返回一个字符串,它表示当前的对象。 (从 Object 继承。)
公共方法TryGetValue获取与指定的键相关联的值。
返回顶部

  名称说明
公共扩展方法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>>确定序列中的所有元素是否满足条件。 (由 Enumerable 定义。)
公共扩展方法Any<KeyValuePair<TKey, TValue>>()重载。 确定序列是否包含任何元素。 (由 Enumerable 定义。)
公共扩展方法Any<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Boolean>)重载。 确定序列中的任何元素是否都满足条件。 (由 Enumerable 定义。)
公共扩展方法AsEnumerable<KeyValuePair<TKey, TValue>>返回类型化为 IEnumerable<T> 的输入。 (由 Enumerable 定义。)
公共扩展方法AsQueryable()重载。 IEnumerable 转换为 IQueryable (由 Queryable 定义。)
公共扩展方法AsQueryable<KeyValuePair<TKey, TValue>>()重载。 将泛型 IEnumerable<T> 转换为泛型 IQueryable<T> (由 Queryable 定义。)
公共扩展方法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>, 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<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>>连接两个序列。 (由 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>>返回序列中指定索引处的元素。 (由 Enumerable 定义。)
公共扩展方法ElementAtOrDefault<KeyValuePair<TKey, TValue>>返回序列中指定索引处的元素;如果索引超出范围,则返回默认值。 (由 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, TResult>(Func<KeyValuePair<TKey, TValue>, TKey>, Func<TKey, IEnumerable<KeyValuePair<TKey, TValue>>, TResult>)重载。 根据指定的键选择器函数对序列中的元素进行分组,并且从每个组及其键中创建结果值。 (由 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>, 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>, Nullable<Decimal>>)重载。 调用序列的每个元素上的转换函数并返回可空 Decimal 的最大值。 (由 Enumerable 定义。)
公共扩展方法Max<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Nullable<Double>>)重载。 调用序列的每个元素上的转换函数并返回可空 Double 的最大值。 (由 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<Int32>>)重载。 调用序列的每个元素上的转换函数并返回可空 Int32 的最大值。 (由 Enumerable 定义。)
公共扩展方法Max<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Nullable<Int64>>)重载。 调用序列的每个元素上的转换函数并返回可空 Int64 的最大值。 (由 Enumerable 定义。)
公共扩展方法Max<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Nullable<Single>>)重载。 调用序列的每个元素上的转换函数并返回可空 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>, Nullable<Decimal>>)重载。 调用序列的每个元素上的转换函数并返回可空 Decimal 的最小值。 (由 Enumerable 定义。)
公共扩展方法Min<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Nullable<Double>>)重载。 调用序列的每个元素上的转换函数并返回可空 Double 的最小值。 (由 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<Int32>>)重载。 调用序列的每个元素上的转换函数并返回可空 Int32 的最小值。 (由 Enumerable 定义。)
公共扩展方法Min<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Nullable<Int64>>)重载。 调用序列的每个元素上的转换函数并返回可空 Int64 的最小值。 (由 Enumerable 定义。)
公共扩展方法Min<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Nullable<Single>>)重载。 调用序列的每个元素上的转换函数并返回可空 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>>跳过序列中指定数量的元素,然后返回剩余的元素。 (由 Enumerable 定义。)
公共扩展方法SkipWhile<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Boolean>)重载。 只要满足指定的条件,就跳过序列中的元素,然后返回剩余元素。 (由 Enumerable 定义。)
公共扩展方法SkipWhile<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Int32, Boolean>)重载。 只要满足指定的条件,就跳过序列中的元素,然后返回剩余元素。 将在谓词函数的逻辑中使用元素的索引。 (由 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>, 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<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>>从序列的开头返回指定数量的连续元素。 (由 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>)重载。 根据指定的键选择器函数,从 IEnumerable<T> 创建一个 Dictionary<TKey, TValue> (由 Enumerable 定义。)
公共扩展方法ToDictionary<KeyValuePair<TKey, TValue>, TKey>(Func<KeyValuePair<TKey, TValue>, TKey>, IEqualityComparer<TKey>)重载。 根据指定的键选择器函数和键比较器,从 IEnumerable<T> 创建一个 Dictionary<TKey, TValue> (由 Enumerable 定义。)
公共扩展方法ToDictionary<KeyValuePair<TKey, TValue>, TKey, TElement>(Func<KeyValuePair<TKey, TValue>, TKey>, Func<KeyValuePair<TKey, TValue>, TElement>)重载。 根据指定的键选择器和元素选择器函数,从 IEnumerable<T> 创建一个 Dictionary<TKey, TValue> (由 Enumerable 定义。)
公共扩展方法ToDictionary<KeyValuePair<TKey, TValue>, TKey, TElement>(Func<KeyValuePair<TKey, TValue>, TKey>, Func<KeyValuePair<TKey, TValue>, TElement>, IEqualityComparer<TKey>)重载。 根据指定的键选择器函数、比较器和元素选择器函数从 IEnumerable<T> 创建一个 Dictionary<TKey, TValue> (由 Enumerable 定义。)
公共扩展方法ToList<KeyValuePair<TKey, TValue>>IEnumerable<T> 创建一个 List<T> (由 Enumerable 定义。)
公共扩展方法ToLookup<KeyValuePair<TKey, TValue>, TKey>(Func<KeyValuePair<TKey, TValue>, TKey>)重载。 根据指定的键选择器函数,从 IEnumerable<T> 创建一个 Lookup<TKey, TElement> (由 Enumerable 定义。)
公共扩展方法ToLookup<KeyValuePair<TKey, TValue>, TKey>(Func<KeyValuePair<TKey, TValue>, TKey>, IEqualityComparer<TKey>)重载。 根据指定的键选择器函数和键比较器,从 IEnumerable<T> 创建一个 Lookup<TKey, TElement> (由 Enumerable 定义。)
公共扩展方法ToLookup<KeyValuePair<TKey, TValue>, TKey, TElement>(Func<KeyValuePair<TKey, TValue>, TKey>, Func<KeyValuePair<TKey, TValue>, TElement>)重载。 根据指定的键选择器和元素选择器函数,从 IEnumerable<T> 创建一个 Lookup<TKey, TElement> (由 Enumerable 定义。)
公共扩展方法ToLookup<KeyValuePair<TKey, TValue>, TKey, TElement>(Func<KeyValuePair<TKey, TValue>, TKey>, Func<KeyValuePair<TKey, TValue>, TElement>, IEqualityComparer<TKey>)重载。 根据指定的键选择器函数、比较器和元素选择器函数,从 IEnumerable<T> 创建一个 Lookup<TKey, TElement> (由 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>通过使用指定的谓词函数合并两个序列。 (由 Enumerable 定义。)
返回顶部

  名称说明
显式接口实现私有方法ICollection<KeyValuePair<TKey, TValue>>.Add将指定值添加到具有指定键的 ICollection<T> 中。
显式接口实现私有方法ICollection<KeyValuePair<TKey, TValue>>.Contains确定 ICollection<T> 是否包含特定的键和值。
显式接口实现私有方法ICollection<KeyValuePair<TKey, TValue>>.CopyTo从指定的数组索引开始,将 ICollection<T> 的元素复制到类型 KeyValuePair<TKey, TValue> 的数组中。
显式接口实现私有方法ICollection.CopyTo从指定的数组索引开始,将 ICollection<T> 中的元素复制到一个数组中。
显式接口实现私有属性ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly获取一个值,该值指示字典是否为只读。
显式接口实现私有属性ICollection.IsSynchronized获取一个值,该值指示是否同步对 ICollection 的访问(线程安全)。
显式接口实现私有方法ICollection<KeyValuePair<TKey, TValue>>.Remove从字典中移除键和值。
显式接口实现私有属性ICollection.SyncRoot获取可用于同步对 ICollection 的访问的对象。
显式接口实现私有方法IDictionary.Add将指定的键和值添加到字典中。
显式接口实现私有方法IDictionary.Contains确定 IDictionary 是否包含具有指定键的元素。
显式接口实现私有方法IDictionary.GetEnumerator返回 IDictionaryIDictionaryEnumerator
显式接口实现私有属性IDictionary.IsFixedSize获取一个值,该值指示 IDictionary 是否具有固定大小。
显式接口实现私有属性IDictionary.IsReadOnly获取一个值,该值指示 IDictionary 是否为只读。
显式接口实现私有属性IDictionary.Item获取或设置具有指定键的值。
显式接口实现私有属性IDictionary<TKey, TValue>.Keys获取包含 IDictionary<TKey, TValue> 的键的 ICollection<T>
显式接口实现私有属性IDictionary.Keys获取包含 IDictionary 的键的 ICollection
显式接口实现私有方法IDictionary.RemoveIDictionary 中移除具有指定键的元素。
显式接口实现私有属性IDictionary<TKey, TValue>.Values获取包含 IDictionary<TKey, TValue> 中的值的 ICollection<T>
显式接口实现私有属性IDictionary.Values获取包含 IDictionary 中的值的 ICollection
显式接口实现私有方法IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator返回一个循环访问集合的枚举数。
显式接口实现私有方法IEnumerable.GetEnumerator返回一个循环访问集合的枚举数。
显式接口实现私有属性IReadOnlyDictionary<TKey, TValue>.Keys获取包含 IReadOnlyDictionary<TKey, TValue> 中的键的集合。
显式接口实现私有属性IReadOnlyDictionary<TKey, TValue>.Values获取包含 IReadOnlyDictionary<TKey, TValue> 中的值的集合。
返回顶部

Dictionary<TKey, TValue> 泛型类提供了从一组键到一组值的映射。字典中的每个添加项都由一个值及其相关联的键组成。通过键来检索值的速度是非常快的,接近于 O(1),这是因为 Dictionary<TKey, TValue> 类是作为一个哈希表来实现的。

说明注意:

检索速度取决于为 TKey 指定的类型的哈希算法的质量。

只要对象用作 Dictionary<TKey, TValue> 中的键,它就不能以任何影响其哈希值的方式更改。使用字典的相等比较器比较时,Dictionary<TKey, TValue> 中的任何键都必须是唯一的。键不能为 null,但是如果值类型 TValue 为引用类型,则值可以为 null。

Dictionary<TKey, TValue> 需要一个相等实现来确定键是否相等。可以使用一个接受 comparer 参数的构造函数来指定 IEqualityComparer<T> 泛型接口的实现;如果不指定实现,则使用默认的泛型相等比较器 EqualityComparer<T>.Default。如果类型 TKey 实现 System.IEquatable<T> 泛型接口,则默认相等比较器会使用该实现。

说明注意:

例如,您可以使用 StringComparer 类提供的不区分大小写的字符串比较器来创建带不区分大小写的字符串键的字典。

Dictionary<TKey, TValue> 的容量是 Dictionary<TKey, TValue> 可以保存的元素数。向 Dictionary<TKey, TValue> 添加元素时,将通过重新分配内部数组,根据需要自动增大容量。

对于枚举而言,字典中的每一项都被视为一个表示值及其键的 KeyValuePair<TKey, TValue> 结构进行处理。项返回的顺序未定义。

C# 语言中的 oreach 语句(在 C++ 中为 for each,在 Visual Basic 中为 For Each)需要集合中每个元素的类型。由于 Dictionary<TKey, TValue> 是键和值的集合,因此元素类型并非键类型或值类型。相反,元素类型是键类型和值类型的 KeyValuePair<TKey, TValue>。例如:

foreach (KeyValuePair<int, string> kvp in myDictionary) {...}

foreach 语句是对枚举数的包装,只允许该枚举数读取集合,而不允许写入集合。

说明注意:

由于键可以被继承而且它们的行为已更改,因此使用 Equals 方法进行的比较并不能保证其绝对唯一性。

版本说明

Windows Phone

当从 Dictionary 参数为枚举的 TKey 派生类时将引发异常。

此类有两个示例。第一个示例使用 Dictionary<TKey, TValue> 对象包含演出"Othello"的演员表成员信息。剧中角色的名称是字典中的键,演员的名称是字典的值。此字典 (OthelloDict) 包含在类 (OthelloCast) 中,该类是从 List<T> 类派生的。OthelloCast 对象的构造函数使用 OthelloDict 字典的键填充其列表。OthelloCast 对象绑定到 ListBox 控件。此示例中的绑定是单向的;有关其他绑定选项和方案的讨论,请参见Windows Phone 的数据绑定

下面的代码演示 OthelloCast 类。将此类添加到项目的 Page 分部类。


// Make sure this class is
// within the C# namespace.
public class OthelloCast : List<string>
{
    // Use a dictionary to contain
    // cast names (key) and actor names (value).
    public Dictionary<string, string> OthelloDict =
        new Dictionary<string, string>();

    public OthelloCast()
    {
        // Add data to the dictionary.
        OthelloDict.Add("Bianca", "Gretchen Rivas");
        OthelloDict.Add("Brabantio", "Carlos Lacerda");
        OthelloDict.Add("Cassio", "Steve Masters");
        OthelloDict.Add("Clown", "Michael Ludwig");
        OthelloDict.Add("Desdemona", "Catherine Autier Miconi");
        OthelloDict.Add("Duke of Venice", "Ken Circeo");
        OthelloDict.Add("Emilia", "Eva Valverde");
        OthelloDict.Add("Gratiano", "Akos Kozari");
        OthelloDict.Add("Iago", "Darius Stasevicius");
        OthelloDict.Add("Lodovico", "Fernando Souza");
        OthelloDict.Add("Montano", "Jeff Hay");
        OthelloDict.Add("Othello", "Marco Tanara");
        OthelloDict.Add("Roderigo", "Pedro Ruivo");

        // Populate the list with character names.
        foreach (KeyValuePair<string, string> kvp in OthelloDict)
        {
            this.Add(kvp.Key);
        }
    }
}


当您在 ListBox 控件中选择某个剧中角色时,扮演该角色的演员显示在 TextBlock 控件中。下面的代码演示了 SelectionChanged 控件的 ListBox 事件的事件处理程序如何执行此操作。将此处理程序添加到 Page 分部类。有关如何编译和运行此示例代码的信息,请参见生成具有静态 Windows Phone TextBlock 控件的示例


private void ListCharacters_SelectionChanged(object sender,
    SelectionChangedEventArgs e)
{
    // Create an instance of OthelloCast to
    // look up an actor by their character.
    OthelloCast othello = new OthelloCast();

    // Get the selected character name (key).
    string key = ListCharacters.SelectedItem.ToString();

    // Get the key's value (actor name) and display it.
    ShowActor.Text = othello.OthelloDict[key].ToString();
}


下面的 XAML 引用和元素执行数据绑定:

  • xmlns:my="clr-namespace:CastMembers"

    这是对t公共语言运行时 (CLR) 命名空间的引用,它在程序集中自动声明,并公开其公共类型。使用程序集的名称(项目名称)替换 CsatMembers

  • <my:OthelloCast x:Name="Characters"/>

    这是在 <Grid.Resources> 元素中指定的资源字典引用。它指定要绑定到的对象 (OthelloCast),其名称 (Characters) 由使用此资源的控件指定,例如 ListBox 控件。

  • <ListBox Margin ="5,5,5,5" SelectionChanged="ListCharacters_SelectionChanged" Grid.Row="1" Grid.Column="0" x:Name="ListCharacters" ItemsSource="{Binding Source={StaticResource Characters}}"/>

    此元素定义一个 ListBox 控件,其 ItemsSource 属性设置为绑定对象。请注意,它包括为 SelectionChanged 事件定义的事件处理程序。

完成的 XAML 如下所示。有关如何编译和运行此示例代码的信息,请参见生成具有静态 Windows Phone TextBlock 控件的示例


 <UserControl x:Class="CastMembers.Page"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:my="clr-namespace:CastMembers"
    Width="400" Height="400">
    <Grid x:Name="LayoutRoot" Background="White" ShowGridLines="False">
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width="Auto"/>
            <ColumnDefinition Width="Auto"/>
        </Grid.ColumnDefinitions>
        <Grid.RowDefinitions>
            <RowDefinition Height="Auto"/>
            <RowDefinition Height="Auto"/>
        </Grid.RowDefinitions>
        <Grid.Resources>
            <my:OthelloCast x:Name="Characters"/>
        </Grid.Resources>
        <TextBlock Margin ="5,5,5,5" Grid.Row="0" Grid.Column="0" Text="Othello Cast:" FontWeight="Bold" />
        <ListBox Margin ="5,5,5,5" SelectionChanged="ListCharacters_SelectionChanged" Grid.Row="1" Grid.Column="0" x:Name="ListCharacters"  ItemsSource="{Binding Source={StaticResource Characters}}"/>
        <TextBlock Margin ="5,5,5,5" Grid.Row="0" Grid.Column="1" Text="Actor:" FontWeight="Bold" />
        <TextBlock Margin ="5,5,5,5" Grid.Row="1" Grid.Column="1" x:Name="ShowActor" Text=""/> 
    </Grid>
</UserControl>


下一个示例使用字符串键创建一个空的字符串 Dictionary<TKey, TValue>,并使用 Add 方法添加一些元素。该示例演示,在尝试添加重复键时,Add 方法会引发 ArgumentException

该示例使用 Item 属性(在 C# 中为索引器)检索值,演示了在请求的键不存在时会引发 KeyNotFoundException,还演示了与键关联的值可以被替换。

该示例演示,如果程序必须经常尝试词典中不存在的键值,如何使用 TryGetValue 方法作为更有效的检索值的方法,该示例还演示在调用 Add 方法之前如何使用 ContainsKey 方法来测试键是否存在。

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

最后,此示例演示了 Remove 方法。

说明注意:

要运行此示例,请参见生成具有静态 Windows Phone TextBlock 控件的示例


using System;
using System.Collections.Generic;

public class Example
{
   public static void Demo(System.Windows.Controls.TextBlock outputBlock)
   {
      // Create a new dictionary of strings, with string keys.
      //
      Dictionary<string, string> openWith =
          new Dictionary<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)
      {
         outputBlock.Text += "An element with Key = \"txt\" already exists." + "\n";
      }

      // The Item property is another name for the indexer, so you 
      // can omit its name when accessing elements. 
      outputBlock.Text += String.Format("For key = \"rtf\", value = {0}.",
          openWith["rtf"]) + "\n";

      // The indexer can be used to change the value associated
      // with a key.
      openWith["rtf"] = "winword.exe";
      outputBlock.Text += String.Format("For key = \"rtf\", value = {0}.",
          openWith["rtf"]) + "\n";

      // 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
      {
         outputBlock.Text += String.Format("For key = \"tif\", value = {0}.",
             openWith["tif"]) + "\n";
      }
      catch (KeyNotFoundException)
      {
         outputBlock.Text += "Key = \"tif\" is not found." + "\n";
      }

      // 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))
      {
         outputBlock.Text += String.Format("For key = \"tif\", value = {0}.", value) + "\n";
      }
      else
      {
         outputBlock.Text += "Key = \"tif\" is not found." + "\n";
      }

      // ContainsKey can be used to test keys before inserting 
      // them.
      if (!openWith.ContainsKey("ht"))
      {
         openWith.Add("ht", "hypertrm.exe");
         outputBlock.Text += String.Format("Value added for key = \"ht\": {0}",
             openWith["ht"]) + "\n";
      }

      // When you use foreach to enumerate dictionary elements,
      // the elements are retrieved as KeyValuePair objects.
      outputBlock.Text += "\n";
      foreach (KeyValuePair<string, string> kvp in openWith)
      {
         outputBlock.Text += String.Format("Key = {0}, Value = {1}",
             kvp.Key, kvp.Value) + "\n";
      }

      // To get the values alone, use the Values property.
      Dictionary<string, string>.ValueCollection valueColl =
          openWith.Values;

      // The elements of the ValueCollection are strongly typed
      // with the type that was specified for dictionary values.
      outputBlock.Text += "\n";
      foreach (string s in valueColl)
      {
         outputBlock.Text += String.Format("Value = {0}", s) + "\n";
      }

      // To get the keys alone, use the Keys property.
      Dictionary<string, string>.KeyCollection keyColl =
          openWith.Keys;

      // The elements of the KeyCollection are strongly typed
      // with the type that was specified for dictionary keys.
      outputBlock.Text += "\n";
      foreach (string s in keyColl)
      {
         outputBlock.Text += String.Format("Key = {0}", s) + "\n";
      }

      // Use the Remove method to remove a key/value pair.
      outputBlock.Text += "\nRemove(\"doc\")" + "\n";
      openWith.Remove("doc");

      if (!openWith.ContainsKey("doc"))
      {
         outputBlock.Text += "Key \"doc\" is not found." + "\n";
      }
   }
}

/* 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 = txt, Value = notepad.exe
Key = bmp, Value = paint.exe
Key = dib, Value = paint.exe
Key = rtf, Value = winword.exe
Key = doc, Value = winword.exe
Key = ht, Value = hypertrm.exe

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

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

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


Windows Phone OS

受以下版本支持: 8.0, 7.1, 7.0

Windows Phone

此类型的所有公共静态(在 Visual Basic 中为 Shared)成员都是线程安全的。但不保证所有实例成员都是线程安全的。

只要不修改该集合,Dictionary<TKey, TValue> 就可以同时支持多个阅读器。即便如此,从头到尾对一个集合进行枚举本质上并不是一个线程安全的过程。当出现枚举与写访问互相争用这种极少发生的情况时,必须在整个枚举过程中锁定集合。若允许多个线程对集合执行读写操作,您必须实现自己的同步。

显示: