Dictionary(TKey, TValue) Classe
TOC
Réduire la table des matières
Développer la table des matières
Cet article a fait l’objet d’une traduction automatique. Pour afficher l’article en anglais, activez la case d’option Anglais. Vous pouvez également afficher le texte anglais dans une fenêtre contextuelle en faisant glisser le pointeur de la souris sur le texte traduit.
Traduction
Anglais

Dictionary<TKey, TValue>, classe

 

Représente une collection de clés et de valeurs.

Pour parcourir le code source .NET Framework pour ce type, consultez la Reference Source.

Espace de noms:   System.Collections.Generic
Assembly:  mscorlib (dans 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

Paramètres de type

TKey

Type des clés dans le dictionnaire.

TValue

Type des valeurs dans le dictionnaire.

NomDescription
System_CAPS_pubmethodDictionary<TKey, TValue>()

Initialise une nouvelle instance de la classe Dictionary<TKey, TValue> qui est vide, possède la capacité initiale par défaut et utilise le comparateur d'égalité par défaut pour le type de clé.

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

Initialise une nouvelle instance de la classe Dictionary<TKey, TValue> qui contient des éléments copiés à partir du IDictionary<TKey, TValue> spécifié et utilise le comparateur d'égalité par défaut pour le type de clé.

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

Initialise une nouvelle instance de la classe Dictionary<TKey, TValue> qui contient des éléments copiés à partir du IDictionary<TKey, TValue> spécifié et utilise le IEqualityComparer<T> spécifié.

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

Initialise une nouvelle instance de la classe Dictionary<TKey, TValue> qui est vide, possède la capacité initiale par défaut et utilise le IEqualityComparer<T> spécifié.

System_CAPS_pubmethodDictionary<TKey, TValue>(Int32)

Initialise une nouvelle instance de la classe Dictionary<TKey, TValue> qui est vide, possède la capacité initiale spécifiée et utilise le comparateur d'égalité par défaut pour le type de clé.

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

Initialise une nouvelle instance de la classe Dictionary<TKey, TValue> qui est vide, possède la capacité initiale spécifiée et utilise le IEqualityComparer<T> spécifié.

System_CAPS_protmethodDictionary<TKey, TValue>(SerializationInfo, StreamingContext)

Initialise une nouvelle instance de la classe Dictionary<TKey, TValue> avec des données sérialisées.

NomDescription
System_CAPS_pubpropertyComparer

Obtient le IEqualityComparer<T> qui est utilisé pour déterminer l'égalité des clés pour le dictionnaire.

System_CAPS_pubpropertyCount

Obtient le nombre de paires clé/valeur contenues dans Dictionary<TKey, TValue>.

System_CAPS_pubpropertyItem[TKey]

Obtient ou définit la valeur associée à la clé spécifiée.

System_CAPS_pubpropertyKeys

Obtient une collection contenant les clés dans Dictionary<TKey, TValue>.

System_CAPS_pubpropertyValues

Obtient une collection contenant les valeurs dans Dictionary<TKey, TValue>.

NomDescription
System_CAPS_pubmethodAdd(TKey, TValue)

Ajoute la clé et la valeur spécifiées au dictionnaire.

System_CAPS_pubmethodClear()

Supprime toutes les clés et les valeurs de Dictionary<TKey, TValue>.

System_CAPS_pubmethodContainsKey(TKey)

Détermine si Dictionary<TKey, TValue> contient la clé spécifiée.

System_CAPS_pubmethodContainsValue(TValue)

Détermine si Dictionary<TKey, TValue> contient une valeur spécifique.

System_CAPS_pubmethodEquals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.(Hérité de Object.)

System_CAPS_protmethodFinalize()

Autorise un objet à tenter de libérer des ressources et d'exécuter d'autres opérations de nettoyage avant qu'il ne soit récupéré par l'opération garbage collection. (Hérité de Object.)

System_CAPS_pubmethodGetEnumerator()

Retourne un énumérateur qui itère au sein de Dictionary<TKey, TValue>.

System_CAPS_pubmethodGetHashCode()

Fait office de fonction de hachage par défaut.(Hérité de Object.)

System_CAPS_pubmethodGetObjectData(SerializationInfo, StreamingContext)

Implémente l'interface System.Runtime.Serialization.ISerializable et retourne les données nécessaires pour sérialiser l'instance Dictionary<TKey, TValue>.

System_CAPS_pubmethodGetType()

Obtient le Type de l'instance actuelle.(Hérité de Object.)

System_CAPS_protmethodMemberwiseClone()

Crée une copie superficielle du Object actuel.(Hérité de Object.)

System_CAPS_pubmethodOnDeserialization(Object)

Implémente l'interface System.Runtime.Serialization.ISerializable et déclenche l'événement de désérialisation une fois la désérialisation terminée.

System_CAPS_pubmethodRemove(TKey)

Supprime de Dictionary<TKey, TValue> la valeur ayant la clé spécifiée.

System_CAPS_pubmethodToString()

Retourne une chaîne qui représente l'objet actuel.(Hérité de Object.)

System_CAPS_pubmethodTryGetValue(TKey, TValue)

Obtient la valeur associée à la clé spécifiée.

NomDescription
System_CAPS_pubinterfaceSystem_CAPS_privmethodICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue>)

Ajoute la valeur spécifiée à ICollection<T> avec la clé spécifiée.

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

Détermine si ICollection<T> contient une clé et une valeur spécifiques.

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

Copie les éléments de ICollection<T> dans un tableau de type KeyValuePair<TKey, TValue>, en commençant au niveau de l'index de tableau spécifié.

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

Supprime une clé et une valeur du dictionnaire.

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

Retourne un énumérateur qui itère au sein de la collection.

System_CAPS_pubinterfaceSystem_CAPS_privmethodICollection.CopyTo(Array, Int32)

Copie les éléments de ICollection<T> dans un tableau, en commençant au niveau d'un index de tableau spécifié.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIDictionary.Add(Object, Object)

Ajoute la clé et la valeur spécifiées au dictionnaire.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIDictionary.Contains(Object)

Détermine si IDictionary contient un élément avec la clé spécifiée.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIDictionary.GetEnumerator()

Retourne IDictionaryEnumerator pour l'objet IDictionary.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIDictionary.Remove(Object)

Supprime de IDictionary l'élément ayant la clé spécifiée.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIEnumerable.GetEnumerator()

Retourne un énumérateur qui itère au sein de la collection.

System_CAPS_pubinterfaceSystem_CAPS_privpropertyICollection<KeyValuePair<TKey, TValue>>.IsReadOnly

Obtient une valeur indiquant si le dictionnaire est en lecture seule.

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIDictionary<TKey, TValue>.Keys

Obtient un ICollection<T> contenant les clés de IDictionary<TKey, TValue>.

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIDictionary<TKey, TValue>.Values

Obtient ICollection<T> contenant les valeurs de IDictionary<TKey, TValue>.

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIReadOnlyDictionary<TKey, TValue>.Keys

Obtient une collection contenant les clés de IReadOnlyDictionary<TKey, TValue>.

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIReadOnlyDictionary<TKey, TValue>.Values

Obtient une collection contenant les valeurs de IReadOnlyDictionary<TKey, TValue>.

System_CAPS_pubinterfaceSystem_CAPS_privpropertyICollection.IsSynchronized

Obtient une valeur indiquant si l'accès à ICollection est synchronisé (thread-safe).

System_CAPS_pubinterfaceSystem_CAPS_privpropertyICollection.SyncRoot

Obtient un objet qui peut être utilisé pour synchroniser l'accès à ICollection.

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIDictionary.IsFixedSize

Obtient une valeur indiquant si IDictionary est de taille fixe.

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIDictionary.IsReadOnly

Obtient une valeur indiquant si IDictionary est en lecture seule.

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIDictionary.Item[Object]

Obtient ou définit la valeur avec la clé spécifiée.

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIDictionary.Keys

Obtient un ICollection contenant les clés de IDictionary.

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIDictionary.Values

Obtient ICollection contenant les valeurs de IDictionary.

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

Surchargé. Applique une fonction d'accumulation sur une séquence.(Défini par Enumerable.)

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

Surchargé. Applique une fonction d'accumulation sur une séquence. La valeur initiale spécifiée est utilisée comme valeur d'accumulation initiale.(Défini par Enumerable.)

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

Surchargé. Applique une fonction d'accumulation sur une séquence. La valeur initiale spécifiée est utilisée comme valeur d'accumulation initiale et la fonction spécifiée permet de sélectionner la valeur de résultat.(Défini par Enumerable.)

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

Détermine si tous les éléments d'une séquence remplissent une condition.(Défini par Enumerable.)

System_CAPS_pubmethodAny<KeyValuePair<TKey, TValue>>()

Surchargé. Détermine si une séquence contient des éléments.(Défini par Enumerable.)

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

Surchargé. Détermine si les éléments d'une séquence satisfont à une condition.(Défini par Enumerable.)

System_CAPS_pubmethodAsEnumerable<KeyValuePair<TKey, TValue>>()

Retourne l'entrée typée comme IEnumerable<T>.(Défini par Enumerable.)

System_CAPS_pubmethodAsParallel()

Surchargé. Active la parallélisation d'une requête.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodAsParallel<KeyValuePair<TKey, TValue>>()

Surchargé. Active la parallélisation d'une requête.(Défini par ParallelEnumerable.)

System_CAPS_pubmethodAsQueryable()

Surchargé. Convertit un IEnumerable à un IQueryable.(Défini par Queryable.)

System_CAPS_pubmethodAsQueryable<KeyValuePair<TKey, TValue>>()

Surchargé. Convertit un type générique IEnumerable<T> générique IQueryable<T>.(Défini par Queryable.)

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

Surchargé. Calcule la moyenne d'une séquence de Decimal valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par Enumerable.)

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

Surchargé. Calcule la moyenne d'une séquence de Double valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par Enumerable.)

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

Surchargé. Calcule la moyenne d'une séquence de Int32 valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par Enumerable.)

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

Surchargé. Calcule la moyenne d'une séquence de Int64 valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par Enumerable.)

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

Surchargé. Calcule la moyenne d'une séquence de type nullable Decimal valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par Enumerable.)

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

Surchargé. Calcule la moyenne d'une séquence de type nullable Double valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par Enumerable.)

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

Surchargé. Calcule la moyenne d'une séquence de type nullable Int32 valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par Enumerable.)

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

Surchargé. Calcule la moyenne d'une séquence de type nullable Int64 valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par Enumerable.)

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

Surchargé. Calcule la moyenne d'une séquence de type nullable Single valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par Enumerable.)

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

Surchargé. Calcule la moyenne d'une séquence de Single valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par Enumerable.)

System_CAPS_pubmethodCast<TResult>()

Convertit les éléments d'un IEnumerable au type spécifié.(Défini par Enumerable.)

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

Concatène deux séquences.(Défini par Enumerable.)

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

Surchargé. Détermine si une séquence contient un élément spécifié à l'aide du comparateur d'égalité par défaut.(Défini par Enumerable.)

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

Surchargé. Détermine si une séquence contient un élément spécifié en utilisant un IEqualityComparer<T>.(Défini par Enumerable.)

System_CAPS_pubmethodCount<KeyValuePair<TKey, TValue>>()

Surchargé. Retourne le nombre d'éléments dans une séquence.(Défini par Enumerable.)

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

Surchargé. Retourne un nombre qui représente le nombre d'éléments dans la séquence spécifiée qui satisfont à une condition.(Défini par Enumerable.)

System_CAPS_pubmethodDefaultIfEmpty<KeyValuePair<TKey, TValue>>()

Surchargé. Retourne les éléments de la séquence spécifiée ou la valeur par défaut du paramètre de type dans une collection de singletons si la séquence est vide.(Défini par Enumerable.)

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

Surchargé. Retourne les éléments de la séquence spécifiée ou la valeur spécifiée dans une collection de singletons si la séquence est vide.(Défini par Enumerable.)

System_CAPS_pubmethodDistinct<KeyValuePair<TKey, TValue>>()

Surchargé. Retourne des éléments distincts d'une séquence à l'aide du comparateur d'égalité par défaut pour comparer les valeurs.(Défini par Enumerable.)

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

Surchargé. Retourne des éléments distincts d'une séquence en utilisant un IEqualityComparer<T> pour comparer des valeurs.(Défini par Enumerable.)

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

Retourne l'élément à l'index spécifié dans une séquence.(Défini par Enumerable.)

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

Retourne l’élément situé à un index spécifié dans une séquence ou une valeur par défaut si l’index est hors limites.(Défini par Enumerable.)

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

Surchargé. Produit la différence définie entre deux séquences à l'aide du comparateur d'égalité par défaut pour comparer les valeurs.(Défini par Enumerable.)

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

Surchargé. Produit la différence définie entre deux séquences en utilisant le IEqualityComparer<T> pour comparer des valeurs.(Défini par Enumerable.)

System_CAPS_pubmethodFirst<KeyValuePair<TKey, TValue>>()

Surchargé. Retourne le premier élément d'une séquence.(Défini par Enumerable.)

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

Surchargé. Retourne le premier élément d’une séquence à satisfaire à la condition spécifiée.(Défini par Enumerable.)

System_CAPS_pubmethodFirstOrDefault<KeyValuePair<TKey, TValue>>()

Surchargé. Retourne le premier élément d’une séquence ou une valeur par défaut si la séquence ne contient aucun élément.(Défini par Enumerable.)

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

Surchargé. Retourne le premier élément de la séquence à satisfaire à une condition ou une valeur par défaut si aucun élément correspondant n’est trouvé.(Défini par Enumerable.)

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

Surchargé. Regroupe les éléments d'une séquence selon une fonction de sélection de clé spécifiée.(Défini par Enumerable.)

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

Surchargé. Regroupe les éléments d'une séquence selon une fonction de sélection de clé spécifiée et compare les clés à l'aide du comparateur spécifié.(Défini par Enumerable.)

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

Surchargé. Regroupe les éléments d'une séquence selon une fonction de sélection de clé spécifiée et projette les éléments de chaque groupe à l'aide d'une fonction spécifiée.(Défini par Enumerable.)

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

Surchargé. Regroupe les éléments d'une séquence selon une fonction de sélection de clé. Les clés sont comparées à l'aide d'un comparateur et les éléments de chaque groupe sont projetés à l'aide d'une fonction spécifique.(Défini par Enumerable.)

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

Surchargé. Regroupe les éléments d'une séquence selon la fonction de sélection de clé spécifiée et crée une valeur de résultat à partir de chaque groupe et de la clé correspondante.(Défini par Enumerable.)

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

Surchargé. Regroupe les éléments d'une séquence selon la fonction de sélection de clé spécifiée et crée une valeur de résultat à partir de chaque groupe et de la clé correspondante. Les clés sont comparées à l'aide d'un comparateur spécifié.(Défini par 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>)

Surchargé. Regroupe les éléments d'une séquence selon la fonction de sélection de clé spécifiée et crée une valeur de résultat à partir de chaque groupe et de la clé correspondante. Les éléments de chaque groupe sont projetés à l'aide d'une fonction spécifique.(Défini par 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>)

Surchargé. Regroupe les éléments d'une séquence selon la fonction de sélection de clé spécifiée et crée une valeur de résultat à partir de chaque groupe et de la clé correspondante. Les valeurs de clé sont comparées à l'aide du comparateur spécifié et les éléments de chaque groupe sont projetés à l'aide d'une fonction spécifique.(Défini par 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>)

Surchargé. Met en corrélation les éléments de deux séquences en fonction de l'égalité des clés et regroupe les résultats. Le comparateur d'égalité par défaut est utilisé pour comparer les clés.(Défini par 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>)

Surchargé. Met en corrélation les éléments de deux séquences en fonction de l'égalité des clés et regroupe les résultats. Un IEqualityComparer<T> est utilisé pour comparer les clés.(Défini par Enumerable.)

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

Surchargé. Produit l'intersection définie de deux séquences à l'aide du comparateur d'égalité par défaut pour comparer les valeurs.(Défini par Enumerable.)

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

Surchargé. Produit l'intersection définie de deux séquences en utilisant le IEqualityComparer<T> pour comparer des valeurs.(Défini par 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>)

Surchargé. Met en corrélation les éléments de deux séquences selon des clés correspondantes. Le comparateur d'égalité par défaut est utilisé pour comparer les clés.(Défini par 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>)

Surchargé. Met en corrélation les éléments de deux séquences selon des clés correspondantes. Un IEqualityComparer<T> est utilisé pour comparer les clés.(Défini par Enumerable.)

System_CAPS_pubmethodLast<KeyValuePair<TKey, TValue>>()

Surchargé. Retourne le dernier élément d'une séquence.(Défini par Enumerable.)

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

Surchargé. Retourne le dernier élément d’une séquence à satisfaire à la condition spécifiée.(Défini par Enumerable.)

System_CAPS_pubmethodLastOrDefault<KeyValuePair<TKey, TValue>>()

Surchargé. Retourne le dernier élément d’une séquence ou une valeur par défaut si la séquence ne contient aucun élément.(Défini par Enumerable.)

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

Surchargé. Retourne le dernier élément d’une séquence à satisfaire à une condition ou une valeur par défaut si aucun élément correspondant n’est trouvé.(Défini par Enumerable.)

System_CAPS_pubmethodLongCount<KeyValuePair<TKey, TValue>>()

Surchargé. Retourne un Int64 qui représente le nombre total d'éléments dans une séquence.(Défini par Enumerable.)

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

Surchargé. Retourne un Int64 qui représente le nombre d'éléments dans une séquence remplissent une condition.(Défini par Enumerable.)

System_CAPS_pubmethodMax<KeyValuePair<TKey, TValue>>()

Surchargé. Retourne la valeur maximale dans une séquence générique.(Défini par Enumerable.)

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

Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur maximale Decimal valeur.(Défini par Enumerable.)

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

Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur maximale Double valeur.(Défini par Enumerable.)

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

Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur maximale Int32 valeur.(Défini par Enumerable.)

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

Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur maximale Int64 valeur.(Défini par Enumerable.)

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

Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur maximale nullable Decimal valeur.(Défini par Enumerable.)

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

Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur maximale nullable Double valeur.(Défini par Enumerable.)

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

Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur maximale nullable Int32 valeur.(Défini par Enumerable.)

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

Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur maximale nullable Int64 valeur.(Défini par Enumerable.)

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

Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur maximale nullable Single valeur.(Défini par Enumerable.)

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

Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur maximale Single valeur.(Défini par Enumerable.)

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

Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence générique et retourne la valeur résultante maximale.(Défini par Enumerable.)

System_CAPS_pubmethodMin<KeyValuePair<TKey, TValue>>()

Surchargé. Retourne la valeur minimale dans une séquence générique.(Défini par Enumerable.)

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

Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur minimale Decimal valeur.(Défini par Enumerable.)

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

Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur minimale Double valeur.(Défini par Enumerable.)

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

Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur minimale Int32 valeur.(Défini par Enumerable.)

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

Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur minimale Int64 valeur.(Défini par Enumerable.)

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

Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur minimale nullable Decimal valeur.(Défini par Enumerable.)

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

Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur minimale nullable Double valeur.(Défini par Enumerable.)

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

Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur minimale nullable Int32 valeur.(Défini par Enumerable.)

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

Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur minimale nullable Int64 valeur.(Défini par Enumerable.)

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

Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur minimale nullable Single valeur.(Défini par Enumerable.)

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

Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence et retourne la valeur minimale Single valeur.(Défini par Enumerable.)

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

Surchargé. Appelle une fonction de transformation sur chaque élément d'une séquence générique et retourne la valeur résultante minimale.(Défini par Enumerable.)

System_CAPS_pubmethodOfType<TResult>()

Filtre les éléments d'un IEnumerable basé sur un type spécifié.(Défini par Enumerable.)

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

Surchargé. Trie les éléments d'une séquence dans l'ordre croissant selon une clé.(Défini par Enumerable.)

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

Surchargé. Trie les éléments d'une séquence dans l'ordre croissant à l'aide du comparateur spécifié.(Défini par Enumerable.)

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

Surchargé. Trie les éléments d'une séquence dans l'ordre décroissant selon une clé.(Défini par Enumerable.)

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

Surchargé. Trie les éléments d'une séquence dans l'ordre décroissant à l'aide d'un comparateur spécifié.(Défini par Enumerable.)

System_CAPS_pubmethodReverse<KeyValuePair<TKey, TValue>>()

Inverse l'ordre des éléments dans une séquence.(Défini par Enumerable.)

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

Surchargé. Projette chaque élément d’une séquence dans un nouveau formulaire.(Défini par Enumerable.)

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

Surchargé. Projette chaque élément d'une séquence dans un nouveau formulaire en incorporant l'index de l'élément.(Défini par Enumerable.)

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

Surchargé. Projette chaque élément d'une séquence sur un IEnumerable<T> et aplatit les séquences résultantes en une seule séquence.(Défini par Enumerable.)

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

Surchargé. Projette chaque élément d'une séquence sur un IEnumerable<T>, et aplatit les séquences résultantes en une seule séquence. L'index de chaque élément source est utilisé dans le formulaire projeté de l'élément.(Défini par Enumerable.)

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

Surchargé. Projette chaque élément d'une séquence sur un IEnumerable<T>, aplatit les séquences résultantes en une seule séquence et appelle une fonction de sélecteur de résultat sur chaque élément inclus.(Défini par Enumerable.)

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

Surchargé. Projette chaque élément d'une séquence sur un IEnumerable<T>, aplatit les séquences résultantes en une seule séquence et appelle une fonction de sélecteur de résultat sur chaque élément inclus. L'index de chaque élément source est utilisé dans le formulaire intermédiaire projeté de l'élément.(Défini par Enumerable.)

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

Surchargé. Détermine si deux séquences sont égales en comparant les éléments à l'aide du comparateur d'égalité par défaut pour ce type.(Défini par Enumerable.)

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

Surchargé. Détermine si deux séquences sont égales en comparant leurs éléments en utilisant un IEqualityComparer<T>.(Défini par Enumerable.)

System_CAPS_pubmethodSingle<KeyValuePair<TKey, TValue>>()

Surchargé. Retourne l'élément unique d'une séquence ou lève une exception si cette séquence ne contient pas un seul et unique élément. (Défini par Enumerable.)

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

Surchargé. Retourne le seul élément d’une séquence qui satisfait à une condition spécifique ou lève une exception si cette séquence contient plusieurs éléments respectant cette condition.(Défini par Enumerable.)

System_CAPS_pubmethodSingleOrDefault<KeyValuePair<TKey, TValue>>()

Surchargé. Retourne le seul élément d'une séquence ou une valeur par défaut si la séquence est vide ; Cette méthode lève une exception s'il existe plusieurs éléments dans la séquence.(Défini par Enumerable.)

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

Surchargé. Retourne l’élément unique d’une séquence ou une valeur par défaut si cette séquence ne contient pas d’élément respectant cette condition. Cette méthode lève une exception si cette séquence contient plusieurs éléments satisfaisant à cette condition.(Défini par Enumerable.)

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

Ignore un nombre spécifié d'éléments dans une séquence et puis retourne les éléments restants.(Défini par Enumerable.)

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

Surchargé. Ignore les éléments d'une séquence tant qu'une condition spécifiée a la valeur true, puis retourne les éléments restants.(Défini par Enumerable.)

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

Surchargé. Ignore les éléments d'une séquence tant qu'une condition spécifiée a la valeur true, puis retourne les éléments restants. L'index de l'élément est utilisé dans la logique de la fonction de prédicat.(Défini par Enumerable.)

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

Surchargé. Calcule la somme de la séquence de Decimal valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par Enumerable.)

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

Surchargé. Calcule la somme de la séquence de Double valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par Enumerable.)

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

Surchargé. Calcule la somme de la séquence de Int32 valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par Enumerable.)

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

Surchargé. Calcule la somme de la séquence de Int64 valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par Enumerable.)

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

Surchargé. Calcule la somme de la séquence de nullable Decimal valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par Enumerable.)

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

Surchargé. Calcule la somme de la séquence de nullable Double valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par Enumerable.)

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

Surchargé. Calcule la somme de la séquence de nullable Int32 valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par Enumerable.)

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

Surchargé. Calcule la somme de la séquence de nullable Int64 valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par Enumerable.)

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

Surchargé. Calcule la somme de la séquence de nullable Single valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par Enumerable.)

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

Surchargé. Calcule la somme de la séquence de Single valeurs obtenues en appelant une fonction de transformation sur chaque élément de la séquence d'entrée.(Défini par Enumerable.)

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

Retourne un nombre spécifié d’éléments contigus à partir du début d’une séquence.(Défini par Enumerable.)

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

Surchargé. Retourne des éléments d’une séquence tant qu’une condition spécifiée a la valeur true.(Défini par Enumerable.)

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

Surchargé. Retourne des éléments d’une séquence tant qu’une condition spécifiée a la valeur true. L'index de l'élément est utilisé dans la logique de la fonction de prédicat.(Défini par Enumerable.)

System_CAPS_pubmethodToArray<KeyValuePair<TKey, TValue>>()

Crée un tableau d’un IEnumerable<T>.(Défini par Enumerable.)

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

Surchargé. Crée un Dictionary<TKey, TValue> d’un IEnumerable<T> selon une fonction de sélection de clé spécifiée.(Défini par Enumerable.)

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

Surchargé. Crée un Dictionary<TKey, TValue> d’un IEnumerable<T> selon un comparateur de fonction et la clé de sélection de clé spécifiée.(Défini par Enumerable.)

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

Surchargé. Crée un Dictionary<TKey, TValue> d’un IEnumerable<T> en fonction de sélection de clé spécifiée et les fonctions de sélecteur d’élément.(Défini par Enumerable.)

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

Surchargé. Crée un Dictionary<TKey, TValue> d’un IEnumerable<T> selon une fonction de sélection de clé spécifiée, un comparateur et une fonction de sélection d’élément.(Défini par Enumerable.)

System_CAPS_pubmethodToList<KeyValuePair<TKey, TValue>>()

Crée un List<T> d’un IEnumerable<T>.(Défini par Enumerable.)

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

Surchargé. Crée un Lookup<TKey, TElement> d’un IEnumerable<T> selon une fonction de sélection de clé spécifiée.(Défini par Enumerable.)

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

Surchargé. Crée un Lookup<TKey, TElement> d’un IEnumerable<T> selon un comparateur de fonction et la clé de sélection de clé spécifiée.(Défini par Enumerable.)

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

Surchargé. Crée un Lookup<TKey, TElement> d’un IEnumerable<T> en fonction de sélection de clé spécifiée et les fonctions de sélecteur d’élément.(Défini par Enumerable.)

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

Surchargé. Crée un Lookup<TKey, TElement> d’un IEnumerable<T> selon une fonction de sélection de clé spécifiée, un comparateur et une fonction de sélection d’élément.(Défini par Enumerable.)

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

Surchargé. Produit l'union définie de deux séquences à l'aide du comparateur d'égalité par défaut.(Défini par Enumerable.)

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

Surchargé. Produit l'union définie de deux séquences en utilisant un IEqualityComparer<T>.(Défini par Enumerable.)

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

Surchargé. Filtre une séquence de valeurs selon un prédicat.(Défini par Enumerable.)

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

Surchargé. Filtre une séquence de valeurs selon un prédicat. L'index de chaque élément est utilisé dans la logique de la fonction de prédicat.(Défini par Enumerable.)

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

Applique une fonction spécifiée pour les éléments de deux séquences, produire une séquence de résultats correspondants.(Défini par Enumerable.)

System_CAPS_noteRemarque

Pour afficher le code source .NET Framework pour ce type, consultez la Reference Source. Vous pouvez parcourir le code source en ligne, télécharger la référence hors connexion et parcourir les sources (y compris les correctifs et mises à jour) pendant le débogage ; see instructions.

La Dictionary<TKey, TValue> classe générique fournit un mappage à partir d'un jeu de clés à un ensemble de valeurs. Chaque ajout au dictionnaire se compose d’une valeur et de sa clé associée. Récupération d'une valeur à l'aide de sa clé est très rapide, fermer à o (1), car la Dictionary<TKey, TValue> classe est implémentée comme une table de hachage.

System_CAPS_noteRemarque

La vitesse de récupération dépend de la qualité de l'algorithme de hachage du type spécifié pour TKey.

Si un objet est utilisé comme clé dans le Dictionary<TKey, TValue>, il ne doit pas changer en aucune manière qui affecte sa valeur de hachage. Chaque clé dans un Dictionary<TKey, TValue> doit être unique selon le comparateur d'égalité du dictionnaire. Une clé ne peut pas être null, mais une valeur peut l'être si le type valeur TValue est un type référence.

Dictionary<TKey, TValue> requiert l'implémentation d'une égalité pour déterminer si les clés sont égales. Vous pouvez spécifier une implémentation de la IEqualityComparer<T> interface générique à l'aide d'un constructeur qui accepte un comparer paramètre ; si vous ne spécifiez pas d'implémentation, le comparateur d'égalité générique par défaut EqualityComparer<T>.Default est utilisé. Si type TKey implémente le System.IEquatable<T> interface générique, le comparateur d'égalité par défaut utilise cette implémentation.

System_CAPS_noteRemarque

Par exemple, vous pouvez utiliser les comparateurs de chaînes sans respecter la casse fournis par la StringComparer classe pour créer des dictionnaires avec des clés de chaîne de la casse.

La capacité d'un Dictionary<TKey, TValue> est le nombre d'éléments de la Dictionary<TKey, TValue> peut contenir. Lorsque des éléments sont ajoutés à un Dictionary<TKey, TValue>, la capacité est automatiquement augmentée si nécessaire, en réallouant le tableau interne.

De très grande Dictionary<TKey, TValue> des objets, vous pouvez augmenter la capacité maximale de 2 milliards des éléments sur un système 64 bits en définissant le enabled attribut de l'élément de configuration true dans l'environnement d'exécution.

À des fins d'énumération, chaque élément dans le dictionnaire est traité comme un KeyValuePair<TKey, TValue> structure qui représente une valeur et sa clé. L'ordre dans lequel les éléments sont retournés est non défini.

La foreach instruction du langage c# (for each en C++, For Each en Visual Basic) retourne un objet du type des éléments dans la collection. Étant donné que le Dictionary<TKey, TValue> est une collection de clés et valeurs, le type d'élément n'est pas le type de la clé ou le type de la valeur. Au lieu de cela, le type d'élément est un KeyValuePair<TKey, TValue> de type de clé et le type de valeur. Exemple :

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

La foreach instruction est un wrapper autour de l'énumérateur, qui permet la lecture à partir de la collection, mais ne pas l'écriture dans celle-ci.

System_CAPS_noteRemarque

Étant donné que les clés peuvent être héritées et leur comportement modifié, leur unicité absolue ne peut pas être garantie par des comparaisons à l'aide de la Equals méthode.

L'exemple de code suivant crée un vide Dictionary<TKey, TValue> de chaînes avec des clés de chaîne et utilise le Add méthode pour ajouter des éléments. L'exemple montre que le Add méthode lève un ArgumentException lors de la tentative d'ajout d'une clé dupliquée.

L'exemple utilise le Item propriété (l'indexeur en c#) pour récupérer des valeurs, démontrant qu'une KeyNotFoundException est levée lorsqu'une clé demandée n'est pas présente et indiquant que la valeur associée à une clé peut être remplacée.

L'exemple montre comment utiliser le TryGetValue méthode comme un moyen plus efficace pour récupérer des valeurs si un programme doit souvent essayer des valeurs de clés qui ne sont pas dans le dictionnaire, il montre comment utiliser le ContainsKey méthode pour tester si une clé existe avant d'appeler le Add (méthode).

L'exemple montre comment énumérer les clés et valeurs dans le dictionnaire et comment énumérer les clés et les valeurs seules à l'aide du Keys propriété et Values propriété.

Enfin, l'exemple montre le Remove (méthode).

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.
 */

Universal Windows Platform
Disponible depuis 8
.NET Framework
Disponible depuis 2.0
Portable Class Library
Pris en charge dans : portable .NET platforms
Silverlight
Disponible depuis 2.0
Windows Phone Silverlight
Disponible depuis 7.0
Windows Phone
Disponible depuis 8.1

Un Dictionary<TKey, TValue> peut prendre en charge plusieurs lecteurs simultanément, tant que la collection n'est pas modifiée. Même dans ce cas, l'énumération d'une collection n'est intrinsèquement pas une procédure thread-safe. Dans les rares cas où une énumération gère accès en écriture, la collection doit être verrouillée pendant toute l'énumération. Pour permettre à plusieurs threads d'accéder en lecture et en écriture à la collection, vous devez implémenter votre propre synchronisation.

Pour des alternatives de thread-safe, consultez la ConcurrentDictionary<TKey, TValue> classe ou System.Collections.Immutable.ImmutableDictionary<TKey, TValue> classe.

Public static (Shared en Visual Basic) de ce type sont thread-safe.

Retour au début
Afficher:
© 2016 Microsoft