BlockingCollection<T>.GetConsumingEnumerable Methode

Definition

Namespace:

System.Collections.Concurrent

Assembly:

System.Collections.Concurrent.dll

Stellt ein verwendetes IEnumerable<T> für Elemente in der Auflistung bereit.

Überlädt

GetConsumingEnumerable(CancellationToken)	Stellt ein verwendetes IEnumerable<T> für Elemente in der Auflistung bereit.
GetConsumingEnumerable()	Stellt ein verwendetes IEnumerable<T> für Elemente in der Auflistung bereit.

GetConsumingEnumerable(CancellationToken)

Quelle:

BlockingCollection.cs

Stellt ein verwendetes IEnumerable<T> für Elemente in der Auflistung bereit.

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)

Parameter

cancellationToken

CancellationToken

Ein Abbruchtoken, das überwacht werden soll.

Gibt zurück

IEnumerable<T>

Ein IEnumerable<T>, das Elemente aus der Auflistung entfernt und zurückgibt.

Ausnahmen

OperationCanceledException

Das CancellationToken wird abgebrochen.

ObjectDisposedException

Die BlockingCollection<T> wurde freigegeben, oder die CancellationTokenSource, die cancellationToken erstellt hat, wurde freigegeben.

Hinweise

Diese Methode ermöglicht Clientcode das Entfernen von Elementen aus der Auflistung mithilfe einer foreach-Schleife (For Each in Visual Basic) oder Parallel.ForEach einer PLINQ-Abfrage. Der Enumerator stellt weiterhin Elemente bereit (sofern vorhanden), bis IsCompleted true zurückgegeben wird, und wenn IsCompleted false ist, blockiert die Schleife, bis ein Element verfügbar ist oder bis die CancellationToken abgebrochen wird.

Weitere Informationen

• Threadsichere Sammlungen
• Übersicht über BlockingCollection

GetConsumingEnumerable()

Quelle:

BlockingCollection.cs

Stellt ein verwendetes IEnumerable<T> für Elemente in der Auflistung bereit.

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)

Gibt zurück

IEnumerable<T>

Ein IEnumerable<T>, das Elemente aus der Auflistung entfernt und zurückgibt.

Ausnahmen

ObjectDisposedException

BlockingCollection<T> wurde verworfen.

Beispiele

Das folgende Beispiel zeigt die Verwendung der GetConsumingEnumerable -Methode:

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

Weitere Informationen

• Threadsichere Sammlungen
• Übersicht über BlockingCollection