BlockingCollection<T> Classe

Définition

Fournit des fonctions bloquantes et englobantes pour les collections thread-safe qui implémentent IProducerConsumerCollection<T>.Provides blocking and bounding capabilities for thread-safe collections that implement IProducerConsumerCollection<T>.

generic <typename T>
public ref class BlockingCollection : IDisposable, System::Collections::Generic::IEnumerable<T>, System::Collections::Generic::IReadOnlyCollection<T>, System::Collections::ICollection
[System.Runtime.InteropServices.ComVisible(false)]
public class BlockingCollection<T> : IDisposable, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.ICollection
type BlockingCollection<'T> = class
    interface seq<'T>
    interface ICollection
    interface IDisposable
    interface IReadOnlyCollection<'T>
    interface IEnumerable
Public Class BlockingCollection(Of T)
Implements ICollection, IDisposable, IEnumerable(Of T), IReadOnlyCollection(Of T)

Paramètres de type

T

Type des éléments de la collection.The type of elements in the collection.

Héritage
BlockingCollection<T>
Attributs
Implémente

Exemples

L’exemple suivant montre comment ajouter et prendre des éléments simultanément à partir d’une collection bloquante :The following example shows how to add and take items concurrently from a blocking collection:

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

class BlockingCollectionDemo
{
    static async Task Main()
    {
        await AddTakeDemo.BC_AddTakeCompleteAdding();
        TryTakeDemo.BC_TryTake();
        FromToAnyDemo.BC_FromToAny();
        await 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 async Task BC_AddTakeCompleteAdding()
    {
        using (BlockingCollection<int> bc = new BlockingCollection<int>())
        {
            // Spin up a Task to populate the BlockingCollection
            using (Task t1 = Task.Run(() =>
            {
                bc.Add(1);
                bc.Add(2);
                bc.Add(3);
                bc.CompleteAdding();
            }))
            {
                // Spin up a Task to consume the BlockingCollection
                using (Task t2 = Task.Run(() =>
                {
                    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!");
                    }
                }))
                {
                    await Task.WhenAll(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 async Task BC_GetConsumingEnumerable()
    {
        using (BlockingCollection<int> bc = new BlockingCollection<int>())
        {
            // Kick off a producer task
            await Task.Run(async () =>
            {
                for (int i = 0; i < 10; i++)
                {
                    bc.Add(i);
                    await Task.Delay(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);
            }
        }
    }
}
Imports System.Threading.Tasks
Imports System.Collections.Concurrent
Imports System.Threading

Class BlockingCollectionDemo
    Shared Sub Main()
        AddTakeDemo.BC_AddTakeCompleteAdding()
        TryTakeDemo.BC_TryTake()
        ToAnyDemo.BC_ToAny()
        ConsumingEnumerableDemo.BC_GetConsumingEnumerable()
        ' Keep the console window open in debug mode
        Console.WriteLine("Press any key to exit.")
        Console.ReadKey()
    End Sub
End Class

Class AddTakeDemo

    ' Demonstrates:
    ' BlockingCollection<T>.Add()
    ' BlockingCollection<T>.Take()
    ' BlockingCollection<T>.CompleteAdding()
    Shared Sub BC_AddTakeCompleteAdding()
        Using bc As New BlockingCollection(Of Integer)()

            ' Spin up a Task to populate the BlockingCollection 
            Using t1 As Task = Task.Factory.StartNew(
                Sub()
                    bc.Add(1)
                    bc.Add(2)
                    bc.Add(3)
                    bc.CompleteAdding()
                End Sub)
                ' Spin up a Task to consume the BlockingCollection
                Using t2 As Task = Task.Factory.StartNew(
                Sub()
                    Try
                        ' Consume the BlockingCollection
                        While True
                            Console.WriteLine(bc.Take())
                        End While
                    Catch generatedExceptionName As InvalidOperationException
                        ' An InvalidOperationException means that Take() was called on a completed collection
                        Console.WriteLine("That's All!")
                    End Try
                End Sub)

                    Task.WaitAll(t1, t2)
                End Using
            End Using
        End Using
    End Sub



End Class

'Imports System.Collections.Concurrent
'Imports System.Threading
'Imports System.Threading.Tasks

Class TryTakeDemo
    ' Demonstrates:
    ' BlockingCollection<T>.Add()
    ' BlockingCollection<T>.CompleteAdding()
    ' BlockingCollection<T>.TryTake()
    ' BlockingCollection<T>.IsCompleted
    Shared Sub BC_TryTake()
        ' Construct and fill our BlockingCollection
        Using bc As New BlockingCollection(Of Integer)()
            Dim NUMITEMS As Integer = 10000
            For i As Integer = 0 To NUMITEMS - 1
                bc.Add(i)
            Next
            bc.CompleteAdding()
            Dim outerSum As Integer = 0

            ' Delegate for consuming the BlockingCollection and adding up all items
            Dim action As Action =
                Sub()
                    Dim localItem As Integer
                    Dim localSum As Integer = 0

                    While bc.TryTake(localItem)
                        localSum += localItem
                    End While
                    Interlocked.Add(outerSum, localSum)
                End Sub

            ' 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)
        End Using
    End Sub

End Class

'Imports System.Threading.Tasks
'Imports System.Collections.Concurrent

' Demonstrates:
' Bounded BlockingCollection<T>
' BlockingCollection<T>.TryAddToAny()
' BlockingCollection<T>.TryTakeFromAny()
Class ToAnyDemo
    Shared Sub BC_ToAny()
        Dim bcs As BlockingCollection(Of Integer)() = New BlockingCollection(Of Integer)(1) {}
        bcs(0) = New BlockingCollection(Of Integer)(5)
        ' collection bounded to 5 items
        bcs(1) = New BlockingCollection(Of Integer)(5)
        ' collection bounded to 5 items
        ' Should be able to add 10 items w/o blocking
        Dim numFailures As Integer = 0
        For i As Integer = 0 To 9
            If BlockingCollection(Of Integer).TryAddToAny(bcs, i) = -1 Then
                numFailures += 1
            End If
        Next
        Console.WriteLine("TryAddToAny: {0} failures (should be 0)", numFailures)

        ' Should be able to retrieve 10 items
        Dim numItems As Integer = 0
        Dim item As Integer
        While BlockingCollection(Of Integer).TryTakeFromAny(bcs, item) <> -1
            numItems += 1
        End While
        Console.WriteLine("TryTakeFromAny: retrieved {0} items (should be 10)", numItems)
    End Sub
End Class

'Imports System.Threading.Tasks
'Imports System.Collections.Concurrent

' Demonstrates:
' BlockingCollection<T>.Add()
' BlockingCollection<T>.CompleteAdding()
' BlockingCollection<T>.GetConsumingEnumerable()

Class ConsumingEnumerableDemo
    Shared Sub BC_GetConsumingEnumerable()
        Using bc As New BlockingCollection(Of Integer)()

            ' Kick off a producer task
            Task.Factory.StartNew(
                Sub()
                    For i As Integer = 0 To 9
                        bc.Add(i)
                        ' sleep 100 ms between adds
                        Thread.Sleep(100)
                    Next

                    ' Need to do this to keep foreach below from not responding.
                    bc.CompleteAdding()
                End Sub)
            ' 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.
            For Each item In bc.GetConsumingEnumerable()
                Console.WriteLine(item)
            Next
        End Using
    End Sub
End Class

Remarques

BlockingCollection<T> est une classe de collection thread-safe qui fournit les éléments suivants :BlockingCollection<T> is a thread-safe collection class that provides the following:

Important

Ce type implémente l'interface IDisposable.This type implements the IDisposable interface. Une fois que vous avez fini d’utiliser le type, vous devez le supprimer directement ou indirectement.When you have finished using the type, you should dispose of it either directly or indirectly. Pour supprimer directement le type Dispose, appelez sa méthode dans un bloc try/catch.To dispose of the type directly, call its Dispose method in a try/catch block. Pour la supprimer indirectement, utilisez une construction de langage telle que using (dans C#) ou Using (dans Visual Basic).To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Pour plus d’informations, consultez la section « Utilisation d’un objet qui implémente IDisposable » dans la rubrique de l’interface IDisposable.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic. Notez également que la méthode Dispose() n’est pas thread-safe.Also, note that the Dispose() method is not thread-safe. Tous les autres membres publics et protégés de BlockingCollection<T> sont thread-safe et peuvent être utilisés simultanément à partir de plusieurs threads.All other public and protected members of BlockingCollection<T> are thread-safe and may be used concurrently from multiple threads.

IProducerConsumerCollection<T> représente une collection qui permet d’ajouter et de supprimer des données thread-safe.IProducerConsumerCollection<T> represents a collection that allows for thread-safe adding and removal of data. BlockingCollection<T> est utilisé comme wrapper pour une instance IProducerConsumerCollection<T> et permet aux tentatives de suppression de la collection de se bloquer jusqu’à ce que les données soient disponibles pour être supprimées.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. De même, vous pouvez créer un BlockingCollection<T> pour appliquer une limite supérieure au nombre d’éléments de données autorisés dans le IProducerConsumerCollection<T> ; les tentatives d’ajout au regroupement peuvent alors se bloquer jusqu’à ce que de l’espace soit disponible pour stocker les éléments ajoutés.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. De cette façon, BlockingCollection<T> est semblable à une structure de données de file d’attente de blocage traditionnelle, à ceci près que le mécanisme de stockage de données sous-jacent est abstrait en tant que IProducerConsumerCollection<T>.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> prend en charge la délimitation et le blocage.BlockingCollection<T> supports bounding and blocking. La limitation signifie que vous pouvez définir la capacité maximale de la collection.Bounding means that you can set the maximum capacity of the collection. La délimitation est importante dans certains scénarios, car elle vous permet de contrôler la taille maximale de la collection en mémoire, et elle empêche les threads producteurs de se déplacer trop loin avant les threads consommateurs. Plusieurs threads ou tâches peuvent ajouter simultanément des éléments à la collection, et si la collection atteint sa capacité maximale spécifiée, les threads de production se bloquent jusqu’à ce qu’un élément soit supprimé.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. Plusieurs consommateurs peuvent supprimer des éléments simultanément, et si la collection devient vide, les threads consommateur se bloquent jusqu’à ce qu’un producteur ajoute un élément.Multiple consumers can remove items concurrently, and if the collection becomes empty, the consuming threads will block until a producer adds an item. Un thread producteur peut appeler la méthode CompleteAdding pour indiquer qu’aucun autre élément ne sera ajouté.A producing thread can call the CompleteAdding method to indicate that no more items will be added. Les consommateurs surveillent la propriété IsCompleted pour savoir quand la collection est vide et quand aucun autre élément ne sera ajouté.Consumers monitor the IsCompleted property to know when the collection is empty and no more items will be added.

Add et Take opérations sont généralement effectuées dans une boucle.Add and Take operations are typically performed in a loop. Vous pouvez annuler une boucle en passant un objet CancellationToken à la méthode TryAdd ou TryTake, puis en vérifiant la valeur de la propriété IsCancellationRequested du jeton à chaque itération.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. Si la valeur est true, il vous revient de répondre à la demande d’annulation en nettoyant toutes les ressources et en quittant la boucle.If the value is true, it is up to you to respond the cancellation request by cleaning up any resources and exiting the loop.

Lorsque vous créez un objet BlockingCollection<T>, vous pouvez spécifier non seulement la capacité limitée, mais aussi le type de collection à utiliser.When you create a BlockingCollection<T> object, you can specify not only the bounded capacity but also the type of collection to use. Par exemple, vous pouvez spécifier un objet ConcurrentQueue<T> pour le comportement premier entré, premier sorti (FIFO), ou un objet ConcurrentStack<T> pour le comportement dernier entré, premier sorti (LIFO).For example, you could specify a ConcurrentQueue<T> object for first in, first out (FIFO) behavior, or a ConcurrentStack<T> object for last in, first out (LIFO) behavior. Vous pouvez utiliser n’importe quelle classe de collection qui implémente l’interface IProducerConsumerCollection<T>.You can use any collection class that implements the IProducerConsumerCollection<T> interface. Le type de collection par défaut pour BlockingCollection<T> est ConcurrentQueue<T>.The default collection type for BlockingCollection<T> is ConcurrentQueue<T>.

Ne modifiez pas la collection sous-jacente directement.Do not modify the underlying collection directly. Utilisez les méthodes BlockingCollection<T> pour ajouter ou supprimer des éléments.Use BlockingCollection<T> methods to add or remove elements. L’objet BlockingCollection<T> peut être endommagé si vous modifiez directement la collection sous-jacente.The BlockingCollection<T> object can become corrupted if you change the underlying collection directly.

Constructeurs

BlockingCollection<T>()

Initialise une nouvelle instance de la classe BlockingCollection<T> sans limite supérieure.Initializes a new instance of the BlockingCollection<T> class without an upper-bound.

BlockingCollection<T>(Int32)

Initialise une nouvelle instance de la classe BlockingCollection<T> avec la limite supérieure spécifiée.Initializes a new instance of the BlockingCollection<T> class with the specified upper-bound.

BlockingCollection<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.Initializes a new instance of the BlockingCollection<T> class without an upper-bound and using the provided IProducerConsumerCollection<T> as its underlying data store.

BlockingCollection<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.Initializes a new instance of the BlockingCollection<T> class with the specified upper-bound and using the provided IProducerConsumerCollection<T> as its underlying data store.

Propriétés

BoundedCapacity

Obtient la capacité limite de cette instance de BlockingCollection<T>.Gets the bounded capacity of this BlockingCollection<T> instance.

Count

Obtient le nombre d'éléments contenus dans BlockingCollection<T>.Gets the number of items contained in the BlockingCollection<T>.

IsAddingCompleted

Obtient si ce BlockingCollection<T> a été marqué comme ne pouvant plus accepter d'ajout.Gets whether this BlockingCollection<T> has been marked as complete for adding.

IsCompleted

Obtient si ce BlockingCollection<T> a été marqué comme ne pouvant plus accepter d'ajout et est vide.Gets whether this BlockingCollection<T> has been marked as complete for adding and is empty.

Méthodes

Add(T)

Ajoute l'élément au BlockingCollection<T>.Adds the item to the BlockingCollection<T>.

Add(T, CancellationToken)

Ajoute l'élément au BlockingCollection<T>.Adds the item to the BlockingCollection<T>.

AddToAny(BlockingCollection<T>[], T)

Ajoute l'élément spécifié à l'une des instances de BlockingCollection<T> spécifiées.Adds the specified item to any one of the specified BlockingCollection<T> instances.

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

Ajoute l'élément spécifié à l'une des instances de BlockingCollection<T> spécifiées.Adds the specified item to any one of the specified BlockingCollection<T> instances.

CompleteAdding()

Marque les instances de BlockingCollection<T> comme n'acceptant plus d'ajouts.Marks the BlockingCollection<T> instances as not accepting any more additions.

CopyTo(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.Copies all of the items in the BlockingCollection<T> instance to a compatible one-dimensional array, starting at the specified index of the target array.

Dispose()

Libère toutes les ressources utilisées par l'instance actuelle de la classe BlockingCollection<T>.Releases all resources used by the current instance of the BlockingCollection<T> class.

Dispose(Boolean)

Libère les ressources utilisées par l'instance de BlockingCollection<T>.Releases resources used by the BlockingCollection<T> instance.

Equals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
GetConsumingEnumerable()

Fournit un IEnumerator<T> de consommation pour les éléments de la collection.Provides a consuming IEnumerator<T> for items in the collection.

GetConsumingEnumerable(CancellationToken)

Fournit un IEnumerable<T> de consommation pour les éléments de la collection.Provides a consuming IEnumerable<T> for items in the collection.

GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
Take()

Supprime un élément de BlockingCollection<T>.Removes an item from the BlockingCollection<T>.

Take(CancellationToken)

Supprime un élément de BlockingCollection<T>.Removes an item from the BlockingCollection<T>.

TakeFromAny(BlockingCollection<T>[], T)

Prend un élément de l'une des instances de BlockingCollection<T> spécifiées.Takes an item from any one of the specified BlockingCollection<T> instances.

TakeFromAny(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é.Takes an item from any one of the specified BlockingCollection<T> instances while observing the specified cancellation token.

ToArray()

Copie les éléments de l'instance de BlockingCollection<T> dans le nouveau tableau.Copies the items from the BlockingCollection<T> instance into a new array.

ToString()

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Hérité de Object)
TryAdd(T)

Tente d'ajouter l'élément spécifié à BlockingCollection<T>.Tries to add the specified item to the BlockingCollection<T>.

TryAdd(T, Int32)

Tente d'ajouter l'élément spécifié à BlockingCollection<T> au cours de la période spécifiée.Tries to add the specified item to the BlockingCollection<T> within the specified time period.

TryAdd(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.Tries to add the specified item to the BlockingCollection<T> within the specified time period, while observing a cancellation token.

TryAdd(T, TimeSpan)

Tente d'ajouter l'élément spécifié à BlockingCollection<T>.Tries to add the specified item to the BlockingCollection<T>.

TryAddToAny(BlockingCollection<T>[], T)

Tente d'ajouter l'élément spécifié à l'une des instances de BlockingCollection<T> spécifiées.Tries to add the specified item to any one of the specified BlockingCollection<T> instances.

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

Tente d'ajouter l'élément spécifié à l'une des instances de BlockingCollection<T> spécifiées.Tries to add the specified item to any one of the specified BlockingCollection<T> instances.

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

Tente d'ajouter l'élément spécifié à l'une des instances de BlockingCollection<T> spécifiées.Tries to add the specified item to any one of the specified BlockingCollection<T> instances.

TryAddToAny(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é.Tries to add the specified item to any one of the specified BlockingCollection<T> instances while observing the specified cancellation token.

TryTake(T)

Tente de supprimer un élément de BlockingCollection<T>.Tries to remove an item from the BlockingCollection<T>.

TryTake(T, Int32)

Tente de supprimer un élément de BlockingCollection<T> au cours de la période spécifiée.Tries to remove an item from the BlockingCollection<T> in the specified time period.

TryTake(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.Tries to remove an item from the BlockingCollection<T> in the specified time period while observing a cancellation token.

TryTake(T, TimeSpan)

Tente de supprimer un élément de BlockingCollection<T> au cours de la période spécifiée.Tries to remove an item from the BlockingCollection<T> in the specified time period.

TryTakeFromAny(BlockingCollection<T>[], T)

Tente de supprimer un élément de l'une des instances de BlockingCollection<T> spécifiées.Tries to remove an item from any one of the specified BlockingCollection<T> instances.

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

Tente de supprimer un élément de l'une des instances de BlockingCollection<T> spécifiées.Tries to remove an item from any one of the specified BlockingCollection<T> instances.

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

Tente de supprimer un élément de l'une des instances de BlockingCollection<T> spécifiées.Tries to remove an item from any one of the specified BlockingCollection<T> instances.

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

Tente de supprimer un élément de l'une des instances de BlockingCollection<T> spécifiées.Tries to remove an item from any one of the specified BlockingCollection<T> instances.

Implémentations d’interfaces explicites

ICollection.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.Copies all of the items in the BlockingCollection<T> instance to a compatible one-dimensional array, starting at the specified index of the target array.

ICollection.IsSynchronized

Obtient une valeur indiquant si l'accès à ICollection est synchronisé (thread-safe).Gets a value indicating whether access to the ICollection is synchronized (thread safe).

ICollection.SyncRoot

Obtient un objet qui peut être utilisé pour synchroniser l'accès à ICollection.Gets an object that can be used to synchronize access to the ICollection. Cette propriété n'est pas prise en charge.This property is not supported.

IEnumerable.GetEnumerator()

Fournit un IEnumerator pour les éléments de la collection.Provides an IEnumerator for items in the collection.

IEnumerable<T>.GetEnumerator()

Fournit un IEnumerator<T> pour les éléments de la collection.Provides an IEnumerator<T> for items in the collection.

Méthodes d’extension

CopyToDataTable<T>(IEnumerable<T>)

Retourne un DataTable qui contient des copies des objets DataRow, à partir d'un objet d'entrée IEnumerable<T> où le paramètre générique T est DataRow.Returns a DataTable that contains copies of the DataRow objects, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)

Copie les objets DataRow vers le DataTable spécifié, à partir d'un objet d'entrée IEnumerable<T> où le paramètre générique T est DataRow.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)

Copie les objets DataRow vers le DataTable spécifié, à partir d'un objet d'entrée IEnumerable<T> où le paramètre générique T est DataRow.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

Cast<TResult>(IEnumerable)

Effectue un cast des éléments d'un IEnumerable vers le type spécifié.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtre les éléments d'un IEnumerable en fonction du type spécifié.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Active la parallélisation d'une requête.Enables parallelization of a query.

AsQueryable(IEnumerable)

Convertit un IEnumerable en IQueryable.Converts an IEnumerable to an IQueryable.

Ancestors<T>(IEnumerable<T>)

Retourne une collection d'éléments qui contient les ancêtres de chaque nœud de la collection source.Returns a collection of elements that contains the ancestors of every node in the source collection.

Ancestors<T>(IEnumerable<T>, XName)

Retourne une collection d'éléments filtrée qui contient les ancêtres de chaque nœud de la collection source.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Seuls les éléments avec un XName correspondant sont inclus dans la collection.Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>)

Retourne une collection des nœuds descendants de chaque document et élément de la collection source.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>)

Retourne une collection d'éléments qui contient les éléments descendants de tous les éléments et tous les documents de la collection source.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

Descendants<T>(IEnumerable<T>, XName)

Retourne une collection d'éléments filtrée qui contient les éléments descendants de tous les éléments et tous les documents de la collection source.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Seuls les éléments avec un XName correspondant sont inclus dans la collection.Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>)

Retourne une collection des éléments enfants de chaque élément et document de la collection source.Returns a collection of the child elements of every element and document in the source collection.

Elements<T>(IEnumerable<T>, XName)

Retourne une collection filtrée des éléments enfants de chaque élément et document de la collection source.Returns a filtered collection of the child elements of every element and document in the source collection. Seuls les éléments avec un XName correspondant sont inclus dans la collection.Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>)

Retourne une collection de nœuds qui contient tous les nœuds de la collection source, triés selon l'ordre des documents.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>)

Retourne une collection des nœuds enfants de chaque document et élément de la collection source.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>)

Supprime chaque nœud de la collection source de son nœud parent.Removes every node in the source collection from its parent node.

S’applique à

Cohérence de thread

La méthode dispose n’est pas thread-safe.The Dispose method is not thread-safe. Tous les autres membres publics et protégés de BlockingCollection<T> sont thread-safe et peuvent être utilisés simultanément à partir de plusieurs threads.All other public and protected members of BlockingCollection<T> are thread-safe and may be used concurrently from multiple threads.

Voir aussi