BlockingCollection<T>.GetConsumingEnumerable Método

Definición

Espacio de nombres:

System.Collections.Concurrent

Ensamblado:

System.Collections.Concurrent.dll

Proporciona una interfaz IEnumerable<T> en uso para los elementos de la colección.

Sobrecargas

GetConsumingEnumerable(CancellationToken)	Proporciona una interfaz IEnumerable<T> en uso para los elementos de la colección.
GetConsumingEnumerable()	Proporciona una interfaz IEnumerable<T> en uso para los elementos de la colección.

GetConsumingEnumerable(CancellationToken)

Source:

BlockingCollection.cs

Proporciona una interfaz IEnumerable<T> en uso para los elementos de la colección.

public:
 System::Collections::Generic::IEnumerable<T> ^ GetConsumingEnumerable(System::Threading::CancellationToken cancellationToken);

public System.Collections.Generic.IEnumerable<T> GetConsumingEnumerable (System.Threading.CancellationToken cancellationToken);

member this.GetConsumingEnumerable : System.Threading.CancellationToken -> seq<'T>

Public Function GetConsumingEnumerable (cancellationToken As CancellationToken) As IEnumerable(Of T)

Parámetros

cancellationToken

CancellationToken

Token de cancelación que se va a observar.

Devoluciones

IEnumerable<T>

IEnumerable<T> que quita y devuelve elementos de la colección.

Excepciones

OperationCanceledException

CancellationToken se cancela.

ObjectDisposedException

BlockingCollection<T> ha sido eliminado o CancellationTokenSource que creó cancellationToken ha sido eliminado.

Comentarios

Este método permite que el código de cliente quite elementos de la colección mediante un bucle foreach (For Each en Visual Basic) o Parallel.ForEach una consulta PLINQ. El enumerador seguirá proporcionando elementos (si existe) hasta IsCompleted que devuelva true y, si IsCompleted es false, el bucle se bloquea hasta que un elemento esté disponible o hasta CancellationToken que se cancele.

Consulte también

• Colecciones seguras para subprocesos
• Información general sobre BlockingCollection

GetConsumingEnumerable()

Source:

BlockingCollection.cs

Proporciona una interfaz IEnumerable<T> en uso para los elementos de la colección.

public:
 System::Collections::Generic::IEnumerable<T> ^ GetConsumingEnumerable();

public System.Collections.Generic.IEnumerable<T> GetConsumingEnumerable ();

member this.GetConsumingEnumerable : unit -> seq<'T>

Public Function GetConsumingEnumerable () As IEnumerable(Of T)

Devoluciones

IEnumerable<T>

IEnumerable<T> que quita y devuelve elementos de la colección.

Excepciones

ObjectDisposedException

Se ha eliminado BlockingCollection<T>.

Ejemplos

En el siguiente ejemplo, se muestra cómo utilizar el método GetConsumingEnumerable:

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
            var producerTask = Task.Run(async () =>
            {
                for (int i = 0; i < 10; i++)
                {
                    bc.Add(i);
                    Console.WriteLine($"Producing: {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($"Consuming: {item}");
            }
            await producerTask; // Allow task to complete cleanup
        }
    }
}

module ConsumingEnumerableDemo =
    // Demonstrates:
    //      BlockingCollection<T>.Add()
    //      BlockingCollection<T>.CompleteAdding()
    //      BlockingCollection<T>.GetConsumingEnumerable()
    let blockingCollectionGetConsumingEnumerable () =
        task {
            use bc = new BlockingCollection<int>()
            // Kick off a producer task
            let producerTask =
                task {
                    for i = 0 to 9 do
                        bc.Add i
                        printfn $"Producing: {i}"

                        do! 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.
            for item in bc.GetConsumingEnumerable() do
                printfn $"Consuming: {item}"
            do! producerTask // Allow task to complete cleanup
        }

'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

Consulte también

• Colecciones seguras para subprocesos
• Información general sobre BlockingCollection