本文由机器翻译。若要查看英语原文,请勾选“英语”复选框。 也可将鼠标指针移到文本上,在弹出窗口中显示英语原文。
翻译
英语

Dictionary<TKey, TValue>

 

表示键和值的集合。

若要浏览此类型的 .NET Framework 源代码,请参阅引用源

命名空间:   System.Collections.Generic
程序集:  mscorlib(位于 mscorlib.dll)

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

[SerializableAttribute]
[ComVisibleAttribute(false)]
public class Dictionary<TKey, TValue> : IDictionary<TKey, TValue>, 
	ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, 
	IEnumerable, IDictionary, ICollection, IReadOnlyDictionary<TKey, TValue>, 
	IReadOnlyCollection<KeyValuePair<TKey, TValue>>, ISerializable, 
	IDeserializationCallback

类型参数

TKey

字典中的键的类型。

TValue

字典中的值的类型。

名称说明
System_CAPS_pubmethodDictionary<TKey, TValue>()

初始化 Dictionary<TKey, TValue> 类的新实例,该实例为空,具有默认的初始容量并为键类型使用默认的相等比较器。

System_CAPS_pubmethodDictionary<TKey, TValue>(IDictionary<TKey, TValue>)

初始化 Dictionary<TKey, TValue> 类的新实例,该实例包含从指定的 IDictionary<TKey, TValue> 复制的元素并为键类型使用默认的相等比较器。

System_CAPS_pubmethodDictionary<TKey, TValue>(IDictionary<TKey, TValue>, IEqualityComparer<TKey>)

初始化 Dictionary<TKey, TValue> 类的新实例,该实例包含从指定的 IDictionary<TKey, TValue> 中复制的元素并使用指定的 IEqualityComparer<T>

System_CAPS_pubmethodDictionary<TKey, TValue>(IEqualityComparer<TKey>)

初始化 Dictionary<TKey, TValue> 类的新实例,该实例为空,具有默认的初始容量并使用指定的 IEqualityComparer<T>

System_CAPS_pubmethodDictionary<TKey, TValue>(Int32)

初始化 Dictionary<TKey, TValue> 类的新实例,该实例为空,具有指定的初始容量并为键类型使用默认的相等比较器。

System_CAPS_pubmethodDictionary<TKey, TValue>(Int32, IEqualityComparer<TKey>)

初始化 Dictionary<TKey, TValue> 类的新实例,该实例为空,具有指定的初始容量并使用指定的 IEqualityComparer<T>

System_CAPS_protmethodDictionary<TKey, TValue>(SerializationInfo, StreamingContext)

用序列化数据初始化 Dictionary<TKey, TValue> 类的新实例。

名称说明
System_CAPS_pubpropertyComparer

获取用于确定字典中的键是否相等的 IEqualityComparer<T>

System_CAPS_pubpropertyCount

获取包含在 Dictionary<TKey, TValue> 中的键/值对的数目。

System_CAPS_pubpropertyItem[TKey]

获取或设置与指定的键关联的值。

System_CAPS_pubpropertyKeys

获得一个包含 Dictionary<TKey, TValue> 中的键的集合。

System_CAPS_pubpropertyValues

获得一个包含 Dictionary<TKey, TValue> 中的值的集合。

名称说明
System_CAPS_pubmethodAdd(TKey, TValue)

将指定的键和值添加到字典中。

System_CAPS_pubmethodClear()

将所有键和值从 Dictionary<TKey, TValue> 中移除。

System_CAPS_pubmethodContainsKey(TKey)

确定是否 Dictionary<TKey, TValue> 包含指定键。

System_CAPS_pubmethodContainsValue(TValue)

确定 Dictionary<TKey, TValue> 是否包含特定值。

System_CAPS_pubmethodEquals(Object)

确定指定的对象是否等于当前对象。(继承自 Object。)

System_CAPS_protmethodFinalize()

在垃圾回收将某一对象回收前允许该对象尝试释放资源并执行其他清理操作。(继承自 Object。)

System_CAPS_pubmethodGetEnumerator()

返回循环访问 Dictionary<TKey, TValue> 的枚举数。

System_CAPS_pubmethodGetHashCode()

作为默认哈希函数。(继承自 Object。)

System_CAPS_pubmethodGetObjectData(SerializationInfo, StreamingContext)

实现 System.Runtime.Serialization.ISerializable 接口,并返回序列化 Dictionary<TKey, TValue> 实例所需的数据。

System_CAPS_pubmethodGetType()

获取当前实例的 Type(继承自 Object。)

System_CAPS_protmethodMemberwiseClone()

创建当前 Object 的浅表副本。(继承自 Object。)

System_CAPS_pubmethodOnDeserialization(Object)

实现 System.Runtime.Serialization.ISerializable 接口,并在完成反序列化之后引发反序列化事件。

System_CAPS_pubmethodRemove(TKey)

将带有指定键的值从 Dictionary<TKey, TValue> 中移除。

System_CAPS_pubmethodToString()

返回表示当前对象的字符串。(继承自 Object。)

System_CAPS_pubmethodTryGetValue(TKey, TValue)

获取与指定键关联的值。

名称说明
System_CAPS_pubinterfaceSystem_CAPS_privmethodICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue>)

添加指定值到带有指定键的 ICollection<T>

System_CAPS_pubinterfaceSystem_CAPS_privmethodICollection<KeyValuePair<TKey, TValue>>.Contains(KeyValuePair<TKey, TValue>)

确定是否 ICollection<T> 包含一个指定键和值。

System_CAPS_pubinterfaceSystem_CAPS_privmethodICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[], Int32)

从特定的数组索引处开始,将 ICollection<T> 的元素复制到类型 KeyValuePair<TKey, TValue> 的一个数组。

System_CAPS_pubinterfaceSystem_CAPS_privmethodICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue>)

从字典中移除键和值。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()

返回一个循环访问集合的枚举器。

System_CAPS_pubinterfaceSystem_CAPS_privmethodICollection.CopyTo(Array, Int32)

从特定的数组索引处开始,将 ICollection<T> 的元素复制到一个数组中。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIDictionary.Add(Object, Object)

将指定的键和值添加到字典中。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIDictionary.Contains(Object)

确定是否 IDictionary 包含带有指定键的元素。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIDictionary.GetEnumerator()
System_CAPS_pubinterfaceSystem_CAPS_privmethodIDictionary.Remove(Object)

IDictionary 中移除带有指定键的元素。

System_CAPS_pubinterfaceSystem_CAPS_privmethodIEnumerable.GetEnumerator()

返回一个循环访问集合的枚举器。

System_CAPS_pubinterfaceSystem_CAPS_privpropertyICollection<KeyValuePair<TKey, TValue>>.IsReadOnly

获取一个值,该值指示字典是否为只读。

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIDictionary<TKey, TValue>.Keys
System_CAPS_pubinterfaceSystem_CAPS_privpropertyIDictionary<TKey, TValue>.Values

获取一个 ICollection<T>,它包含 IDictionary<TKey, TValue> 中的值。

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIReadOnlyDictionary<TKey, TValue>.Keys

获得一个包含 IReadOnlyDictionary<TKey, TValue> 的键的集合。

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIReadOnlyDictionary<TKey, TValue>.Values

获得一个包含 IReadOnlyDictionary<TKey, TValue> 的值的集合。

System_CAPS_pubinterfaceSystem_CAPS_privpropertyICollection.IsSynchronized

获取一个值,该值指示是否同步对 ICollection 的访问(线程安全)。

System_CAPS_pubinterfaceSystem_CAPS_privpropertyICollection.SyncRoot

获取可用于同步对 ICollection 的访问的对象。

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIDictionary.IsFixedSize

获取一个值,该值指示 IDictionary 是否具有固定大小。

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIDictionary.IsReadOnly

获取一个值,该值指示 IDictionary 是否为只读。

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIDictionary.Item[Object]

获取或设置具有指定键的值。

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIDictionary.Keys

获取包含 ICollection 的键的 IDictionary

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIDictionary.Values

获取一个 ICollection,它包含 IDictionary 中的值。

名称说明
System_CAPS_pubmethodAggregate<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, KeyValuePair<TKey, TValue>, KeyValuePair<TKey, TValue>>)

已重载。对一个序列应用累加器函数。(由 Enumerable 定义。)

System_CAPS_pubmethodAggregate<KeyValuePair<TKey, TValue>, TAccumulate>(TAccumulate, Func<TAccumulate, KeyValuePair<TKey, TValue>, TAccumulate>)

已重载。对一个序列应用累加器函数。 将指定的种子值用作累加器初始值。(由 Enumerable 定义。)

System_CAPS_pubmethodAggregate<KeyValuePair<TKey, TValue>, TAccumulate, TResult>(TAccumulate, Func<TAccumulate, KeyValuePair<TKey, TValue>, TAccumulate>, Func<TAccumulate, TResult>)

已重载。对一个序列应用累加器函数。 将指定的种子值用作累加器的初始值,并使用指定的函数选择结果值。(由 Enumerable 定义。)

System_CAPS_pubmethodAll<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Boolean>)

确定是否对序列中的所有元素都满足条件。(由 Enumerable 定义。)

System_CAPS_pubmethodAny<KeyValuePair<TKey, TValue>>()

已重载。确定序列是否包含任何元素。(由 Enumerable 定义。)

System_CAPS_pubmethodAny<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Boolean>)

已重载。 确定序列中是否存在元素满足条件。 (由 Enumerable 定义。)

System_CAPS_pubmethodAsEnumerable<KeyValuePair<TKey, TValue>>()

返回输入类型化为 IEnumerable<T>(由 Enumerable 定义。)

System_CAPS_pubmethodAsParallel()

已重载。启用查询的并行化。(由 ParallelEnumerable 定义。)

System_CAPS_pubmethodAsParallel<KeyValuePair<TKey, TValue>>()

已重载。启用查询的并行化。(由 ParallelEnumerable 定义。)

System_CAPS_pubmethodAsQueryable()

已重载。将转换 IEnumerableIQueryable(由 Queryable 定义。)

System_CAPS_pubmethodAsQueryable<KeyValuePair<TKey, TValue>>()

已重载。将转换泛型 IEnumerable<T> 于泛型 IQueryable<T>(由 Queryable 定义。)

System_CAPS_pubmethodAverage<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Decimal>)

已重载。计算序列的平均值 Decimal 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodAverage<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Double>)

已重载。计算序列的平均值 Double 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodAverage<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Int32>)

已重载。计算序列的平均值 Int32 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodAverage<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Int64>)

已重载。计算序列的平均值 Int64 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodAverage<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Nullable<Decimal>>)

已重载。可以为 null 的序列的平均值,计算 Decimal 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodAverage<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Nullable<Double>>)

已重载。可以为 null 的序列的平均值,计算 Double 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodAverage<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Nullable<Int32>>)

已重载。可以为 null 的序列的平均值,计算 Int32 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodAverage<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Nullable<Int64>>)

已重载。可以为 null 的序列的平均值,计算 Int64 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodAverage<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Nullable<Single>>)

已重载。可以为 null 的序列的平均值,计算 Single 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodAverage<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Single>)

已重载。计算序列的平均值 Single 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodCast<TResult>()

将强制转换的元素 IEnumerable 为指定的类型。(由 Enumerable 定义。)

System_CAPS_pubmethodConcat<KeyValuePair<TKey, TValue>>(IEnumerable<KeyValuePair<TKey, TValue>>)

连接两个序列。(由 Enumerable 定义。)

System_CAPS_pubmethodContains<KeyValuePair<TKey, TValue>>(KeyValuePair<TKey, TValue>)

已重载。确定序列是否包含指定的元素使用的默认相等比较器。(由 Enumerable 定义。)

System_CAPS_pubmethodContains<KeyValuePair<TKey, TValue>>(KeyValuePair<TKey, TValue>, IEqualityComparer<KeyValuePair<TKey, TValue>>)

已重载。确定序列是否使用指定的包含指定的元素 IEqualityComparer<T>(由 Enumerable 定义。)

System_CAPS_pubmethodCount<KeyValuePair<TKey, TValue>>()

已重载。返回序列中的元素数。(由 Enumerable 定义。)

System_CAPS_pubmethodCount<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Boolean>)

已重载。返回一个数字来表示多少个元素指定序列中的满足条件。(由 Enumerable 定义。)

System_CAPS_pubmethodDefaultIfEmpty<KeyValuePair<TKey, TValue>>()

已重载。返回单一实例集合中指定的序列或类型参数的默认值的元素,如果序列为空。(由 Enumerable 定义。)

System_CAPS_pubmethodDefaultIfEmpty<KeyValuePair<TKey, TValue>>(KeyValuePair<TKey, TValue>)

已重载。返回单一实例集合中指定的序列或指定的值的元素,如果序列为空。(由 Enumerable 定义。)

System_CAPS_pubmethodDistinct<KeyValuePair<TKey, TValue>>()

已重载。通过使用的默认相等比较器对值进行比较从序列返回非重复元素。(由 Enumerable 定义。)

System_CAPS_pubmethodDistinct<KeyValuePair<TKey, TValue>>(IEqualityComparer<KeyValuePair<TKey, TValue>>)

已重载。返回序列中通过使用指定的非重复元素 IEqualityComparer<T> 对值进行比较。(由 Enumerable 定义。)

System_CAPS_pubmethodElementAt<KeyValuePair<TKey, TValue>>(Int32)

返回序列中的指定索引处的元素。(由 Enumerable 定义。)

System_CAPS_pubmethodElementAtOrDefault<KeyValuePair<TKey, TValue>>(Int32)

返回序列中指定索引处的元素;如果索引超出范围,则返回默认值。(由 Enumerable 定义。)

System_CAPS_pubmethodExcept<KeyValuePair<TKey, TValue>>(IEnumerable<KeyValuePair<TKey, TValue>>)

已重载。通过使用默认的相等比较器对值进行比较,生成两个序列的差集。(由 Enumerable 定义。)

System_CAPS_pubmethodExcept<KeyValuePair<TKey, TValue>>(IEnumerable<KeyValuePair<TKey, TValue>>, IEqualityComparer<KeyValuePair<TKey, TValue>>)

已重载。使用指定的生成两个序列的差集 IEqualityComparer<T> 对值进行比较。(由 Enumerable 定义。)

System_CAPS_pubmethodFirst<KeyValuePair<TKey, TValue>>()

已重载。返回一个序列的第一个元素。(由 Enumerable 定义。)

System_CAPS_pubmethodFirst<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Boolean>)

已重载。返回序列中满足指定条件的第一个元素。(由 Enumerable 定义。)

System_CAPS_pubmethodFirstOrDefault<KeyValuePair<TKey, TValue>>()

已重载。返回序列中的第一个元素;如果序列中不包含任何元素,则返回默认值。(由 Enumerable 定义。)

System_CAPS_pubmethodFirstOrDefault<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Boolean>)

已重载。返回序列中满足条件的第一个元素;如果未找到这样的元素,则返回默认值。(由 Enumerable 定义。)

System_CAPS_pubmethodGroupBy<KeyValuePair<TKey, TValue>, TKey>(Func<KeyValuePair<TKey, TValue>, TKey>)

已重载。根据指定的键选择器函数对序列的元素进行分组。(由 Enumerable 定义。)

System_CAPS_pubmethodGroupBy<KeyValuePair<TKey, TValue>, TKey>(Func<KeyValuePair<TKey, TValue>, TKey>, IEqualityComparer<TKey>)

已重载。根据指定的键选择器函数并将进行比较的键使用指定的比较器对序列的元素进行分组。(由 Enumerable 定义。)

System_CAPS_pubmethodGroupBy<KeyValuePair<TKey, TValue>, TKey, TElement>(Func<KeyValuePair<TKey, TValue>, TKey>, Func<KeyValuePair<TKey, TValue>, TElement>)

已重载。根据指定的键选择器函数和项目的元素的每个组通过使用指定的函数对序列的元素进行分组。(由 Enumerable 定义。)

System_CAPS_pubmethodGroupBy<KeyValuePair<TKey, TValue>, TKey, TElement>(Func<KeyValuePair<TKey, TValue>, TKey>, Func<KeyValuePair<TKey, TValue>, TElement>, IEqualityComparer<TKey>)

已重载。根据键选择器函数对序列的元素进行分组。 通过使用比较器对键进行比较,并且通过使用指定的函数对每个组的元素进行投影。(由 Enumerable 定义。)

System_CAPS_pubmethodGroupBy<KeyValuePair<TKey, TValue>, TKey, TResult>(Func<KeyValuePair<TKey, TValue>, TKey>, Func<TKey, IEnumerable<KeyValuePair<TKey, TValue>>, TResult>)

已重载。根据指定的键选择器函数对序列中的元素进行分组,并且从每个组及其键中创建结果值。(由 Enumerable 定义。)

System_CAPS_pubmethodGroupBy<KeyValuePair<TKey, TValue>, TKey, TResult>(Func<KeyValuePair<TKey, TValue>, TKey>, Func<TKey, IEnumerable<KeyValuePair<TKey, TValue>>, TResult>, IEqualityComparer<TKey>)

已重载。根据指定的键选择器函数对序列中的元素进行分组,并且从每个组及其键中创建结果值。 通过使用指定的比较器对键进行比较。(由 Enumerable 定义。)

System_CAPS_pubmethodGroupBy<KeyValuePair<TKey, TValue>, TKey, TElement, TResult>(Func<KeyValuePair<TKey, TValue>, TKey>, Func<KeyValuePair<TKey, TValue>, TElement>, Func<TKey, IEnumerable<TElement>, TResult>)

已重载。根据指定的键选择器函数对序列中的元素进行分组,并且从每个组及其键中创建结果值。 通过使用指定的函数对每个组的元素进行投影。(由 Enumerable 定义。)

System_CAPS_pubmethodGroupBy<KeyValuePair<TKey, TValue>, TKey, TElement, TResult>(Func<KeyValuePair<TKey, TValue>, TKey>, Func<KeyValuePair<TKey, TValue>, TElement>, Func<TKey, IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>)

已重载。根据指定的键选择器函数对序列中的元素进行分组,并且从每个组及其键中创建结果值。 通过使用指定的比较器对键值进行比较,并且通过使用指定的函数对每个组的元素进行投影。(由 Enumerable 定义。)

System_CAPS_pubmethodGroupJoin<KeyValuePair<TKey, TValue>, TInner, TKey, TResult>(IEnumerable<TInner>, Func<KeyValuePair<TKey, TValue>, TKey>, Func<TInner, TKey>, Func<KeyValuePair<TKey, TValue>, IEnumerable<TInner>, TResult>)

已重载。基于键相等对两个序列的元素进行关联,并对结果进行分组。 使用默认的相等比较器对键进行比较。(由 Enumerable 定义。)

System_CAPS_pubmethodGroupJoin<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 定义。)

System_CAPS_pubmethodIntersect<KeyValuePair<TKey, TValue>>(IEnumerable<KeyValuePair<TKey, TValue>>)

已重载。通过使用默认的相等比较器对值进行比较,生成两个序列的交集。(由 Enumerable 定义。)

System_CAPS_pubmethodIntersect<KeyValuePair<TKey, TValue>>(IEnumerable<KeyValuePair<TKey, TValue>>, IEqualityComparer<KeyValuePair<TKey, TValue>>)

已重载。使用指定的生成两个序列的交集 IEqualityComparer<T> 对值进行比较。(由 Enumerable 定义。)

System_CAPS_pubmethodJoin<KeyValuePair<TKey, TValue>, TInner, TKey, TResult>(IEnumerable<TInner>, Func<KeyValuePair<TKey, TValue>, TKey>, Func<TInner, TKey>, Func<KeyValuePair<TKey, TValue>, TInner, TResult>)

已重载。基于匹配键对两个序列的元素关联。 使用默认的相等比较器对键进行比较。(由 Enumerable 定义。)

System_CAPS_pubmethodJoin<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 定义。)

System_CAPS_pubmethodLast<KeyValuePair<TKey, TValue>>()

已重载。返回一个序列的最后一个元素。(由 Enumerable 定义。)

System_CAPS_pubmethodLast<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Boolean>)

已重载。返回序列中满足指定条件的最后一个元素。(由 Enumerable 定义。)

System_CAPS_pubmethodLastOrDefault<KeyValuePair<TKey, TValue>>()

已重载。返回序列中的最后一个元素;如果序列中不包含任何元素,则返回默认值。(由 Enumerable 定义。)

System_CAPS_pubmethodLastOrDefault<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Boolean>)

已重载。返回序列中满足条件的最后一个元素;如果未找到这样的元素,则返回默认值。(由 Enumerable 定义。)

System_CAPS_pubmethodLongCount<KeyValuePair<TKey, TValue>>()

已重载。返回 Int64 ,它表示序列中的元素的总数。(由 Enumerable 定义。)

System_CAPS_pubmethodLongCount<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Boolean>)

已重载。返回 Int64 表示序列中的多少个元素满足条件。(由 Enumerable 定义。)

System_CAPS_pubmethodMax<KeyValuePair<TKey, TValue>>()

已重载。泛型序列中返回的最大值。(由 Enumerable 定义。)

System_CAPS_pubmethodMax<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Decimal>)

已重载。调用转换函数对序列的每个元素并返回最大 Decimal 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMax<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Double>)

已重载。调用转换函数对序列的每个元素并返回最大 Double 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMax<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Int32>)

已重载。调用转换函数对序列的每个元素并返回最大 Int32 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMax<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Int64>)

已重载。调用转换函数对序列的每个元素并返回最大 Int64 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMax<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Nullable<Decimal>>)

已重载。调用转换函数对序列的每个元素并返回最大可以为 null Decimal 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMax<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Nullable<Double>>)

已重载。调用转换函数对序列的每个元素并返回最大可以为 null Double 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMax<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Nullable<Int32>>)

已重载。调用转换函数对序列的每个元素并返回最大可以为 null Int32 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMax<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Nullable<Int64>>)

已重载。调用转换函数对序列的每个元素并返回最大可以为 null Int64 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMax<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Nullable<Single>>)

已重载。调用转换函数对序列的每个元素并返回最大可以为 null Single 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMax<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Single>)

已重载。调用转换函数对序列的每个元素并返回最大 Single 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMax<KeyValuePair<TKey, TValue>, TResult>(Func<KeyValuePair<TKey, TValue>, TResult>)

已重载。调用泛型序列的每个元素的转换函数并返回最大结果值。(由 Enumerable 定义。)

System_CAPS_pubmethodMin<KeyValuePair<TKey, TValue>>()

已重载。泛型序列中返回的最小值。(由 Enumerable 定义。)

System_CAPS_pubmethodMin<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Decimal>)

已重载。调用转换函数对序列的每个元素,并返回所需的最低 Decimal 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMin<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Double>)

已重载。调用转换函数对序列的每个元素,并返回所需的最低 Double 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMin<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Int32>)

已重载。调用转换函数对序列的每个元素,并返回所需的最低 Int32 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMin<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Int64>)

已重载。调用转换函数对序列的每个元素,并返回所需的最低 Int64 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMin<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Nullable<Decimal>>)

已重载。调用转换函数对序列的每个元素,并返回最小值可以为 null Decimal 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMin<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Nullable<Double>>)

已重载。调用转换函数对序列的每个元素,并返回最小值可以为 null Double 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMin<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Nullable<Int32>>)

已重载。调用转换函数对序列的每个元素,并返回最小值可以为 null Int32 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMin<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Nullable<Int64>>)

已重载。调用转换函数对序列的每个元素,并返回最小值可以为 null Int64 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMin<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Nullable<Single>>)

已重载。调用转换函数对序列的每个元素,并返回最小值可以为 null Single 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMin<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Single>)

已重载。调用转换函数对序列的每个元素,并返回所需的最低 Single 值。(由 Enumerable 定义。)

System_CAPS_pubmethodMin<KeyValuePair<TKey, TValue>, TResult>(Func<KeyValuePair<TKey, TValue>, TResult>)

已重载。调用泛型序列的每个元素的转换函数,并返回最小的结果值。(由 Enumerable 定义。)

System_CAPS_pubmethodOfType<TResult>()

筛选的元素 IEnumerable 根据指定的类型。(由 Enumerable 定义。)

System_CAPS_pubmethodOrderBy<KeyValuePair<TKey, TValue>, TKey>(Func<KeyValuePair<TKey, TValue>, TKey>)

已重载。按根据某个键按升序对序列的元素进行排序。(由 Enumerable 定义。)

System_CAPS_pubmethodOrderBy<KeyValuePair<TKey, TValue>, TKey>(Func<KeyValuePair<TKey, TValue>, TKey>, IComparer<TKey>)

已重载。按使用指定的比较器按升序对序列的元素进行排序。(由 Enumerable 定义。)

System_CAPS_pubmethodOrderByDescending<KeyValuePair<TKey, TValue>, TKey>(Func<KeyValuePair<TKey, TValue>, TKey>)

已重载。按根据某个键按降序对序列的元素进行排序。(由 Enumerable 定义。)

System_CAPS_pubmethodOrderByDescending<KeyValuePair<TKey, TValue>, TKey>(Func<KeyValuePair<TKey, TValue>, TKey>, IComparer<TKey>)

已重载。使用指定的比较器按降序对序列的元素排序。(由 Enumerable 定义。)

System_CAPS_pubmethodReverse<KeyValuePair<TKey, TValue>>()

反转序列中元素的顺序。(由 Enumerable 定义。)

System_CAPS_pubmethodSelect<KeyValuePair<TKey, TValue>, TResult>(Func<KeyValuePair<TKey, TValue>, TResult>)

已重载。将序列中的每个元素投影到新表单。(由 Enumerable 定义。)

System_CAPS_pubmethodSelect<KeyValuePair<TKey, TValue>, TResult>(Func<KeyValuePair<TKey, TValue>, Int32, TResult>)

已重载。通过合并元素的索引投影到一个新窗体的序列的每个元素。(由 Enumerable 定义。)

System_CAPS_pubmethodSelectMany<KeyValuePair<TKey, TValue>, TResult>(Func<KeyValuePair<TKey, TValue>, IEnumerable<TResult>>)

已重载。一个序列的每个元素投影 IEnumerable<T> 并将合并为一个序列将结果序列。(由 Enumerable 定义。)

System_CAPS_pubmethodSelectMany<KeyValuePair<TKey, TValue>, TResult>(Func<KeyValuePair<TKey, TValue>, Int32, IEnumerable<TResult>>)

已重载。一个序列的每个元素投影 IEnumerable<T>, ,并将合并为一个序列将结果序列。 每个源元素的索引用于该元素的投影表。(由 Enumerable 定义。)

System_CAPS_pubmethodSelectMany<KeyValuePair<TKey, TValue>, TCollection, TResult>(Func<KeyValuePair<TKey, TValue>, IEnumerable<TCollection>>, Func<KeyValuePair<TKey, TValue>, TCollection, TResult>)

已重载。一个序列的每个元素投影 IEnumerable<T>, 将平展为一个序列,将结果序列,其中调用结果选择器函数对每个元素。(由 Enumerable 定义。)

System_CAPS_pubmethodSelectMany<KeyValuePair<TKey, TValue>, TCollection, TResult>(Func<KeyValuePair<TKey, TValue>, Int32, IEnumerable<TCollection>>, Func<KeyValuePair<TKey, TValue>, TCollection, TResult>)

已重载。一个序列的每个元素投影 IEnumerable<T>, 将平展为一个序列,将结果序列,其中调用结果选择器函数对每个元素。 每个源元素的索引用于该元素的中间投影表。(由 Enumerable 定义。)

System_CAPS_pubmethodSequenceEqual<KeyValuePair<TKey, TValue>>(IEnumerable<KeyValuePair<TKey, TValue>>)

已重载。确定两个序列是否相等的元素进行比较通过使用相应类型的默认相等比较器。(由 Enumerable 定义。)

System_CAPS_pubmethodSequenceEqual<KeyValuePair<TKey, TValue>>(IEnumerable<KeyValuePair<TKey, TValue>>, IEqualityComparer<KeyValuePair<TKey, TValue>>)

已重载。确定两个序列是否通过使用指定的比较它们的元素相等 IEqualityComparer<T>(由 Enumerable 定义。)

System_CAPS_pubmethodSingle<KeyValuePair<TKey, TValue>>()

已重载。返回序列的唯一元素;如果该序列并非恰好包含一个元素,则会引发异常。(由 Enumerable 定义。)

System_CAPS_pubmethodSingle<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Boolean>)

已重载。返回序列中满足指定条件的唯一元素;如果有多个这样的元素存在,则会引发异常。(由 Enumerable 定义。)

System_CAPS_pubmethodSingleOrDefault<KeyValuePair<TKey, TValue>>()

已重载。返回一个序列,或默认值的唯一元素,如果序列为空,则为如果序列中存在多个元素,则此方法将引发异常。(由 Enumerable 定义。)

System_CAPS_pubmethodSingleOrDefault<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Boolean>)

已重载。返回序列中满足指定条件的唯一元素;如果这类元素不存在,则返回默认值;如果有多个元素满足该条件,此方法将引发异常。(由 Enumerable 定义。)

System_CAPS_pubmethodSkip<KeyValuePair<TKey, TValue>>(Int32)

跳过指定的数量的序列中的元素,然后返回剩余元素。(由 Enumerable 定义。)

System_CAPS_pubmethodSkipWhile<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Boolean>)

已重载。只要指定的条件为 true,然后返回剩余元素,跳过序列中的元素。(由 Enumerable 定义。)

System_CAPS_pubmethodSkipWhile<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Int32, Boolean>)

已重载。只要指定的条件为 true,然后返回剩余元素,跳过序列中的元素。 将在谓词函数的逻辑中使用元素的索引。(由 Enumerable 定义。)

System_CAPS_pubmethodSum<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Decimal>)

已重载。计算的序列的和 Decimal 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodSum<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Double>)

已重载。计算的序列的和 Double 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodSum<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Int32>)

已重载。计算的序列的和 Int32 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodSum<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Int64>)

已重载。计算的序列的和 Int64 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodSum<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Nullable<Decimal>>)

已重载。计算可以为 null 的序列的和 Decimal 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodSum<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Nullable<Double>>)

已重载。计算可以为 null 的序列的和 Double 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodSum<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Nullable<Int32>>)

已重载。计算可以为 null 的序列的和 Int32 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodSum<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Nullable<Int64>>)

已重载。计算可以为 null 的序列的和 Int64 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodSum<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Nullable<Single>>)

已重载。计算可以为 null 的序列的和 Single 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodSum<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Single>)

已重载。计算的序列的和 Single 通过调用对输入序列中的每个元素的转换函数获得的值。(由 Enumerable 定义。)

System_CAPS_pubmethodTake<KeyValuePair<TKey, TValue>>(Int32)

从序列的开头返回指定的数量的连续元素。(由 Enumerable 定义。)

System_CAPS_pubmethodTakeWhile<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Boolean>)

已重载。返回序列中的元素,只要指定的条件为真。(由 Enumerable 定义。)

System_CAPS_pubmethodTakeWhile<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Int32, Boolean>)

已重载。返回序列中的元素,只要指定的条件为真。 将在谓词函数的逻辑中使用元素的索引。(由 Enumerable 定义。)

System_CAPS_pubmethodToArray<KeyValuePair<TKey, TValue>>()

创建一个数组,从 IEnumerable<T>(由 Enumerable 定义。)

System_CAPS_pubmethodToDictionary<KeyValuePair<TKey, TValue>, TKey>(Func<KeyValuePair<TKey, TValue>, TKey>)

已重载。创建 Dictionary<TKey, TValue>IEnumerable<T> 根据指定的键选择器函数。(由 Enumerable 定义。)

System_CAPS_pubmethodToDictionary<KeyValuePair<TKey, TValue>, TKey>(Func<KeyValuePair<TKey, TValue>, TKey>, IEqualityComparer<TKey>)

已重载。创建 Dictionary<TKey, TValue>IEnumerable<T> 根据指定的键选择器函数和键比较器。(由 Enumerable 定义。)

System_CAPS_pubmethodToDictionary<KeyValuePair<TKey, TValue>, TKey, TElement>(Func<KeyValuePair<TKey, TValue>, TKey>, Func<KeyValuePair<TKey, TValue>, TElement>)

已重载。创建 Dictionary<TKey, TValue>IEnumerable<T> 根据指定的键选择器和元素选择器函数。(由 Enumerable 定义。)

System_CAPS_pubmethodToDictionary<KeyValuePair<TKey, TValue>, TKey, TElement>(Func<KeyValuePair<TKey, TValue>, TKey>, Func<KeyValuePair<TKey, TValue>, TElement>, IEqualityComparer<TKey>)

已重载。创建 Dictionary<TKey, TValue>IEnumerable<T> 根据指定的键选择器函数、 比较器和元素选择器函数。(由 Enumerable 定义。)

System_CAPS_pubmethodToList<KeyValuePair<TKey, TValue>>()

创建 List<T>IEnumerable<T>(由 Enumerable 定义。)

System_CAPS_pubmethodToLookup<KeyValuePair<TKey, TValue>, TKey>(Func<KeyValuePair<TKey, TValue>, TKey>)

已重载。创建 Lookup<TKey, TElement>IEnumerable<T> 根据指定的键选择器函数。(由 Enumerable 定义。)

System_CAPS_pubmethodToLookup<KeyValuePair<TKey, TValue>, TKey>(Func<KeyValuePair<TKey, TValue>, TKey>, IEqualityComparer<TKey>)

已重载。创建 Lookup<TKey, TElement>IEnumerable<T> 根据指定的键选择器函数和键比较器。(由 Enumerable 定义。)

System_CAPS_pubmethodToLookup<KeyValuePair<TKey, TValue>, TKey, TElement>(Func<KeyValuePair<TKey, TValue>, TKey>, Func<KeyValuePair<TKey, TValue>, TElement>)

已重载。创建 Lookup<TKey, TElement>IEnumerable<T> 根据指定的键选择器和元素选择器函数。(由 Enumerable 定义。)

System_CAPS_pubmethodToLookup<KeyValuePair<TKey, TValue>, TKey, TElement>(Func<KeyValuePair<TKey, TValue>, TKey>, Func<KeyValuePair<TKey, TValue>, TElement>, IEqualityComparer<TKey>)

已重载。创建 Lookup<TKey, TElement>IEnumerable<T> 根据指定的键选择器函数、 比较和元素选择器函数。(由 Enumerable 定义。)

System_CAPS_pubmethodUnion<KeyValuePair<TKey, TValue>>(IEnumerable<KeyValuePair<TKey, TValue>>)

已重载。通过使用默认的相等比较器生成的两个序列的并集。(由 Enumerable 定义。)

System_CAPS_pubmethodUnion<KeyValuePair<TKey, TValue>>(IEnumerable<KeyValuePair<TKey, TValue>>, IEqualityComparer<KeyValuePair<TKey, TValue>>)

已重载。使用指定的生成两个序列的并集 IEqualityComparer<T>(由 Enumerable 定义。)

System_CAPS_pubmethodWhere<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Boolean>)

已重载。基于谓词筛选值序列。(由 Enumerable 定义。)

System_CAPS_pubmethodWhere<KeyValuePair<TKey, TValue>>(Func<KeyValuePair<TKey, TValue>, Int32, Boolean>)

已重载。基于谓词筛选值序列。 将在谓词函数的逻辑中使用每个元素的索引。(由 Enumerable 定义。)

System_CAPS_pubmethodZip<KeyValuePair<TKey, TValue>, TSecond, TResult>(IEnumerable<TSecond>, Func<KeyValuePair<TKey, TValue>, TSecond, TResult>)

适用于两个序列,生成结果的序列的相应元素指定的函数。(由 Enumerable 定义。)

System_CAPS_note说明

To view the .NET Framework source code for this type, see the Reference Sourcehttp://referencesource.microsoft.com/#mscorlib/system/collections/generic/dictionary.cs#d3599058f8d79be0. You can browse through the source code online, download the reference for offline viewing, and step through the sources (including patches and updates) during debugging; see instructionshttp://referencesource.microsoft.com/.

The T:System.Collections.Generic.Dictionary`2 generic class provides a mapping from a set of keys to a set of values. Each addition to the dictionary consists of a value and its associated key. Retrieving a value by using its key is very fast, close to O(1), because the T:System.Collections.Generic.Dictionary`2 class is implemented as a hash table.

System_CAPS_note说明

The speed of retrieval depends on the quality of the hashing algorithm of the type specified for TKey.

As long as an object is used as a key in the T:System.Collections.Generic.Dictionary`2, it must not change in any way that affects its hash value. Every key in a T:System.Collections.Generic.Dictionary`2 must be unique according to the dictionary's equality comparer. A key cannot be null, but a value can be, if the value type TValue is a reference type.

Dictionary<TKey, TValue> requires an equality implementation to determine whether keys are equal. You can specify an implementation of the IEqualityComparer<T> generic interface by using a constructor that accepts a comparer parameter; if you do not specify an implementation, the default generic equality comparer EqualityComparer<T>.Default is used. If type TKey implements the System.IEquatable<T> generic interface, the default equality comparer uses that implementation.

System_CAPS_note说明

For example, you can use the case-insensitive string comparers provided by the T:System.StringComparer class to create dictionaries with case-insensitive string keys.

The capacity of a T:System.Collections.Generic.Dictionary`2 is the number of elements the T:System.Collections.Generic.Dictionary`2 can hold. As elements are added to a T:System.Collections.Generic.Dictionary`2, the capacity is automatically increased as required by reallocating the internal array.

For very large T:System.Collections.Generic.Dictionary`2 objects, you can increase the maximum capacity to 2 billion elements on a 64-bit system by setting the enabled attribute of the configuration element to true in the run-time environment.

For purposes of enumeration, each item in the dictionary is treated as a T:System.Collections.Generic.KeyValuePair`2 structure representing a value and its key. The order in which the items are returned is undefined.

The foreach statement of the C# language (for each in C++, For Each in Visual Basic) returns an object of the type of the elements in the collection. Since the T:System.Collections.Generic.Dictionary`2 is a collection of keys and values, the element type is not the type of the key or the type of the value. Instead, the element type is a T:System.Collections.Generic.KeyValuePair`2 of the key type and the value type. For example:

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

The foreach statement is a wrapper around the enumerator, which allows only reading from the collection, not writing to it.

System_CAPS_note说明

Because keys can be inherited and their behavior changed, their absolute uniqueness cannot be guaranteed by comparisons using the M:System.Type.Equals(System.Object) method.

The following code example creates an empty T:System.Collections.Generic.Dictionary`2 of strings with string keys and uses the M:System.Collections.Generic.Dictionary`2.Add(`0,`1) method to add some elements. The example demonstrates that the M:System.Collections.Generic.Dictionary`2.Add(`0,`1) method throws an T:System.ArgumentException when attempting to add a duplicate key.

The example uses the P:System.Collections.Generic.Dictionary`2.Item(`0) property (the indexer in C#) to retrieve values, demonstrating that a T:System.Collections.Generic.KeyNotFoundException is thrown when a requested key is not present, and showing that the value associated with a key can be replaced.

The example shows how to use the M:System.Collections.Generic.Dictionary`2.TryGetValue(`0,`1@) method as a more efficient way to retrieve values if a program often must try key values that are not in the dictionary, and it shows how to use the M:System.Collections.Generic.Dictionary`2.ContainsKey(`0) method to test whether a key exists before calling the M:System.Collections.Generic.Dictionary`2.Add(`0,`1) method.

The example shows how to enumerate the keys and values in the dictionary and how to enumerate the keys and values alone using the P:System.Collections.Generic.Dictionary`2.Keys property and the P:System.Collections.Generic.Dictionary`2.Values property.

Finally, the example demonstrates the M:System.Collections.Generic.Dictionary`2.Remove(`0) method.

using System;
using System.Collections.Generic;

public class Example
{
    public static void Main()
    {
        // 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)
        {
            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.
        Dictionary<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.
        Dictionary<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 = 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 平台
自 8 起可用
.NET Framework
自 2.0 起可用
可移植类库
可移植 .NET 平台 中受支持
Silverlight
自 2.0 起可用
Windows Phone Silverlight
自 7.0 起可用
Windows Phone
自 8.1 起可用

A T:System.Collections.Generic.Dictionary`2 can support multiple readers concurrently, as long as the collection is not modified. Even so, enumerating through a collection is intrinsically not a thread-safe procedure. In the rare case where an enumeration contends with write accesses, the collection must be locked during the entire enumeration. To allow the collection to be accessed by multiple threads for reading and writing, you must implement your own synchronization.

For thread-safe alternatives, see the T:System.Collections.Concurrent.ConcurrentDictionary`2 class or T:System.Collections.Immutable.ImmutableDictionary`2 class.

Public static (Shared in Visual Basic) members of this type are thread safe.

返回页首
显示: