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

BlockingCollection<T> classe

.NET Framework (current version)
 

Date de publication : novembre 2016

Fournit des fonctions bloquantes et englobantes pour les collections thread-safe qui implémentent IProducerConsumerCollection<T>.

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

System.Object
  System.Collections.Concurrent.BlockingCollection<T>

[ComVisibleAttribute(false)]
[HostProtectionAttribute(SecurityAction.LinkDemand, Synchronization = true, 
	ExternalThreading = true)]
public class BlockingCollection<T> : IEnumerable<T>, IEnumerable, 
	ICollection, IDisposable, IReadOnlyCollection<T>

Paramètres de type

T

Type des éléments de la collection.

NomDescription
System_CAPS_pubmethodBlockingCollection<T>()

Initialise une nouvelle instance de la classe BlockingCollection<T> sans limite supérieure.

System_CAPS_pubmethodBlockingCollection<T>(Int32)

Initialise une nouvelle instance de la classe BlockingCollection<T> avec la limite supérieure spécifiée.

System_CAPS_pubmethodBlockingCollection<T>(IProducerConsumerCollection<T>)

Initialise une nouvelle instance de la classe BlockingCollection<T> sans limite supérieure et qui utilise le IProducerConsumerCollection<T> fourni comme magasin de données sous-jacent.

System_CAPS_pubmethodBlockingCollection<T>(IProducerConsumerCollection<T>, Int32)

Initialise une nouvelle instance de la classe BlockingCollection<T> avec la limite supérieure spécifiée et qui utilise le IProducerConsumerCollection<T> fourni comme magasin de données sous-jacent.

NomDescription
System_CAPS_pubpropertyBoundedCapacity

Obtient la capacité limite de cette instance de BlockingCollection<T>.

System_CAPS_pubpropertyCount

Obtient le nombre d'éléments contenus dans BlockingCollection<T>.

System_CAPS_pubpropertyIsAddingCompleted

Obtient si ce BlockingCollection<T> a été marqué comme ne pouvant plus accepter d'ajout.

System_CAPS_pubpropertyIsCompleted

Obtient si ce BlockingCollection<T> a été marqué comme ne pouvant plus accepter d'ajout et est vide.

NomDescription
System_CAPS_pubmethodAdd(T)

Ajoute l'élément au BlockingCollection<T>.

System_CAPS_pubmethodAdd(T, CancellationToken)

Ajoute l'élément au BlockingCollection<T>.

System_CAPS_pubmethodSystem_CAPS_staticAddToAny(BlockingCollection<T>[], T)

Ajoute l'élément spécifié à l'une des instances de BlockingCollection<T> spécifiées.

System_CAPS_pubmethodSystem_CAPS_staticAddToAny(BlockingCollection<T>[], T, CancellationToken)

Ajoute l'élément spécifié à l'une des instances de BlockingCollection<T> spécifiées.

System_CAPS_pubmethodCompleteAdding()

Marque les instances de BlockingCollection<T> comme n'acceptant plus d'ajouts.

System_CAPS_pubmethodCopyTo(T[], Int32)

Copie tous les éléments dans l'instance de BlockingCollection<T> dans un tableau compatible unidimensionnel, en commençant à l'index spécifié du tableau cible.

System_CAPS_pubmethodDispose()

Libère toutes les ressources utilisées par l'instance actuelle de la classe BlockingCollection<T>.

System_CAPS_protmethodDispose(Boolean)

Libère les ressources utilisées par l'instance de BlockingCollection<T>.

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

Fournit un IEnumerator<T> de consommation pour les éléments de la collection.

System_CAPS_pubmethodGetConsumingEnumerable(CancellationToken)

Fournit un IEnumerable<T> de consommation pour les éléments de la collection.

System_CAPS_pubmethodGetHashCode()

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

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

Supprime un élément de BlockingCollection<T>.

System_CAPS_pubmethodTake(CancellationToken)

Supprime un élément de BlockingCollection<T>.

System_CAPS_pubmethodSystem_CAPS_staticTakeFromAny(BlockingCollection<T>[], T)

Prend un élément de l'une des instances de BlockingCollection<T> spécifiées.

System_CAPS_pubmethodSystem_CAPS_staticTakeFromAny(BlockingCollection<T>[], T, CancellationToken)

Prend un élément de l'une des instances de BlockingCollection<T> spécifiées tout en observant le jeton d'annulation spécifié.

System_CAPS_pubmethodToArray()

Copie les éléments de l'instance de BlockingCollection<T> dans un nouveau tableau.

System_CAPS_pubmethodToString()

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

System_CAPS_pubmethodTryAdd(T)

Tente d'ajouter l'élément spécifié à BlockingCollection<T>.

System_CAPS_pubmethodTryAdd(T, Int32)

Tente d'ajouter l'élément spécifié à BlockingCollection<T> au cours de la période spécifiée.

System_CAPS_pubmethodTryAdd(T, Int32, CancellationToken)

Tente d'ajouter l'élément spécifié à BlockingCollection<T> au cours de la période spécifiée tout en observant un jeton d'annulation.

System_CAPS_pubmethodTryAdd(T, TimeSpan)

Tente d'ajouter l'élément spécifié à BlockingCollection<T>.

System_CAPS_pubmethodSystem_CAPS_staticTryAddToAny(BlockingCollection<T>[], T)

Tente d'ajouter l'élément spécifié à l'une des instances de BlockingCollection<T> spécifiées.

System_CAPS_pubmethodSystem_CAPS_staticTryAddToAny(BlockingCollection<T>[], T, Int32)

Tente d'ajouter l'élément spécifié à l'une des instances de BlockingCollection<T> spécifiées.

System_CAPS_pubmethodSystem_CAPS_staticTryAddToAny(BlockingCollection<T>[], T, Int32, CancellationToken)

Tente d'ajouter l'élément spécifié à l'une des instances de BlockingCollection<T> spécifiées.

System_CAPS_pubmethodSystem_CAPS_staticTryAddToAny(BlockingCollection<T>[], T, TimeSpan)

Tente d'ajouter l'élément spécifié à l'une des instances de BlockingCollection<T> spécifiées tout en observant le jeton d'annulation spécifié.

System_CAPS_pubmethodTryTake(T)

Tente de supprimer un élément de BlockingCollection<T>.

System_CAPS_pubmethodTryTake(T, Int32)

Tente de supprimer un élément de BlockingCollection<T> au cours de la période spécifiée.

System_CAPS_pubmethodTryTake(T, Int32, CancellationToken)

Tente de supprimer un élément de BlockingCollection<T> au cours de la période spécifiée tout en observant un jeton d'annulation.

System_CAPS_pubmethodTryTake(T, TimeSpan)

Tente de supprimer un élément de BlockingCollection<T> au cours de la période spécifiée.

System_CAPS_pubmethodSystem_CAPS_staticTryTakeFromAny(BlockingCollection<T>[], T)

Tente de supprimer un élément de l'une des instances de BlockingCollection<T> spécifiées.

System_CAPS_pubmethodSystem_CAPS_staticTryTakeFromAny(BlockingCollection<T>[], T, Int32)

Tente de supprimer un élément de l'une des instances de BlockingCollection<T> spécifiées.

System_CAPS_pubmethodSystem_CAPS_staticTryTakeFromAny(BlockingCollection<T>[], T, Int32, CancellationToken)

Tente de supprimer un élément de l'une des instances de BlockingCollection<T> spécifiées.

System_CAPS_pubmethodSystem_CAPS_staticTryTakeFromAny(BlockingCollection<T>[], T, TimeSpan)

Tente de supprimer un élément de l'une des instances de BlockingCollection<T> spécifiées.

NomDescription
System_CAPS_pubinterfaceSystem_CAPS_privmethodIEnumerable<T>.GetEnumerator()

Fournit un IEnumerator<T> pour les éléments de la collection.

System_CAPS_pubinterfaceSystem_CAPS_privmethodICollection.CopyTo(Array, Int32)

Copie tous les éléments dans l'instance de BlockingCollection<T> dans un tableau compatible unidimensionnel, en commençant à l'index spécifié du tableau cible.

System_CAPS_pubinterfaceSystem_CAPS_privmethodIEnumerable.GetEnumerator()

Fournit un IEnumerator pour les éléments de la collection.

System_CAPS_pubinterfaceSystem_CAPS_privpropertyICollection.IsSynchronized

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

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.

NomDescription
System_CAPS_pubmethodAggregate<T>(Func<T, T, T>)

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

System_CAPS_pubmethodAggregate<T, TAccumulate>(TAccumulate, Func<TAccumulate, T, 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<T, TAccumulate, TResult>(TAccumulate, Func<TAccumulate, T, 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<T>(Func<T, Boolean>)

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

System_CAPS_pubmethodAny<T>()

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

System_CAPS_pubmethodAny<T>(Func<T, Boolean>)

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

System_CAPS_pubmethodAsEnumerable<T>()

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

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

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

System_CAPS_pubmethodAverage<T>(Func<T, 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<T>(Func<T, 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<T>(Func<T, 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<T>(Func<T, 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<T>(Func<T, 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<T>(Func<T, 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<T>(Func<T, 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<T>(Func<T, 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<T>(Func<T, 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<T>(Func<T, 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<T>(IEnumerable<T>)

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

System_CAPS_pubmethodContains<T>(T)

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<T>(T, IEqualityComparer<T>)

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

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

System_CAPS_pubmethodCount<T>(Func<T, 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<T>()

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

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

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<T>(IEqualityComparer<T>)

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<T>(Int32)

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

System_CAPS_pubmethodElementAtOrDefault<T>(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<T>(IEnumerable<T>)

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<T>(IEnumerable<T>, IEqualityComparer<T>)

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

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

System_CAPS_pubmethodFirst<T>(Func<T, Boolean>)

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

System_CAPS_pubmethodFirstOrDefault<T>()

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<T>(Func<T, 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<T, TKey>(Func<T, 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<T, TKey>(Func<T, 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<T, TKey, TElement>(Func<T, TKey>, Func<T, 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<T, TKey, TElement>(Func<T, TKey>, Func<T, 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<T, TKey, TResult>(Func<T, TKey>, Func<TKey, IEnumerable<T>, 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<T, TKey, TResult>(Func<T, TKey>, Func<TKey, IEnumerable<T>, 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<T, TKey, TElement, TResult>(Func<T, TKey>, Func<T, 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<T, TKey, TElement, TResult>(Func<T, TKey>, Func<T, 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<T, TInner, TKey, TResult>(IEnumerable<TInner>, Func<T, TKey>, Func<TInner, TKey>, Func<T, 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<T, TInner, TKey, TResult>(IEnumerable<TInner>, Func<T, TKey>, Func<TInner, TKey>, Func<T, 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<T>(IEnumerable<T>)

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<T>(IEnumerable<T>, IEqualityComparer<T>)

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<T, TInner, TKey, TResult>(IEnumerable<TInner>, Func<T, TKey>, Func<TInner, TKey>, Func<T, 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<T, TInner, TKey, TResult>(IEnumerable<TInner>, Func<T, TKey>, Func<TInner, TKey>, Func<T, 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<T>()

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

System_CAPS_pubmethodLast<T>(Func<T, Boolean>)

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

System_CAPS_pubmethodLastOrDefault<T>()

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<T>(Func<T, 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<T>()

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

System_CAPS_pubmethodLongCount<T>(Func<T, 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<T>()

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

System_CAPS_pubmethodMax<T>(Func<T, 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<T>(Func<T, 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<T>(Func<T, 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<T>(Func<T, 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<T>(Func<T, 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<T>(Func<T, 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<T>(Func<T, 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<T>(Func<T, 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<T>(Func<T, 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<T>(Func<T, 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<T, TResult>(Func<T, 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<T>()

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

System_CAPS_pubmethodMin<T>(Func<T, 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<T>(Func<T, 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<T>(Func<T, 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<T>(Func<T, 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<T>(Func<T, 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<T>(Func<T, 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<T>(Func<T, 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<T>(Func<T, 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<T>(Func<T, 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<T>(Func<T, 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<T, TResult>(Func<T, 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<T, TKey>(Func<T, TKey>)

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

System_CAPS_pubmethodOrderBy<T, TKey>(Func<T, 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<T, TKey>(Func<T, 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<T, TKey>(Func<T, 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<T>()

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

System_CAPS_pubmethodSelect<T, TResult>(Func<T, TResult>)

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

System_CAPS_pubmethodSelect<T, TResult>(Func<T, 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<T, TResult>(Func<T, 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<T, TResult>(Func<T, 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<T, TCollection, TResult>(Func<T, IEnumerable<TCollection>>, Func<T, 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<T, TCollection, TResult>(Func<T, Int32, IEnumerable<TCollection>>, Func<T, 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<T>(IEnumerable<T>)

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<T>(IEnumerable<T>, IEqualityComparer<T>)

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

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<T>(Func<T, 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<T>()

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<T>(Func<T, 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<T>(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<T>(Func<T, 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<T>(Func<T, 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<T>(Func<T, 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<T>(Func<T, 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<T>(Func<T, 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<T>(Func<T, 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<T>(Func<T, 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<T>(Func<T, 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<T>(Func<T, 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<T>(Func<T, 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<T>(Func<T, 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<T>(Func<T, 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<T>(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<T>(Func<T, 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<T>(Func<T, 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<T>()

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

System_CAPS_pubmethodToDictionary<T, TKey>(Func<T, 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<T, TKey>(Func<T, 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<T, TKey, TElement>(Func<T, TKey>, Func<T, 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<T, TKey, TElement>(Func<T, TKey>, Func<T, 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<T>()

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

System_CAPS_pubmethodToLookup<T, TKey>(Func<T, 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<T, TKey>(Func<T, 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<T, TKey, TElement>(Func<T, TKey>, Func<T, 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<T, TKey, TElement>(Func<T, TKey>, Func<T, 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<T>(IEnumerable<T>)

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<T>(IEnumerable<T>, IEqualityComparer<T>)

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

System_CAPS_pubmethodWhere<T>(Func<T, Boolean>)

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

System_CAPS_pubmethodWhere<T>(Func<T, 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<T, TSecond, TResult>(IEnumerable<TSecond>, Func<T, 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.)

BlockingCollection<T> is a thread-safe collection class that provides the following:

  • An implementation of the producer/consumer pattern; T:System.Collections.Concurrent.BlockingCollection`1 is a wrapper for the T:System.Collections.Concurrent.IProducerConsumerCollection`1 interface.

  • Concurrent addition and removal of items from multiple threads with the M:System.Collections.Concurrent.BlockingCollection`1.Add(`0) and M:System.Collections.Concurrent.BlockingCollection`1.Take methods.

  • A bounded collection that blocks M:System.Collections.Concurrent.BlockingCollection`1.Add(`0) and M:System.Collections.Concurrent.BlockingCollection`1.Take operations when the collection is full or empty.

  • Cancellation of M:System.Collections.Concurrent.BlockingCollection`1.Add(`0) or M:System.Collections.Concurrent.BlockingCollection`1.Take operations by using a T:System.Threading.CancellationToken object in the M:System.Collections.Concurrent.BlockingCollection`1.TryAdd(`0) or M:System.Collections.Concurrent.BlockingCollection`1.TryTake(`0@) method.

System_CAPS_importantImportant

This type implements the T:System.IDisposable interface. When you have finished using the type, you should dispose of it either directly or indirectly. To dispose of the type directly, call its M:System.IDisposable.Dispose method in a try/catch block. To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). For more information, see the “Using an Object that Implements IDisposable” section in the T:System.IDisposable interface topic. Also, note that the M:System.Collections.Concurrent.BlockingCollection`1.Dispose method is not thread-safe. All other public and protected members of T:System.Collections.Concurrent.BlockingCollection`1 are thread-safe and may be used concurrently from multiple threads.

IProducerConsumerCollection<T> represents a collection that allows for thread-safe adding and removal of data. BlockingCollection<T> is used as a wrapper for an IProducerConsumerCollection<T> instance, and allows removal attempts from the collection to block until data is available to be removed. Similarly, you can create a BlockingCollection<T> to enforce an upper bound on the number of data elements allowed in the IProducerConsumerCollection<T>; addition attempts to the collection may then block until space is available to store the added items. In this manner, BlockingCollection<T> is similar to a traditional blocking queue data structure, except that the underlying data storage mechanism is abstracted away as an IProducerConsumerCollection<T>.

BlockingCollection<T> supports bounding and blocking. Bounding means that you can set the maximum capacity of the collection. Bounding is important in certain scenarios because it enables you to control the maximum size of the collection in memory, and it prevents the producing threads from moving too far ahead of the consuming threads.Multiple threads or tasks can add items to the collection concurrently, and if the collection reaches its specified maximum capacity, the producing threads will block until an item is removed. Multiple consumers can remove items concurrently, and if the collection becomes empty, the consuming threads will block until a producer adds an item. A producing thread can call the CompleteAdding method to indicate that no more items will be added. Consumers monitor the IsCompleted property to know when the collection is empty and no more items will be added.

Add and Take operations are typically performed in a loop. You can cancel a loop by passing in a CancellationToken object to the TryAdd or TryTake method, and then checking the value of the token's IsCancellationRequested property on each iteration. If the value is true, it is up to you to respond the cancellation request by cleaning up any resources and exiting the loop.

When you create a T:System.Collections.Concurrent.BlockingCollection`1 object, you can specify not only the bounded capacity but also the type of collection to use. For example, you could specify a T:System.Collections.Concurrent.ConcurrentQueue`1 object for first in, first out (FIFO) behavior, or a T:System.Collections.Concurrent.ConcurrentStack`1 object for last in, first out (LIFO) behavior. You can use any collection class that implements the T:System.Collections.Concurrent.IProducerConsumerCollection`1 interface. The default collection type for T:System.Collections.Concurrent.BlockingCollection`1 is T:System.Collections.Concurrent.ConcurrentQueue`1.

Do not modify the underlying collection directly. Use T:System.Collections.Concurrent.BlockingCollection`1 methods to add or remove elements. The T:System.Collections.Concurrent.BlockingCollection`1 object can become corrupted if you change the underlying collection directly.

The following example shows how to add and take items concurrently from a blocking collection:

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Concurrent;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

class BlockingCollectionDemo
{
    static void Main()
    {
        AddTakeDemo.BC_AddTakeCompleteAdding();
        TryTakeDemo.BC_TryTake();
        FromToAnyDemo.BC_FromToAny();
        ConsumingEnumerableDemo.BC_GetConsumingEnumerable();
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
class AddTakeDemo
{
    // Demonstrates:
    //      BlockingCollection<T>.Add()
    //      BlockingCollection<T>.Take()
    //      BlockingCollection<T>.CompleteAdding()
    public static void BC_AddTakeCompleteAdding()
    {
        using (BlockingCollection<int> bc = new BlockingCollection<int>())
        {

            // Spin up a Task to populate the BlockingCollection 
            using (Task t1 = Task.Factory.StartNew(() =>
            {
                bc.Add(1);
                bc.Add(2);
                bc.Add(3);
                bc.CompleteAdding();
            }))
            {

                // Spin up a Task to consume the BlockingCollection
                using (Task t2 = Task.Factory.StartNew(() =>
                {
                    try
                    {
                        // Consume consume the BlockingCollection
                        while (true) Console.WriteLine(bc.Take());
                    }
                    catch (InvalidOperationException)
                    {
                        // An InvalidOperationException means that Take() was called on a completed collection
                        Console.WriteLine("That's All!");
                    }
                }))

                    Task.WaitAll(t1, t2);
            }
        }
    }
}

class TryTakeDemo
{
    // Demonstrates:
    //      BlockingCollection<T>.Add()
    //      BlockingCollection<T>.CompleteAdding()
    //      BlockingCollection<T>.TryTake()
    //      BlockingCollection<T>.IsCompleted
    public static void BC_TryTake()
    {
        // Construct and fill our BlockingCollection
        using (BlockingCollection<int> bc = new BlockingCollection<int>())
        {
            int NUMITEMS = 10000;
            for (int i = 0; i < NUMITEMS; i++) bc.Add(i);
            bc.CompleteAdding();
            int outerSum = 0;

            // Delegate for consuming the BlockingCollection and adding up all items
            Action action = () =>
            {
                int localItem;
                int localSum = 0;

                while (bc.TryTake(out localItem)) localSum += localItem;
                Interlocked.Add(ref outerSum, localSum);
            };

            // Launch three parallel actions to consume the BlockingCollection
            Parallel.Invoke(action, action, action);

            Console.WriteLine("Sum[0..{0}) = {1}, should be {2}", NUMITEMS, outerSum, ((NUMITEMS*(NUMITEMS - 1))/2));
            Console.WriteLine("bc.IsCompleted = {0} (should be true)", bc.IsCompleted);
        }
    }
}

class FromToAnyDemo
{

    // Demonstrates:
    //      Bounded BlockingCollection<T>
    //      BlockingCollection<T>.TryAddToAny()
    //      BlockingCollection<T>.TryTakeFromAny()
    public static void BC_FromToAny()
    {
        BlockingCollection<int>[] bcs = new BlockingCollection<int>[2];
        bcs[0] = new BlockingCollection<int>(5); // collection bounded to 5 items
        bcs[1] = new BlockingCollection<int>(5); // collection bounded to 5 items

        // Should be able to add 10 items w/o blocking
        int numFailures = 0;
        for (int i = 0; i < 10; i++)
        {
            if (BlockingCollection<int>.TryAddToAny(bcs, i) == -1) numFailures++;
        }
        Console.WriteLine("TryAddToAny: {0} failures (should be 0)", numFailures);

        // Should be able to retrieve 10 items
        int numItems = 0;
        int item;
        while (BlockingCollection<int>.TryTakeFromAny(bcs, out item) != -1) numItems++;
        Console.WriteLine("TryTakeFromAny: retrieved {0} items (should be 10)", numItems);
    }
}

class ConsumingEnumerableDemo
{
    // Demonstrates:
    //      BlockingCollection<T>.Add()
    //      BlockingCollection<T>.CompleteAdding()
    //      BlockingCollection<T>.GetConsumingEnumerable()
    public static void BC_GetConsumingEnumerable()
    {
        using (BlockingCollection<int> bc = new BlockingCollection<int>())
        {

            // Kick off a producer task
            Task.Factory.StartNew(() =>
            {
                for (int i = 0; i < 10; i++)
                {
                    bc.Add(i);
                    Thread.Sleep(100); // sleep 100 ms between adds
                }

                // Need to do this to keep foreach below from hanging
                bc.CompleteAdding();
            });

            // Now consume the blocking collection with foreach.
            // Use bc.GetConsumingEnumerable() instead of just bc because the
            // former will block waiting for completion and the latter will
            // simply take a snapshot of the current state of the underlying collection.
            foreach (var item in bc.GetConsumingEnumerable())
            {
                Console.WriteLine(item);
            }
        }
    }
}

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

The Dispose method is not thread-safe. All other public and protected members of T:System.Collections.Concurrent.BlockingCollection`1 are thread-safe and may be used concurrently from multiple threads.

Retour au début
Afficher: