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

ConcurrentDictionary<TKey, TValue> classe

.NET Framework (current version)
 

Date de publication : novembre 2016

Représente une collection thread-safe de paires clé/valeur accessibles par plusieurs threads simultanément.

Espace de noms:   System.Collections.Concurrent
Assembly:  mscorlib (dans mscorlib.dll)

System.Object
  System.Collections.Concurrent.ConcurrentDictionary<TKey, TValue>

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

Paramètres de type

TKey

Type des clés dans le dictionnaire.

TValue

Type des valeurs dans le dictionnaire.

NomDescription
System_CAPS_pubmethodConcurrentDictionary<TKey, TValue>()

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

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

Initialise une nouvelle instance de la classe ConcurrentDictionary<TKey, TValue> qui contient des éléments copiés depuis le IEnumerable<T> spécifié, possède le niveau de concurrence par défaut, possède la capacité initiale par défaut et utilise le comparateur par défaut pour le type de clé.

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

Initialise une nouvelle instance de la classe ConcurrentDictionary<TKey, TValue> qui contient des éléments copiés à partir du IEnumerable spécifié, possède le niveau de concurrence par défaut, possède la capacité initiale par défaut et utilise le IEqualityComparer<T> spécifié.

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

Initialise une nouvelle instance de la classe ConcurrentDictionary<TKey, TValue> qui est vide, possède le niveau de concurrence et la capacité par défaut, et utilise le System.Collections.Generic.IEqualityComparer<T> spécifié.

System_CAPS_pubmethodConcurrentDictionary<TKey, TValue>(Int32, IEnumerable<KeyValuePair<TKey, TValue>>, IEqualityComparer<TKey>)

Initialise une nouvelle instance de la classe ConcurrentDictionary<TKey, TValue> qui contient des éléments copiés du IEnumerable spécifié et utilise le System.Collections.Generic.IEqualityComparer<T> spécifié.

System_CAPS_pubmethodConcurrentDictionary<TKey, TValue>(Int32, Int32)

Initialise une nouvelle instance de la classe ConcurrentDictionary<TKey, TValue> qui est vide, possède le niveau de concurrence et la capacité spécifiés, et utilise le comparateur par défaut pour le type de clé.

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

Initialise une nouvelle instance de la classe System.Collections.Concurrent.ConcurrentDictionary<TKey, TValue> qui est vide, possède le niveau de concurrence spécifiés, possède la capacité initiale spécifiée et utilise le System.Collections.Generic.IEqualityComparer<T> spécifié.

NomDescription
System_CAPS_pubpropertyCount

Obtient le nombre de paires clé/valeur contenues dans System.Collections.Concurrent.ConcurrentDictionary<TKey, TValue>.

System_CAPS_pubpropertyIsEmpty

Obtient une valeur qui indique si System.Collections.Concurrent.ConcurrentDictionary<TKey, TValue> est vide.

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 System.Collections.Generic.Dictionary<TKey, TValue>.

System_CAPS_pubpropertyValues

Obtient une collection qui contient les valeurs de System.Collections.Generic.Dictionary<TKey, TValue>.

NomDescription
System_CAPS_pubmethodAddOrUpdate(TKey, TValue, Func<TKey, TValue, TValue>)

Ajoute une paire clé/valeur au ConcurrentDictionary<TKey, TValue> si la clé n'existe pas déjà, ou met à jour une paire clé/valeur dans le ConcurrentDictionary<TKey, TValue> en utilisant la fonction spécifiée si la clé existe déjà.

System_CAPS_pubmethodAddOrUpdate(TKey, Func<TKey, TValue>, Func<TKey, TValue, TValue>)

Utilise les fonctions spécifiées pour ajouter une paire clé/valeur au ConcurrentDictionary<TKey, TValue> si la clé n'existe pas déjà, ou pour mettre à jour une paire clé/valeur dans le ConcurrentDictionary<TKey, TValue> en utilisant la fonction spécifiée si la clé existe déjà.

System_CAPS_pubmethodClear()

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

System_CAPS_pubmethodContainsKey(TKey)

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

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 à exécuter d'autres opérations de nettoyage avant qu'il ne soit récupéré par une opération garbage collection.(Hérité de Object.)

System_CAPS_pubmethodGetEnumerator()

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

System_CAPS_pubmethodGetHashCode()

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

System_CAPS_pubmethodGetOrAdd(TKey, TValue)

Ajoute une paire clé/valeur au ConcurrentDictionary<TKey, TValue> si la clé n'existe pas encore.

System_CAPS_pubmethodGetOrAdd(TKey, Func<TKey, TValue>)

Ajoute une paire clé/valeur à ConcurrentDictionary<TKey, TValue> en utilisant la fonction spécifiée, si la clé n'existe pas.

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_pubmethodToArray()

Copie les paires clé/valeur stockées dans le System.Collections.Concurrent.ConcurrentDictionary<TKey, TValue> dans un nouveau tableau.

System_CAPS_pubmethodToString()

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

System_CAPS_pubmethodTryAdd(TKey, TValue)

Tente d'ajouter la clé et la valeur spécifiées à System.Collections.Concurrent.ConcurrentDictionary<TKey, TValue>.

System_CAPS_pubmethodTryGetValue(TKey, TValue)

Tente d'obtenir la valeur associée à la clé spécifiée à partir de System.Collections.Concurrent.ConcurrentDictionary<TKey, TValue>.

System_CAPS_pubmethodTryRemove(TKey, TValue)

Tente de supprimer et de retourner la valeur ayant la clé spécifiée du System.Collections.Concurrent.ConcurrentDictionary<TKey, TValue>.

System_CAPS_pubmethodTryUpdate(TKey, TValue, TValue)

Compare la valeur existante pour la clé spécifiée avec une valeur spécifiée, et si elles sont égales, met à jour la clé avec une troisième valeur.

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

Ajoute un élément à la collection.

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

Obtient si ICollection<T> contient un élément avec la clé spécifiée.

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

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

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

Supprime la paire clé/valeur spécifiée de la collection.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIDictionary<TKey, TValue>.Add(TKey, TValue)

Ajoute la clé et la valeur spécifiées à IDictionary<TKey, TValue>.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIDictionary<TKey, TValue>.Remove(TKey)

Supprime de IDictionary<TKey, TValue> l'élément ayant la clé spécifiée.

System_CAPS_pubinterfaceSystem_CAPS_privmethodICollection.CopyTo(Array, Int32)

Copie les éléments de ICollection 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)

Obtient si System.Collections.Generic.IDictionary<TKey, TValue> contient un élément avec la clé spécifiée.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIDictionary.GetEnumerator()
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 System.Collections.Concurrent.ConcurrentDictionary<TKey, TValue>.

System_CAPS_pubinterfaceSystem_CAPS_privpropertyICollection<KeyValuePair<TKey, TValue>>.IsReadOnly

Obtient une valeur indiquant si ICollection est en lecture seule.

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIReadOnlyDictionary<TKey, TValue>.Keys

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

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIReadOnlyDictionary<TKey, TValue>.Values

Obtient une collection qui contient les valeurs de System.Collections.Generic.Dictionary<TKey, TValue>.

System_CAPS_pubinterfaceSystem_CAPS_privpropertyICollection.IsSynchronized

Obtient une valeur indiquant si l'accès à ICollection est synchronisé avec SyncRoot.

System_CAPS_pubinterfaceSystem_CAPS_privpropertyICollection.SyncRoot

Obtient un objet qui peut être utilisé pour synchroniser l'accès à ICollection. Cette propriété n'est pas prise en charge.

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIDictionary.IsFixedSize

Obtient une valeur indiquant si System.Collections.Generic.IDictionary<TKey, TValue> est de taille fixe.

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIDictionary.IsReadOnly

Obtient une valeur indiquant si System.Collections.Generic.IDictionary<TKey, TValue> est en lecture seule.

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIDictionary.Item[Object]

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

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIDictionary.Keys

Obtient un objet ICollection qui contient les clés de l'objet System.Collections.Generic.IDictionary<TKey, TValue>.

System_CAPS_pubinterfaceSystem_CAPS_privpropertyIDictionary.Values

Obtient un objet ICollection qui contient les valeurs de l'objet 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 é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 aux éléments correspondants de deux séquences, produire une séquence de résultats.(Défini par Enumerable.)

For very large T:System.Collections.Concurrent.ConcurrentDictionary`2 objects, you can increase the maximum array size to 2 gigabytes (GB) on a 64-bit system by setting the configuration element to true in the run-time environment.

System_CAPS_noteRemarque

ConcurrentDictionary<TKey, TValue> implements the IReadOnlyCollection<T> and IReadOnlyDictionary<TKey, TValue> interfaces starting with the .NET Framework 4.6; in previous versions of the .NET Framework, the ConcurrentDictionary<TKey, TValue> class did not implement these interfaces.

Like the T:System.Collections.Generic.Dictionary`2 class, T:System.Collections.Concurrent.ConcurrentDictionary`2 implements the T:System.Collections.Generic.IDictionary`2 interface. In addition, T:System.Collections.Concurrent.ConcurrentDictionary`2 provides several methods for adding or updating key/value pairs in the dictionary, as described in the following table.

To do this

Use this method

Usage notes

Add a new key to the dictionary, if it doesn’t already exist in the dictionary

TryAdd

This method adds the specified key/value pair, if the key doesn’t currently exist in the dictionary. The method returns true or false depending on whether the new pair was added.

Update the value for an existing key in the dictionary, if that key has a specific value

TryUpdate

This method checks whether the key has a specified value, and if it does, updates the key with a new value. It's similar to the Overload:System.Threading.Interlocked.CompareExchange method, except that it's used for dictionary elements.

Store a key/value pair in the dictionary unconditionally, and overwrite the value of a key that already exists

The indexer’s setter: dictionary[key] = newValue

Add a key/value pair to the dictionary, or if the key already exists, update the value for the key based on the key’s existing value

AddOrUpdate(TKey, Func<TKey, TValue>, Func<TKey, TValue, TValue>)

—or—

AddOrUpdate(TKey, TValue, Func<TKey, TValue, TValue>)

AddOrUpdate(TKey, Func<TKey, TValue>, Func<TKey, TValue, TValue>) accepts the key and two delegates. It uses the first delegate if the key doesn’t exist in the dictionary; it accepts the key and returns the value that should be added for the key. It uses the second delegate if the key does exist; it accepts the key and its current value, and it returns the new value that should be set for the key.

AddOrUpdate(TKey, TValue, Func<TKey, TValue, TValue>) accepts the key, a value to add, and the update delegate. This is the same as the previous overload, except that it doesn't use a delegate to add a key.

Get the value for a key in the dictionary, adding the value to the dictionary and returning it if the key doesn’t exist

GetOrAdd(TKey, TValue)

—or—

GetOrAdd(TKey, Func<TKey, TValue>)

These overloads provide lazy initialization for a key/value pair in the dictionary, adding the value only if it’s not there.

GetOrAdd(TKey, TValue) takes the value to be added if the key doesn’t exist.

GetOrAdd(TKey, Func<TKey, TValue>) takes a delegate that will generate the value if the key doesn’t exist.

All these operations are atomic and are thread-safe with regards to all other operations on the T:System.Collections.Concurrent.ConcurrentDictionary`2 class. The only exceptions are the methods that accept a delegate, that is, Overload:System.Collections.Concurrent.ConcurrentDictionary`2.AddOrUpdate and Overload:System.Collections.Concurrent.ConcurrentDictionary`2.GetOrAdd. For modifications and write operations to the dictionary, T:System.Collections.Concurrent.ConcurrentDictionary`2 uses fine-grained locking to ensure thread safety. (Read operations on the dictionary are performed in a lock-free manner.) However, delegates for these methods are called outside the locks to avoid the problems that can arise from executing unknown code under a lock. Therefore, the code executed by these delegates is not subject to the atomicity of the operation.

The following example shows how to construct a T:System.Collections.Concurrent.ConcurrentDictionary`2 object.


class CD_Ctor
{
        // Demonstrates:
        //      ConcurrentDictionary<TKey, TValue> ctor(concurrencyLevel, initialCapacity)
        //      ConcurrentDictionary<TKey, TValue>[TKey]
        static void Main()
        {
            // We know how many items we want to insert into the ConcurrentDictionary.
            // So set the initial capacity to some prime number above that, to ensure that
            // the ConcurrentDictionary does not need to be resized while initializing it.
            int NUMITEMS = 64;
            int initialCapacity = 101;

            // The higher the concurrencyLevel, the higher the theoretical number of operations
            // that could be performed concurrently on the ConcurrentDictionary.  However, global
            // operations like resizing the dictionary take longer as the concurrencyLevel rises. 
            // For the purposes of this example, we'll compromise at numCores * 2.
            int numProcs = Environment.ProcessorCount;
            int concurrencyLevel = numProcs * 2;

            // Construct the dictionary with the desired concurrencyLevel and initialCapacity
            ConcurrentDictionary<int, int> cd = new ConcurrentDictionary<int, int>(concurrencyLevel, initialCapacity);

            // Initialize the dictionary
            for (int i = 0; i < NUMITEMS; i++) cd[i] = i * i;

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

Plateforme Windows universelle
Disponible depuis 8
.NET Framework
Disponible depuis 4.0
Bibliothèque de classes portable
Pris en charge dans : plateformes .NET portables
Windows Phone
Disponible depuis 8.1

All public and protected members of T:System.Collections.Concurrent.ConcurrentDictionary`2 are thread-safe and may be used concurrently from multiple threads. However, members accessed through one of the interfaces the T:System.Collections.Concurrent.ConcurrentDictionary`2 implements, including extension methods, are not guaranteed to be thread safe and may need to be synchronized by the caller.

Retour au début
Afficher: