BlockingCollection<T> Classe

Definição

Fornece funcionalidades de bloqueio e delimitação para coleções thread-safe que implementam 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)

Parâmetros de tipo

T

O tipo dos elementos na coleção.The type of elements in the collection.

Herança
BlockingCollection<T>
Atributos
Implementações

Exemplos

O exemplo a seguir mostra como adicionar e levar itens simultaneamente de uma coleção de bloqueio: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

Comentários

BlockingCollection<T> é uma classe de coleção thread-safe que fornece o seguinte:BlockingCollection<T> is a thread-safe collection class that provides the following:

Importante

Esse tipo implementa a interface IDisposable.This type implements the IDisposable interface. Quando você terminar de usar o tipo, deverá descartá-lo direta ou indiretamente.When you have finished using the type, you should dispose of it either directly or indirectly. Para descartar o tipo diretamente, chame o método Dispose dele em um bloco try/catch.To dispose of the type directly, call its Dispose method in a try/catch block. Para descartá-lo indiretamente, use um constructo de linguagem como using ( em C#) ou Using (em Visual Basic).To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Saiba mais na seção "Como usar um objeto que implementa IDisposable" no tópico da interface IDisposable.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic. Além disso, observe que o método Dispose() não é thread-safe.Also, note that the Dispose() method is not thread-safe. Todos os outros membros públicos e protegidos do BlockingCollection<T> são thread-safe e podem ser usados simultaneamente de vários threads.All other public and protected members of BlockingCollection<T> are thread-safe and may be used concurrently from multiple threads.

IProducerConsumerCollection<T> representa uma coleção que permite a adição e remoção de dados com segurança de thread.IProducerConsumerCollection<T> represents a collection that allows for thread-safe adding and removal of data. BlockingCollection<T> é usado como um wrapper para uma instância de IProducerConsumerCollection<T> e permite que as tentativas de remoção da coleção sejam bloqueadas até que os dados estejam disponíveis para serem removidos.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. Da mesma forma, você pode criar um BlockingCollection<T> para impor um limite superior no número de elementos de dados permitidos no IProducerConsumerCollection<T>; tentativas de adição à coleção podem bloquear até que o espaço esteja disponível para armazenar os itens adicionados.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. Dessa maneira, BlockingCollection<T> é semelhante a uma estrutura de dados de fila de bloqueio tradicional, exceto que o mecanismo de armazenamento de dados subjacente é abstraido como um 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> dá suporte à delimitação e ao bloqueio.BlockingCollection<T> supports bounding and blocking. O limite significa que você pode definir a capacidade máxima da coleção.Bounding means that you can set the maximum capacity of the collection. O limite é importante em determinados cenários porque permite que você controle o tamanho máximo da coleção na memória e impede que os threads de produção se movimentem muito longe dos threads de consumo. Vários threads ou tarefas podem adicionar itens à coleção simultaneamente e, se a coleção atingir a capacidade máxima especificada, os threads de produção serão bloqueados até que um item seja removido.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. Vários consumidores podem remover itens simultaneamente e, se a coleção ficar vazia, os threads de consumo serão bloqueados até que um produtor adicione um item.Multiple consumers can remove items concurrently, and if the collection becomes empty, the consuming threads will block until a producer adds an item. Um thread de produção pode chamar o método CompleteAdding para indicar que nenhum item adicional será adicionado.A producing thread can call the CompleteAdding method to indicate that no more items will be added. Os consumidores monitoram a propriedade IsCompleted para saber quando a coleção está vazia e não serão adicionados mais itens.Consumers monitor the IsCompleted property to know when the collection is empty and no more items will be added.

as operações Add e Take normalmente são executadas em um loop.Add and Take operations are typically performed in a loop. Você pode cancelar um loop passando um objeto CancellationToken para o método TryAdd ou TryTake e, em seguida, verificando o valor da propriedade IsCancellationRequested do token em cada iteração.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. Se o valor for true, cabe a você responder à solicitação de cancelamento, limpando todos os recursos e saindo do loop.If the value is true, it is up to you to respond the cancellation request by cleaning up any resources and exiting the loop.

Ao criar um objeto BlockingCollection<T>, você pode especificar não apenas a capacidade limitada, mas também o tipo de coleção a ser usado.When you create a BlockingCollection<T> object, you can specify not only the bounded capacity but also the type of collection to use. Por exemplo, seria possível especificar um objeto ConcurrentQueue<T> para o comportamento primeiro a entrar, primeiro a sair (PEPS) ou um objeto ConcurrentStack<T> para último a entrar, primeiro a sair (UEPS).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. Você pode usar qualquer classe de coleção que implemente a interface IProducerConsumerCollection<T>.You can use any collection class that implements the IProducerConsumerCollection<T> interface. O tipo de coleção padrão para BlockingCollection<T> é ConcurrentQueue<T>.The default collection type for BlockingCollection<T> is ConcurrentQueue<T>.

Não modifique a coleção subjacente diretamente.Do not modify the underlying collection directly. Use os métodos BlockingCollection<T> para adicionar ou remover elementos.Use BlockingCollection<T> methods to add or remove elements. O objeto BlockingCollection<T> poderá ser corrompido se você alterar diretamente a coleção subjacente.The BlockingCollection<T> object can become corrupted if you change the underlying collection directly.

Construtores

BlockingCollection<T>()

Inicializa uma nova instância da classe BlockingCollection<T> sem um limite superior.Initializes a new instance of the BlockingCollection<T> class without an upper-bound.

BlockingCollection<T>(Int32)

Inicializa uma nova instância da classe BlockingCollection<T> com o limite superior especificado.Initializes a new instance of the BlockingCollection<T> class with the specified upper-bound.

BlockingCollection<T>(IProducerConsumerCollection<T>)

Inicializa uma nova instância da classe BlockingCollection<T> sem um limite superior e usando a IProducerConsumerCollection<T> fornecida como seu armazenamento de dados subjacente.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)

Inicializa uma nova instância da classe BlockingCollection<T> com o limite superior especificado e usando a IProducerConsumerCollection<T> fornecida como seu repositório de dados subjacente.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.

Propriedades

BoundedCapacity

Obtém a capacidade limitada dessa instância BlockingCollection<T>.Gets the bounded capacity of this BlockingCollection<T> instance.

Count

Obtém o número de itens contidos no BlockingCollection<T>.Gets the number of items contained in the BlockingCollection<T>.

IsAddingCompleted

Obtém se esta BlockingCollection<T> foi marcada como completa para adição.Gets whether this BlockingCollection<T> has been marked as complete for adding.

IsCompleted

Obtém se esta BlockingCollection<T> foi marcada como completa para a adição e está vazia.Gets whether this BlockingCollection<T> has been marked as complete for adding and is empty.

Métodos

Add(T)

Adiciona o item ao BlockingCollection<T>.Adds the item to the BlockingCollection<T>.

Add(T, CancellationToken)

Adiciona o item ao BlockingCollection<T>.Adds the item to the BlockingCollection<T>.

AddToAny(BlockingCollection<T>[], T)

Adiciona o item especificado a qualquer uma das instâncias de BlockingCollection<T> especificadas.Adds the specified item to any one of the specified BlockingCollection<T> instances.

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

Adiciona o item especificado a qualquer uma das instâncias de BlockingCollection<T> especificadas.Adds the specified item to any one of the specified BlockingCollection<T> instances.

CompleteAdding()

Marca que as instâncias de BlockingCollection<T> não estão mais aceitando nenhuma adição.Marks the BlockingCollection<T> instances as not accepting any more additions.

CopyTo(T[], Int32)

Copia todos os itens da instância BlockingCollection<T> para uma matriz unidimensional compatível, iniciando no índice especificado da matriz de destino.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()

Libera todos os recursos usados pela instância atual da classe BlockingCollection<T>.Releases all resources used by the current instance of the BlockingCollection<T> class.

Dispose(Boolean)

Libera os recursos usados pela instância BlockingCollection<T>.Releases resources used by the BlockingCollection<T> instance.

Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

(Herdado de Object)
GetConsumingEnumerable()

Fornece um consumindo IEnumerator<T> para itens na coleção.Provides a consuming IEnumerator<T> for items in the collection.

GetConsumingEnumerable(CancellationToken)

Fornece um consumindo IEnumerable<T> para itens na coleção.Provides a consuming IEnumerable<T> for items in the collection.

GetHashCode()

Serve como a função de hash padrão.Serves as the default hash function.

(Herdado de Object)
GetType()

Obtém o Type da instância atual.Gets the Type of the current instance.

(Herdado de Object)
MemberwiseClone()

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

(Herdado de Object)
Take()

Remove um item do BlockingCollection<T>.Removes an item from the BlockingCollection<T>.

Take(CancellationToken)

Remove um item do BlockingCollection<T>.Removes an item from the BlockingCollection<T>.

TakeFromAny(BlockingCollection<T>[], T)

Toma um item de qualquer uma das instâncias BlockingCollection<T> especificadas.Takes an item from any one of the specified BlockingCollection<T> instances.

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

Recebe um item de qualquer uma das instâncias BlockingCollection<T> especificadas, observando ao mesmo tempo o token de cancelamento especificado.Takes an item from any one of the specified BlockingCollection<T> instances while observing the specified cancellation token.

ToArray()

Copia os itens da instância BlockingCollection<T> em uma nova matriz.Copies the items from the BlockingCollection<T> instance into a new array.

ToString()

Retorna uma cadeia de caracteres que representa o objeto atual.Returns a string that represents the current object.

(Herdado de Object)
TryAdd(T)

Tenta adicionar o item especificado ao BlockingCollection<T>.Tries to add the specified item to the BlockingCollection<T>.

TryAdd(T, Int32)

Tenta adicionar o item especificado à BlockingCollection<T> dentro do período de tempo especificado.Tries to add the specified item to the BlockingCollection<T> within the specified time period.

TryAdd(T, Int32, CancellationToken)

Tenta adicionar o item especificado ao BlockingCollection<T> no período especificado, enquanto observa um token de cancelamento.Tries to add the specified item to the BlockingCollection<T> within the specified time period, while observing a cancellation token.

TryAdd(T, TimeSpan)

Tenta adicionar o item especificado ao BlockingCollection<T>.Tries to add the specified item to the BlockingCollection<T>.

TryAddToAny(BlockingCollection<T>[], T)

Tenta adicionar o item especificado a qualquer uma das instâncias BlockingCollection<T> especificadas.Tries to add the specified item to any one of the specified BlockingCollection<T> instances.

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

Tenta adicionar o item especificado a qualquer uma das instâncias BlockingCollection<T> especificadas.Tries to add the specified item to any one of the specified BlockingCollection<T> instances.

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

Tenta adicionar o item especificado a qualquer uma das instâncias BlockingCollection<T> especificadas.Tries to add the specified item to any one of the specified BlockingCollection<T> instances.

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

Tenta adicionar o item especificado a qualquer uma das instâncias BlockingCollection<T> especificadas, observando ao mesmo tempo o token de cancelamento especificado.Tries to add the specified item to any one of the specified BlockingCollection<T> instances while observing the specified cancellation token.

TryTake(T)

Tenta remover um item no BlockingCollection<T>.Tries to remove an item from the BlockingCollection<T>.

TryTake(T, Int32)

Tenta remover um item do BlockingCollection<T> no período de tempo especificado.Tries to remove an item from the BlockingCollection<T> in the specified time period.

TryTake(T, Int32, CancellationToken)

Tenta remover um item do BlockingCollection<T> no período especificado, enquanto observa um token de cancelamento.Tries to remove an item from the BlockingCollection<T> in the specified time period while observing a cancellation token.

TryTake(T, TimeSpan)

Tenta remover um item do BlockingCollection<T> no período de tempo especificado.Tries to remove an item from the BlockingCollection<T> in the specified time period.

TryTakeFromAny(BlockingCollection<T>[], T)

Tenta remover um item de qualquer uma das instâncias BlockingCollection<T> especificadas.Tries to remove an item from any one of the specified BlockingCollection<T> instances.

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

Tenta remover um item de qualquer uma das instâncias BlockingCollection<T> especificadas.Tries to remove an item from any one of the specified BlockingCollection<T> instances.

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

Tenta remover um item de qualquer uma das instâncias BlockingCollection<T> especificadas.Tries to remove an item from any one of the specified BlockingCollection<T> instances.

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

Tenta remover um item de qualquer uma das instâncias BlockingCollection<T> especificadas.Tries to remove an item from any one of the specified BlockingCollection<T> instances.

Implantações explícitas de interface

ICollection.CopyTo(Array, Int32)

Copia todos os itens da instância BlockingCollection<T> para uma matriz unidimensional compatível, iniciando no índice especificado da matriz de destino.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

Obtém um valor que indica se o acesso à ICollection é sincronizado (thread-safe).Gets a value indicating whether access to the ICollection is synchronized (thread safe).

ICollection.SyncRoot

Obtém um objeto que pode ser usado para sincronizar o acesso ao ICollection.Gets an object that can be used to synchronize access to the ICollection. Não há suporte a esta propriedade.This property is not supported.

IEnumerable.GetEnumerator()

Fornece um IEnumerator para itens na coleção.Provides an IEnumerator for items in the collection.

IEnumerable<T>.GetEnumerator()

Fornece um IEnumerator<T> para itens na coleção.Provides an IEnumerator<T> for items in the collection.

Métodos de Extensão

CopyToDataTable<T>(IEnumerable<T>)

Retorna um DataTable que contém cópias dos objetos DataRow, dado um objeto IEnumerable<T> de entrada em que o parâmetro genérico T é 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)

Copia objetos DataRow no DataTable especificado, dado um objeto IEnumerable<T> de entrada em que o parâmetro genérico T é 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)

Copia objetos DataRow no DataTable especificado, dado um objeto IEnumerable<T> de entrada em que o parâmetro genérico T é DataRow.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

Cast<TResult>(IEnumerable)

Converte os elementos de um IEnumerable para o tipo especificado.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtra os elementos de um IEnumerable com base em um tipo especificado.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Habilita a paralelização de uma consulta.Enables parallelization of a query.

AsQueryable(IEnumerable)

Converte um IEnumerable em um IQueryable.Converts an IEnumerable to an IQueryable.

Ancestors<T>(IEnumerable<T>)

Retorna uma coleção de elementos que contém os ancestrais de cada nó na coleção de origem.Returns a collection of elements that contains the ancestors of every node in the source collection.

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

Retorna uma coleção filtrada de elementos que contém os ancestrais de cada nó na coleção de origem.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Somente os elementos que têm um XName correspondente são incluídos na coleção.Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>)

Retorna uma coleção dos nós descendentes de todos os documentos e elementos na coleção de origem.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>)

Retorna uma coleção de elementos que contém os elementos descendentes de cada elemento e o documento na coleção de origem.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

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

Retorna uma coleção filtrada de elementos que contém os elementos descendentes de cada elemento e o documento na coleção de origem.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Somente os elementos que têm um XName correspondente são incluídos na coleção.Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>)

Retorna uma coleção dos filhos elementos de cada elemento e o documento na coleção de origem.Returns a collection of the child elements of every element and document in the source collection.

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

Retorna uma coleção filtrada dos elementos filho de cada elemento e documento na coleção de origem.Returns a filtered collection of the child elements of every element and document in the source collection. Somente os elementos que têm um XName correspondente são incluídos na coleção.Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>)

Retorna uma coleção de nós que contém todos os nós na coleção de origem, classificados em ordem segundo o documento.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>)

Retorna uma coleção dos nós filhos de todos os documentos e elementos na coleção de origem.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>)

Remove todos os nós na coleção de origem do respectivo nó pai.Removes every node in the source collection from its parent node.

Aplica-se a

Acesso thread-safe

O método Dispose não é thread-safe.The Dispose method is not thread-safe. Todos os outros membros públicos e protegidos do BlockingCollection<T> são thread-safe e podem ser usados simultaneamente de vários threads.All other public and protected members of BlockingCollection<T> are thread-safe and may be used concurrently from multiple threads.

Veja também