BlockingCollection<T> Klasse

Definition

Namespace:

System.Collections.Concurrent

Assembly:

System.Collections.Concurrent.dll

Quelle:

BlockingCollection.cs

Stellt Blockierungs- und Begrenzungsfunktionen für threadsichere Auflistungen bereit, die IProducerConsumerCollection<T>implementieren.

generic <typename T>
public ref class BlockingCollection : IDisposable, System::Collections::Generic::IEnumerable<T>, System::Collections::Generic::IReadOnlyCollection<T>, System::Collections::ICollection

[System.Runtime.Versioning.UnsupportedOSPlatform("browser")]
public class BlockingCollection<T> : IDisposable, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.ICollection

[<System.Runtime.Versioning.UnsupportedOSPlatform("browser")>]
type BlockingCollection<'T> = class
    interface seq<'T>
    interface IEnumerable
    interface IReadOnlyCollection<'T>
    interface ICollection
    interface IDisposable

Public Class BlockingCollection(Of T)
Implements ICollection, IDisposable, IEnumerable(Of T), IReadOnlyCollection(Of T)

Typparameter

T

Der Typ der Elemente in der Auflistung.

Vererbung

Object

BlockingCollection<T>

Attribute

UnsupportedOSPlatformAttribute

Implementiert

IEnumerable<T> IReadOnlyCollection<T> ICollection IEnumerable IDisposable

Beispiele

Das folgende Beispiel zeigt, wie Elemente gleichzeitig aus einer blockierungssammlung hinzugefügt und verwendet werden:

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
            Task t1 = Task.Run(() =>
            {
                bc.Add(1);
                bc.Add(2);
                bc.Add(3);
                bc.CompleteAdding();
            });

            // Spin up a Task to consume the BlockingCollection
            Task t2 = Task.Run(() =>
            {
                try
                {
                    // 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
            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
        }
    }
}

open System
open System.Collections.Concurrent
open System.Threading
open System.Threading.Tasks

module AddTakeDemo =
    // Demonstrates:
    //      BlockingCollection<T>.Add()
    //      BlockingCollection<T>.Take()
    //      BlockingCollection<T>.CompleteAdding()
    let blockingCollectionAddTakeCompleteAdding () =
        task {
            use bc = new BlockingCollection<int>()
            // Spin up a Task to populate the BlockingCollection
            let t1 = 
                task {
                    bc.Add 1
                    bc.Add 2
                    bc.Add 3
                    bc.CompleteAdding()
                }

            // Spin up a Task to consume the BlockingCollection
            let t2 = 
                task {
                    try
                        // Consume consume the BlockingCollection
                        while true do 
                            printfn $"{bc.Take()}"
                    with :? InvalidOperationException ->
                        // An InvalidOperationException means that Take() was called on a completed collection
                        printfn "That's All!"
                }
            let! _ = Task.WhenAll(t1, t2)
            ()
        }

module TryTakeDemo =
    // Demonstrates:
    //      BlockingCollection<T>.Add()
    //      BlockingCollection<T>.CompleteAdding()
    //      BlockingCollection<T>.TryTake()
    //      BlockingCollection<T>.IsCompleted
    let blockingCollectionTryTake () =
        // Construct and fill our BlockingCollection
        use bc = new BlockingCollection<int>()
        let NUMITEMS = 10000;
        for i = 0 to NUMITEMS - 1 do
            bc.Add i
        bc.CompleteAdding()
        let mutable outerSum = 0

        // Delegate for consuming the BlockingCollection and adding up all items
        let action = 
            Action(fun () ->
                let mutable localItem = 0
                let mutable localSum = 0

                while bc.TryTake &localItem do
                    localSum <- localSum + localItem
                Interlocked.Add(&outerSum, localSum)
                |> ignore)

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

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

module FromToAnyDemo =
    // Demonstrates:
    //      Bounded BlockingCollection<T>
    //      BlockingCollection<T>.TryAddToAny()
    //      BlockingCollection<T>.TryTakeFromAny()
    let blockingCollectionFromToAny () =
        let bcs = 
            [|
                new BlockingCollection<int>(5) // collection bounded to 5 items
                new BlockingCollection<int>(5) // collection bounded to 5 items
             |]
        // Should be able to add 10 items w/o blocking
        let mutable numFailures = 0;
        for i = 0 to 9 do
            if BlockingCollection<int>.TryAddToAny(bcs, i) = -1 then
                numFailures <- numFailures + 1
        printfn $"TryAddToAny: {numFailures} failures (should be 0)"

        // Should be able to retrieve 10 items
        let mutable numItems = 0
        let mutable item = 0
        while BlockingCollection<int>.TryTakeFromAny(bcs, &item) <> -1 do
            numItems <- numItems + 1
        printfn $"TryTakeFromAny: retrieved {numItems} items (should be 10)"

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
        }

let main =
    task {
        do! AddTakeDemo.blockingCollectionAddTakeCompleteAdding ()
        TryTakeDemo.blockingCollectionTryTake ()
        FromToAnyDemo.blockingCollectionFromToAny ()
        do! ConsumingEnumerableDemo.blockingCollectionGetConsumingEnumerable ()
        printfn "Press any key to exit."
        Console.ReadKey(true) |> ignore
    }
main.Wait()

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

Hinweise

BlockingCollection<T> ist eine threadsichere Sammlungsklasse, die Folgendes bereitstellt:

• Umsetzung des Erzeuger-/Verbrauchermusters; BlockingCollection<T> ist ein Wrapper für die IProducerConsumerCollection<T> Schnittstelle.

• Gleichzeitiges Hinzufügen und Entfernen von Elementen aus mehreren Threads mit den Methoden Add und Take.

• Eine gebundene Auflistung, die Add- und Take Vorgänge blockiert, wenn die Auflistung voll oder leer ist.

• Abbruch von Add- oder Take Vorgängen mithilfe eines CancellationToken Objekts in der TryAdd- oder TryTake-Methode.

Wichtig

Dieser Typ implementiert die IDisposable Schnittstelle. Wenn Sie die Verwendung des Typs abgeschlossen haben, sollten Sie ihn entweder direkt oder indirekt verwerfen. Rufen Sie zum direkten Löschen des Typs die Dispose-Methode in einem try/catch-Block auf. Verwenden Sie zum indirekten Löschen ein Sprachkonstrukt wie using (in C#) oder Using (in Visual Basic). Weitere Informationen finden Sie im Abschnitt "Verwenden eines Objekts, das IDisposable implementiert", im Thema zur IDisposable Schnittstelle. Beachten Sie außerdem, dass die Dispose()-Methode nicht threadsicher ist. Alle anderen öffentlichen und geschützten Member von BlockingCollection<T> sind threadsicher und können gleichzeitig aus mehreren Threads verwendet werden.

IProducerConsumerCollection<T> stellt eine Auflistung dar, die das threadsichere Hinzufügen und Entfernen von Daten ermöglicht. BlockingCollection<T> wird als Wrapper für eine IProducerConsumerCollection<T> Instanz verwendet und ermöglicht es, Entfernungsversuche aus der Auflistung zu blockieren, bis Daten entfernt werden können. Ebenso können Sie eine BlockingCollection<T> erstellen, um eine obere Grenze für die Anzahl der in der IProducerConsumerCollection<T>zulässigen Datenelemente zu erzwingen; Zusätzlichsversuche zur Sammlung können dann blockiert werden, bis speicherplatz verfügbar ist, um die hinzugefügten Elemente zu speichern. Auf diese Weise ähnelt BlockingCollection<T> einer herkömmlichen Blockierungswarteschlangendatenstruktur, mit der Ausnahme, dass der zugrunde liegende Datenspeichermechanismus als IProducerConsumerCollection<T>abstrahiert wird.

BlockingCollection<T> unterstützt Begrenzung und Blockierung. Begrenzung bedeutet, dass Sie die maximale Kapazität der Sammlung festlegen können. Die Begrenzung ist in bestimmten Szenarien wichtig, da sie es Ihnen ermöglicht, die maximale Größe der Sammlung im Arbeitsspeicher zu steuern, und sie verhindert, dass die produzierenden Threads zu weit vor den verbrauchten Threads verschoben werden. Mehrere Threads oder Aufgaben können der Auflistung gleichzeitig Elemente hinzufügen und wenn die Sammlung die angegebene maximale Kapazität erreicht, werden die produzierenden Threads blockiert, bis ein Element entfernt wird. Mehrere Consumer können Elemente gleichzeitig entfernen, und wenn die Sammlung leer wird, werden die verbrauchten Threads blockiert, bis ein Produzent ein Element hinzufügt. Ein produzierendes Thread kann die CompleteAdding-Methode aufrufen, um anzugeben, dass keine weiteren Elemente hinzugefügt werden. Verbraucher überwachen die IsCompleted Eigenschaft, um zu wissen, wann die Sammlung leer ist und keine weiteren Elemente hinzugefügt werden.

Add- und Take-Vorgänge werden in der Regel in einer Schleife ausgeführt. Sie können eine Schleife abbrechen, indem Sie ein CancellationToken-Objekt an die TryAdd- oder TryTake-Methode übergeben und dann den Wert der IsCancellationRequested Eigenschaft des Tokens für jede Iteration überprüfen. Wenn der Wert trueist, liegt es an Ihnen, die Abbruchanforderung zu beantworten, indem Sie Ressourcen bereinigen und die Schleife beenden.

Wenn Sie ein BlockingCollection<T>-Objekt erstellen, können Sie nicht nur die begrenzungsgebundene Kapazität, sondern auch den typ der zu verwendenden Auflistung angeben. Sie können z. B. ein ConcurrentQueue<T>-Objekt für das erste In-, First-Out-Verhalten (FIFO) oder ein ConcurrentStack<T>-Objekt für das verhalten "first in" (First Out, LIFO) angeben. Sie können jede Sammlungsklasse verwenden, die die IProducerConsumerCollection<T> Schnittstelle implementiert. Der Standardsammlungstyp für BlockingCollection<T> ist ConcurrentQueue<T>.

Ändern Sie die zugrunde liegende Auflistung nicht direkt. Verwenden Sie BlockingCollection<T> Methoden, um Elemente hinzuzufügen oder zu entfernen. Das BlockingCollection<T>-Objekt kann beschädigt werden, wenn Sie die zugrunde liegende Auflistung direkt ändern.

BlockingCollection<T> wurde nicht mit asynchronen Zugriffen entworfen. Wenn Ihre Anwendung asynchrone Produzenten-/Verbraucherszenarien erfordert, sollten Sie stattdessen Channel<T> verwenden.

Konstruktoren

BlockingCollection<T>()	Initialisiert eine neue Instanz der BlockingCollection<T> Klasse ohne obere Grenze.
BlockingCollection<T>(Int32)	Initialisiert eine neue Instanz der BlockingCollection<T> Klasse mit der angegebenen oberen Grenze.
BlockingCollection<T>(IProducerConsumerCollection<T>)	Initialisiert eine neue Instanz der BlockingCollection<T>-Klasse ohne eine obere Grenze und verwendet die bereitgestellte IProducerConsumerCollection<T> als zugrunde liegenden Datenspeicher.
BlockingCollection<T>(IProducerConsumerCollection<T>, Int32)	Initialisiert eine neue Instanz der BlockingCollection<T> Klasse mit der angegebenen oberen Grenze und verwendet die bereitgestellte IProducerConsumerCollection<T> als zugrunde liegenden Datenspeicher.

Eigenschaften

BoundedCapacity	Ruft die begrenzungsgebundene Kapazität dieser BlockingCollection<T> Instanz ab.
Count	Ruft die Anzahl der Elemente ab, die in der BlockingCollection<T>enthalten sind.
IsAddingCompleted	Ruft ab, ob diese BlockingCollection<T> zum Hinzufügen als abgeschlossen markiert wurde.
IsCompleted	Ruft ab, ob diese BlockingCollection<T> zum Hinzufügen als abgeschlossen markiert wurde und leer ist.

Methoden

Add(T)	Fügt das Element zum BlockingCollection<T>hinzu.
Add(T, CancellationToken)	Fügt das Element zum BlockingCollection<T>hinzu.
AddToAny(BlockingCollection<T>[], T)	Fügt das angegebene Element zu einer der angegebenen BlockingCollection<T> Instanzen hinzu.
AddToAny(BlockingCollection<T>[], T, CancellationToken)	Fügt das angegebene Element zu einer der angegebenen BlockingCollection<T> Instanzen hinzu.
CompleteAdding()	Markiert die BlockingCollection<T> Instanzen als keine weiteren Ergänzungen.
CopyTo(T[], Int32)	Kopiert alle Elemente in der BlockingCollection<T> Instanz in ein kompatibles eindimensionales Array, beginnend am angegebenen Index des Zielarrays.
Dispose()	Gibt alle Ressourcen frei, die von der aktuellen Instanz der BlockingCollection<T> Klasse verwendet werden.
Dispose(Boolean)	Veröffentlicht Ressourcen, die von der BlockingCollection<T> Instanz verwendet werden.
Equals(Object)	Bestimmt, ob das angegebene Objekt dem aktuellen Objekt entspricht. (Geerbt von Object)
GetConsumingEnumerable()	Stellt eine verbrauchende IEnumerable<T> für Elemente in der Auflistung bereit.
GetConsumingEnumerable(CancellationToken)	Stellt eine verbrauchende IEnumerable<T> für Elemente in der Auflistung bereit.
GetHashCode()	Dient als Standardhashfunktion. (Geerbt von Object)
GetType()	Ruft die Type der aktuellen Instanz ab. (Geerbt von Object)
MemberwiseClone()	Erstellt eine flache Kopie der aktuellen Object. (Geerbt von Object)
Take()	Entfernt ein Element aus dem BlockingCollection<T>.
Take(CancellationToken)	Entfernt ein Element aus dem BlockingCollection<T>.
TakeFromAny(BlockingCollection<T>[], T)	Übernimmt ein Element aus einer der angegebenen BlockingCollection<T> Instanzen.
TakeFromAny(BlockingCollection<T>[], T, CancellationToken)	Übernimmt ein Element aus einer der angegebenen BlockingCollection<T> Instanzen, während das angegebene Abbruchtoken beobachtet wird.
ToArray()	Kopiert die Elemente aus der BlockingCollection<T> Instanz in ein neues Array.
ToString()	Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt. (Geerbt von Object)
TryAdd(T)	Versucht, das angegebene Element zum BlockingCollection<T>hinzuzufügen.
TryAdd(T, Int32)	Versucht, das angegebene Element innerhalb des angegebenen Zeitraums dem BlockingCollection<T> hinzuzufügen.
TryAdd(T, Int32, CancellationToken)	Versucht, das angegebene Element innerhalb des angegebenen Zeitraums dem BlockingCollection<T> hinzuzufügen, während ein Abbruchtoken beobachtet wird.
TryAdd(T, TimeSpan)	Versucht, das angegebene Element zum BlockingCollection<T>hinzuzufügen.
TryAddToAny(BlockingCollection<T>[], T)	Versucht, das angegebene Element zu einer der angegebenen BlockingCollection<T> Instanzen hinzuzufügen.
TryAddToAny(BlockingCollection<T>[], T, Int32)	Versucht, das angegebene Element zu einer der angegebenen BlockingCollection<T> Instanzen hinzuzufügen.
TryAddToAny(BlockingCollection<T>[], T, Int32, CancellationToken)	Versucht, das angegebene Element zu einer der angegebenen BlockingCollection<T> Instanzen hinzuzufügen.
TryAddToAny(BlockingCollection<T>[], T, TimeSpan)	Versucht, das angegebene Element zu einer der angegebenen BlockingCollection<T> Instanzen hinzuzufügen, während das angegebene Abbruchtoken beobachtet wird.
TryTake(T)	Versucht, ein Element aus dem BlockingCollection<T>zu entfernen.
TryTake(T, Int32)	Versucht, ein Element aus dem BlockingCollection<T> im angegebenen Zeitraum zu entfernen.
TryTake(T, Int32, CancellationToken)	Versucht, ein Element aus dem BlockingCollection<T> im angegebenen Zeitraum zu entfernen, während ein Abbruchtoken beobachtet wird.
TryTake(T, TimeSpan)	Versucht, ein Element aus dem BlockingCollection<T> im angegebenen Zeitraum zu entfernen.
TryTakeFromAny(BlockingCollection<T>[], T)	Versucht, ein Element aus einer der angegebenen BlockingCollection<T> Instanzen zu entfernen.
TryTakeFromAny(BlockingCollection<T>[], T, Int32)	Versucht, ein Element aus einer der angegebenen BlockingCollection<T> Instanzen zu entfernen.
TryTakeFromAny(BlockingCollection<T>[], T, Int32, CancellationToken)	Versucht, ein Element aus einer der angegebenen BlockingCollection<T> Instanzen zu entfernen.
TryTakeFromAny(BlockingCollection<T>[], T, TimeSpan)	Versucht, ein Element aus einer der angegebenen BlockingCollection<T> Instanzen zu entfernen.

Explizite Schnittstellenimplementierungen

ICollection.CopyTo(Array, Int32)	Kopiert alle Elemente in der BlockingCollection<T> Instanz in ein kompatibles eindimensionales Array, beginnend am angegebenen Index des Zielarrays.
ICollection.IsSynchronized	Ruft einen Wert ab, der angibt, ob der Zugriff auf die ICollection synchronisiert wird (Threadsicher).
ICollection.SyncRoot	Ruft ein Objekt ab, das zum Synchronisieren des Zugriffs auf die ICollectionverwendet werden kann. Diese Eigenschaft wird nicht unterstützt.
IEnumerable.GetEnumerator()	Stellt eine IEnumerator für Elemente in der Auflistung bereit.
IEnumerable<T>.GetEnumerator()	Stellt eine IEnumerator<T> für Elemente in der Auflistung bereit.

Erweiterungsmethoden

ToFrozenDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Erstellt eine FrozenDictionary<TKey,TValue> aus einer IEnumerable<T> entsprechend der angegebenen Tastenauswahlfunktion.
ToFrozenDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Erstellt eine FrozenDictionary<TKey,TValue> aus einer IEnumerable<T> gemäß den angegebenen Schlüsselauswahl- und Elementauswahlfunktionen.
ToFrozenSet<T>(IEnumerable<T>, IEqualityComparer<T>)	Erstellt eine FrozenSet<T> mit den angegebenen Werten.
ToImmutableArray<TSource>(IEnumerable<TSource>)	Erstellt ein unveränderliches Array aus der angegebenen Auflistung.
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Erstellt ein unveränderliches Wörterbuch aus einer vorhandenen Auflistung von Elementen, wobei eine Transformationsfunktion auf die Quellschlüssel angewendet wird.
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Erstellt ein unveränderliches Wörterbuch basierend auf einer Transformation einer Sequenz.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)	Enumeiert und transformiert eine Sequenz und erzeugt ein unveränderliches Wörterbuch seiner Inhalte.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>)	Enumeiert und transformiert eine Sequenz und erzeugt ein unveränderliches Wörterbuch seiner Inhalte mithilfe des angegebenen Schlüsselabgleichs.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>)	Enumeiert und transformiert eine Sequenz und erzeugt ein unveränderliches Wörterbuch seiner Inhalte mithilfe des angegebenen Schlüssel- und Wertabgleichs.
ToImmutableHashSet<TSource>(IEnumerable<TSource>)	Listet eine Sequenz auf und erzeugt einen unveränderlichen Hashsatz seiner Inhalte.
ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Listet eine Sequenz auf, erzeugt einen unveränderlichen Hashsatz seines Inhalts und verwendet den angegebenen Gleichheitsabgleich für den Settyp.
ToImmutableList<TSource>(IEnumerable<TSource>)	Listet eine Sequenz auf und erzeugt eine unveränderliche Liste seiner Inhalte.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)	Enumeiert und transformiert eine Sequenz und erzeugt ein unveränderliches sortiertes Wörterbuch seiner Inhalte.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>)	Enumeiert und transformiert eine Sequenz und erzeugt ein unveränderliches sortiertes Wörterbuch seiner Inhalte mithilfe des angegebenen Schlüsselabgleichs.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>, IEqualityComparer<TValue>)	Enumeiert und transformiert eine Sequenz und erzeugt ein unveränderliches sortiertes Wörterbuch seiner Inhalte mithilfe des angegebenen Schlüssel- und Wertabgleichs.
ToImmutableSortedSet<TSource>(IEnumerable<TSource>)	Listet eine Sequenz auf und erzeugt einen unveränderlichen sortierten Satz seiner Inhalte.
ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>)	Listet eine Sequenz auf, erzeugt einen unveränderlichen sortierten Satz seines Inhalts und verwendet den angegebenen Vergleich.
CopyToDataTable<T>(IEnumerable<T>)	Gibt einen DataTable zurück, der Kopien der DataRow -Objekte enthält, vorausgesetzt, ein Eingabeobjekt IEnumerable<T>, bei dem der generische Parameter TDataRowist.
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)	Kopiert DataRow Objekte in den angegebenen DataTable, wenn ein Eingabeobjekt IEnumerable<T> objekt, wobei der generische Parameter TDataRowist.
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)	Kopiert DataRow Objekte in den angegebenen DataTable, wenn ein Eingabeobjekt IEnumerable<T> objekt, wobei der generische Parameter TDataRowist.
Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>)	Wendet eine Akkumulatorfunktion auf eine Sequenz an.
Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>)	Wendet eine Akkumulatorfunktion auf eine Sequenz an. Der angegebene Ausgangswert wird als anfänglicher Akkumulatorwert verwendet.
Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>)	Wendet eine Akkumulatorfunktion auf eine Sequenz an. Der angegebene Ausgangswert wird als anfänglicher Akkumulatorwert verwendet, und die angegebene Funktion wird verwendet, um den Ergebniswert auszuwählen.
All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Bestimmt, ob alle Elemente einer Sequenz eine Bedingung erfüllen.
Any<TSource>(IEnumerable<TSource>)	Bestimmt, ob eine Sequenz Elemente enthält.
Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Bestimmt, ob ein Element einer Sequenz eine Bedingung erfüllt.
Append<TSource>(IEnumerable<TSource>, TSource)	Fügt einen Wert an das Ende der Sequenz an.
AsEnumerable<TSource>(IEnumerable<TSource>)	Gibt die eingegebene Eingabe als IEnumerable<T>zurück.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Berechnet den Mittelwert einer Sequenz von Decimal Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Berechnet den Mittelwert einer Sequenz von Double Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Berechnet den Mittelwert einer Sequenz von Int32 Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Berechnet den Mittelwert einer Sequenz von Int64 Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Berechnet den Mittelwert einer Sequenz nullabler Decimal Werte, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Berechnet den Mittelwert einer Sequenz nullabler Double Werte, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Berechnet den Mittelwert einer Sequenz nullabler Int32 Werte, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Berechnet den Mittelwert einer Sequenz nullabler Int64 Werte, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Berechnet den Mittelwert einer Sequenz nullabler Single Werte, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Berechnet den Mittelwert einer Sequenz von Single Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.
Cast<TResult>(IEnumerable)	Wandelt die Elemente eines IEnumerable in den angegebenen Typ um.
Chunk<TSource>(IEnumerable<TSource>, Int32)	Teilt die Elemente einer Sequenz in Teile der Größe auf, die höchstens size.
Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Verkettet zwei Sequenzen.
Contains<TSource>(IEnumerable<TSource>, TSource)	Bestimmt, ob eine Sequenz ein angegebenes Element mithilfe des Standardmäßigen Gleichheitsabgleichs enthält.
Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>)	Bestimmt, ob eine Sequenz ein angegebenes Element enthält, indem ein angegebenes IEqualityComparer<T>verwendet wird.
Count<TSource>(IEnumerable<TSource>)	Gibt die Anzahl der Elemente in einer Sequenz zurück.
Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Gibt eine Zahl zurück, die angibt, wie viele Elemente in der angegebenen Sequenz eine Bedingung erfüllen.
DefaultIfEmpty<TSource>(IEnumerable<TSource>)	Gibt die Elemente der angegebenen Sequenz oder des Standardwerts des Typparameters in einer Singleton -Auflistung zurück, wenn die Sequenz leer ist.
DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource)	Gibt die Elemente der angegebenen Sequenz oder den angegebenen Wert in einer Singleton -Auflistung zurück, wenn die Sequenz leer ist.
Distinct<TSource>(IEnumerable<TSource>)	Gibt unterschiedliche Elemente aus einer Sequenz zurück, indem der Standardgleichstellungsabgleich verwendet wird, um Werte zu vergleichen.
Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Gibt unterschiedliche Elemente aus einer Sequenz zurück, indem ein angegebenes IEqualityComparer<T> zum Vergleichen von Werten verwendet wird.
DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Gibt unterschiedliche Elemente aus einer Sequenz gemäß einer angegebenen Schlüsselauswahlfunktion zurück.
DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Gibt unterschiedliche Elemente aus einer Sequenz gemäß einer angegebenen Schlüsselmarkierfunktion zurück und verwendet einen angegebenen Vergleich zum Vergleichen von Tasten.
ElementAt<TSource>(IEnumerable<TSource>, Index)	Gibt das Element an einem angegebenen Index in einer Sequenz zurück.
ElementAt<TSource>(IEnumerable<TSource>, Int32)	Gibt das Element an einem angegebenen Index in einer Sequenz zurück.
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Index)	Gibt das Element an einem angegebenen Index in einer Sequenz oder einem Standardwert zurück, wenn der Index außerhalb des Bereichs liegt.
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32)	Gibt das Element an einem angegebenen Index in einer Sequenz oder einem Standardwert zurück, wenn der Index außerhalb des Bereichs liegt.
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Erzeugt den Satzunterschied von zwei Sequenzen mithilfe des Standardgleichgleichsabgleichs zum Vergleichen von Werten.
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Erzeugt den Satzunterschied zweier Sequenzen mithilfe der angegebenen IEqualityComparer<T> zum Vergleichen von Werten.
ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>)	Erzeugt den Satzunterschied von zwei Sequenzen gemäß einer angegebenen Schlüsselmarkierfunktion.
ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Erzeugt den Satzunterschied von zwei Sequenzen gemäß einer angegebenen Schlüsselmarkierfunktion.
First<TSource>(IEnumerable<TSource>)	Gibt das erste Element einer Sequenz zurück.
First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Gibt das erste Element in einer Sequenz zurück, das eine angegebene Bedingung erfüllt.
FirstOrDefault<TSource>(IEnumerable<TSource>)	Gibt das erste Element einer Sequenz oder einen Standardwert zurück, wenn die Sequenz keine Elemente enthält.
FirstOrDefault<TSource>(IEnumerable<TSource>, TSource)	Gibt das erste Element einer Sequenz oder einen angegebenen Standardwert zurück, wenn die Sequenz keine Elemente enthält.
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Gibt das erste Element der Sequenz zurück, das eine Bedingung oder einen Standardwert erfüllt, wenn kein solches Element gefunden wird.
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)	Gibt das erste Element der Sequenz zurück, das eine Bedingung erfüllt, oder einen angegebenen Standardwert, wenn kein solches Element gefunden wird.
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion.
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion und vergleicht die Tasten mithilfe eines angegebenen Vergleichs.
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion und projiziert die Elemente für jede Gruppe mithilfe einer angegebenen Funktion.
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Gruppiert die Elemente einer Sequenz entsprechend einer Tastenauswahlfunktion. Die Schlüssel werden mithilfe eines Vergleichs verglichen, und die Elemente jeder Gruppe werden mithilfe einer angegebenen Funktion projiziert.
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>)	Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselmarkierfunktion und erstellt einen Ergebniswert aus jeder Gruppe und dem zugehörigen Schlüssel.
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>)	Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselmarkierfunktion und erstellt einen Ergebniswert aus jeder Gruppe und dem zugehörigen Schlüssel. Die Schlüssel werden mithilfe eines angegebenen Vergleichs verglichen.
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>)	Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselmarkierfunktion und erstellt einen Ergebniswert aus jeder Gruppe und dem zugehörigen Schlüssel. Die Elemente jeder Gruppe werden mithilfe einer angegebenen Funktion projiziert.
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>)	Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselmarkierfunktion und erstellt einen Ergebniswert aus jeder Gruppe und dem zugehörigen Schlüssel. Schlüsselwerte werden mithilfe eines angegebenen Vergleichs verglichen, und die Elemente jeder Gruppe werden mithilfe einer angegebenen Funktion projiziert.
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>)	Korreliert die Elemente zweier Sequenzen basierend auf der Gleichheit von Schlüsseln und gruppiert die Ergebnisse. Der Standardmäßige Gleichheitsvergleich wird zum Vergleichen von Schlüsseln verwendet.
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>)	Korreliert die Elemente zweier Sequenzen basierend auf schlüsselgleicher Gleichheit und gruppiert die Ergebnisse. Ein angegebenes IEqualityComparer<T> wird zum Vergleichen von Schlüsseln verwendet.
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Erzeugt die festgelegte Schnittmenge von zwei Sequenzen mithilfe des Standardgleichgleichsabgleichs zum Vergleichen von Werten.
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Erzeugt die festgelegte Schnittmenge von zwei Sequenzen mithilfe der angegebenen IEqualityComparer<T> zum Vergleichen von Werten.
IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>)	Erzeugt die festgelegte Schnittmenge von zwei Sequenzen gemäß einer angegebenen Schlüsselmarkierfunktion.
IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Erzeugt die festgelegte Schnittmenge von zwei Sequenzen gemäß einer angegebenen Schlüsselmarkierfunktion.
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>)	Korreliert die Elemente zweier Sequenzen basierend auf übereinstimmenden Schlüsseln. Der Standardmäßige Gleichheitsvergleich wird zum Vergleichen von Schlüsseln verwendet.
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>)	Korreliert die Elemente zweier Sequenzen basierend auf übereinstimmenden Schlüsseln. Ein angegebenes IEqualityComparer<T> wird zum Vergleichen von Schlüsseln verwendet.
Last<TSource>(IEnumerable<TSource>)	Gibt das letzte Element einer Sequenz zurück.
Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Gibt das letzte Element einer Sequenz zurück, das eine angegebene Bedingung erfüllt.
LastOrDefault<TSource>(IEnumerable<TSource>)	Gibt das letzte Element einer Sequenz oder einen Standardwert zurück, wenn die Sequenz keine Elemente enthält.
LastOrDefault<TSource>(IEnumerable<TSource>, TSource)	Gibt das letzte Element einer Sequenz oder einen angegebenen Standardwert zurück, wenn die Sequenz keine Elemente enthält.
LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Gibt das letzte Element einer Sequenz zurück, das eine Bedingung oder einen Standardwert erfüllt, wenn kein solches Element gefunden wird.
LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)	Gibt das letzte Element einer Sequenz zurück, das eine Bedingung erfüllt, oder einen angegebenen Standardwert, wenn kein solches Element gefunden wird.
LongCount<TSource>(IEnumerable<TSource>)	Gibt einen Int64 zurück, der die Gesamtanzahl der Elemente in einer Sequenz darstellt.
LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Gibt einen Int64 zurück, der angibt, wie viele Elemente in einer Sequenz eine Bedingung erfüllen.
Max<TSource>(IEnumerable<TSource>)	Gibt den Maximalwert in einer generischen Sequenz zurück.
Max<TSource>(IEnumerable<TSource>, IComparer<TSource>)	Gibt den Maximalwert in einer generischen Sequenz zurück.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den maximalen Decimal Wert zurück.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den maximalen Double Wert zurück.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den maximalen Int32 Wert zurück.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den maximalen Int64 Wert zurück.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den maximal nullfähigen Decimal Wert zurück.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den maximal nullfähigen Double Wert zurück.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den maximal nullfähigen Int32 Wert zurück.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den maximal nullfähigen Int64 Wert zurück.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den maximal nullfähigen Single Wert zurück.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den maximalen Single Wert zurück.
Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Ruft eine Transformationsfunktion für jedes Element einer generischen Sequenz auf und gibt den maximal resultierenden Wert zurück.
MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Gibt den Maximalwert in einer generischen Sequenz gemäß einer angegebenen Schlüsselmarkierfunktion zurück.
MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Gibt den Maximalwert in einer generischen Sequenz gemäß einer angegebenen Schlüsselmarkierfunktion und einem Schlüsselabgleich zurück.
Min<TSource>(IEnumerable<TSource>)	Gibt den Minimalwert in einer generischen Sequenz zurück.
Min<TSource>(IEnumerable<TSource>, IComparer<TSource>)	Gibt den Minimalwert in einer generischen Sequenz zurück.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den minimalen Decimal Wert zurück.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den minimalen Double Wert zurück.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den minimalen Int32 Wert zurück.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den minimalen Int64 Wert zurück.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den minimal nullfähigen Decimal Wert zurück.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den minimal nullfähigen Double Wert zurück.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den minimal nullfähigen Int32 Wert zurück.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den minimal nullfähigen Int64 Wert zurück.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den minimal nullfähigen Single Wert zurück.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Ruft eine Transformationsfunktion für jedes Element einer Sequenz auf und gibt den minimalen Single Wert zurück.
Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Ruft eine Transformationsfunktion für jedes Element einer generischen Sequenz auf und gibt den minimalen resultierenden Wert zurück.
MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Gibt den Minimalwert in einer generischen Sequenz gemäß einer angegebenen Schlüsselmarkierfunktion zurück.
MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Gibt den Minimalwert in einer generischen Sequenz gemäß einer angegebenen Schlüsselauswahlfunktion und einem Schlüsselabgleich zurück.
OfType<TResult>(IEnumerable)	Filtert die Elemente einer IEnumerable basierend auf einem angegebenen Typ.
Order<T>(IEnumerable<T>)	Sortiert die Elemente einer Sequenz in aufsteigender Reihenfolge.
Order<T>(IEnumerable<T>, IComparer<T>)	Sortiert die Elemente einer Sequenz in aufsteigender Reihenfolge.
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Sortiert die Elemente einer Sequenz in aufsteigender Reihenfolge nach einem Schlüssel.
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Sortiert die Elemente einer Sequenz in aufsteigender Reihenfolge mithilfe eines angegebenen Vergleichs.
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Sortiert die Elemente einer Sequenz in absteigender Reihenfolge nach einem Schlüssel.
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Sortiert die Elemente einer Sequenz in absteigender Reihenfolge mithilfe eines angegebenen Vergleichs.
OrderDescending<T>(IEnumerable<T>)	Sortiert die Elemente einer Sequenz in absteigender Reihenfolge.
OrderDescending<T>(IEnumerable<T>, IComparer<T>)	Sortiert die Elemente einer Sequenz in absteigender Reihenfolge.
Prepend<TSource>(IEnumerable<TSource>, TSource)	Fügt am Anfang der Sequenz einen Wert hinzu.
Reverse<TSource>(IEnumerable<TSource>)	Invertiert die Reihenfolge der Elemente in einer Sequenz.
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Projiziert jedes Element einer Sequenz in ein neues Formular.
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>)	Projiziert jedes Element einer Sequenz in ein neues Formular, indem er den Index des Elements einbezieht.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>)	Projiziert jedes Element einer Sequenz auf eine IEnumerable<T> und vereinfacht die resultierenden Sequenzen in eine Sequenz.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)	Projiziert jedes Element einer Sequenz auf eine IEnumerable<T>und schmeichelt die resultierenden Sequenzen in einer Sequenz ab. Der Index der einzelnen Quellelemente wird in der projizierten Form dieses Elements verwendet.
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)	Projiziert jedes Element einer Sequenz auf eine IEnumerable<T>, schmeichelt die resultierenden Sequenzen in eine Sequenz und ruft eine Ergebnismarkierfunktion für jedes element darin auf.
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)	Projiziert jedes Element einer Sequenz auf eine IEnumerable<T>, schmeichelt die resultierenden Sequenzen in eine Sequenz und ruft eine Ergebnismarkierfunktion für jedes element darin auf. Der Index der einzelnen Quellelemente wird in der zwischen projizierten Form dieses Elements verwendet.
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Bestimmt, ob zwei Sequenzen gleich sind, indem die Elemente mithilfe des Standardmäßigen Gleichheitsabgleichs für ihren Typ verglichen werden.
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Bestimmt, ob zwei Sequenzen gleich sind, indem sie ihre Elemente mithilfe einer angegebenen IEqualityComparer<T>vergleichen.
Single<TSource>(IEnumerable<TSource>)	Gibt das einzige Element einer Sequenz zurück und löst eine Ausnahme aus, wenn nicht genau ein Element in der Sequenz vorhanden ist.
Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Gibt das einzige Element einer Sequenz zurück, das eine angegebene Bedingung erfüllt, und löst eine Ausnahme aus, wenn mehr als ein solches Element vorhanden ist.
SingleOrDefault<TSource>(IEnumerable<TSource>)	Gibt das einzige Element einer Sequenz oder einen Standardwert zurück, wenn die Sequenz leer ist; Diese Methode löst eine Ausnahme aus, wenn mehrere Elemente in der Sequenz vorhanden sind.
SingleOrDefault<TSource>(IEnumerable<TSource>, TSource)	Gibt das einzige Element einer Sequenz oder einen angegebenen Standardwert zurück, wenn die Sequenz leer ist; Diese Methode löst eine Ausnahme aus, wenn mehrere Elemente in der Sequenz vorhanden sind.
SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Gibt das einzige Element einer Sequenz zurück, das eine angegebene Bedingung oder einen Standardwert erfüllt, wenn kein solches Element vorhanden ist; Diese Methode löst eine Ausnahme aus, wenn mehrere Elemente die Bedingung erfüllen.
SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)	Gibt das einzige Element einer Sequenz zurück, das eine angegebene Bedingung erfüllt, oder einen angegebenen Standardwert, wenn kein solches Element vorhanden ist; Diese Methode löst eine Ausnahme aus, wenn mehrere Elemente die Bedingung erfüllen.
Skip<TSource>(IEnumerable<TSource>, Int32)	Umgeht eine angegebene Anzahl von Elementen in einer Sequenz und gibt dann die verbleibenden Elemente zurück.
SkipLast<TSource>(IEnumerable<TSource>, Int32)	Gibt eine neue aufzählbare Auflistung zurück, die die Elemente aus source enthält, wobei die letzten count Elemente der Quellauflistung weggelassen werden.
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Umgeht Elemente in einer Sequenz, solange eine angegebene Bedingung wahr ist, und gibt dann die verbleibenden Elemente zurück.
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Umgeht Elemente in einer Sequenz, solange eine angegebene Bedingung wahr ist, und gibt dann die verbleibenden Elemente zurück. Der Index des Elements wird in der Logik der Prädikatfunktion verwendet.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Berechnet die Summe der Sequenz von Decimal Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Berechnet die Summe der Sequenz von Double Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Berechnet die Summe der Sequenz von Int32 Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Berechnet die Summe der Sequenz von Int64 Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Berechnet die Summe der Sequenz von nullablen Decimal Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Berechnet die Summe der Sequenz von nullablen Double Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Berechnet die Summe der Sequenz von nullablen Int32 Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Berechnet die Summe der Sequenz von nullablen Int64 Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Berechnet die Summe der Sequenz von nullablen Single Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Berechnet die Summe der Sequenz von Single Werten, die durch Aufrufen einer Transformationsfunktion für jedes Element der Eingabesequenz abgerufen werden.
Take<TSource>(IEnumerable<TSource>, Int32)	Gibt eine angegebene Anzahl zusammenhängender Elemente vom Anfang einer Sequenz zurück.
Take<TSource>(IEnumerable<TSource>, Range)	Gibt einen angegebenen Bereich zusammenhängender Elemente aus einer Sequenz zurück.
TakeLast<TSource>(IEnumerable<TSource>, Int32)	Gibt eine neue enumerationsfähige Auflistung zurück, die die letzten count Elemente aus sourceenthält.
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Gibt Elemente aus einer Sequenz zurück, solange eine angegebene Bedingung wahr ist.
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Gibt Elemente aus einer Sequenz zurück, solange eine angegebene Bedingung wahr ist. Der Index des Elements wird in der Logik der Prädikatfunktion verwendet.
ToArray<TSource>(IEnumerable<TSource>)	Erstellt ein Array aus einem IEnumerable<T>.
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Erstellt eine Dictionary<TKey,TValue> aus einer IEnumerable<T> gemäß einer angegebenen Schlüsselauswahlfunktion.
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Erstellt eine Dictionary<TKey,TValue> aus einer IEnumerable<T> gemäß einer angegebenen Schlüsselauswahlfunktion und einem Schlüsselvergleich.
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Erstellt eine Dictionary<TKey,TValue> aus einer IEnumerable<T> gemäß den angegebenen Schlüsselauswahl- und Elementauswahlfunktionen.
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Erstellt eine Dictionary<TKey,TValue> aus einer IEnumerable<T> gemäß einer angegebenen Schlüsselauswahlfunktion, einem Vergleichsmodul und einer Elementauswahlfunktion.
ToHashSet<TSource>(IEnumerable<TSource>)	Erstellt eine HashSet<T> aus einem IEnumerable<T>.
ToHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Erstellt mithilfe des comparer zum Vergleichen von Schlüsseln eine HashSet<T> aus einem IEnumerable<T>.
ToList<TSource>(IEnumerable<TSource>)	Erstellt eine List<T> aus einem IEnumerable<T>.
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Erstellt eine Lookup<TKey,TElement> aus einer IEnumerable<T> gemäß einer angegebenen Schlüsselauswahlfunktion.
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Erstellt eine Lookup<TKey,TElement> aus einer IEnumerable<T> gemäß einer angegebenen Schlüsselauswahlfunktion und einem Schlüsselvergleich.
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Erstellt eine Lookup<TKey,TElement> aus einer IEnumerable<T> gemäß den angegebenen Schlüsselauswahl- und Elementauswahlfunktionen.
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Erstellt eine Lookup<TKey,TElement> aus einer IEnumerable<T> gemäß einer angegebenen Schlüsselauswahlfunktion, einem Vergleichsmodul und einer Elementauswahlfunktion.
TryGetNonEnumeratedCount<TSource>(IEnumerable<TSource>, Int32)	Versucht, die Anzahl der Elemente in einer Sequenz zu ermitteln, ohne eine Enumeration zu erzwingen.
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Erzeugt die Festgelegte Vereinigung von zwei Sequenzen mithilfe des Standardgleichstellungsabgleichs.
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Erzeugt die Set-Vereinigung von zwei Sequenzen mithilfe eines angegebenen IEqualityComparer<T>.
UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>)	Erzeugt die Set-Vereinigung von zwei Sequenzen gemäß einer angegebenen Schlüsselmarkierfunktion.
UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Erzeugt die Set-Vereinigung von zwei Sequenzen gemäß einer angegebenen Schlüsselmarkierfunktion.
Where<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Filtert eine Abfolge von Werten basierend auf einem Prädikat.
Where<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Filtert eine Abfolge von Werten basierend auf einem Prädikat. Der Index jedes Elements wird in der Logik der Prädikatfunktion verwendet.
Zip<TFirst,TSecond>(IEnumerable<TFirst>, IEnumerable<TSecond>)	Erzeugt eine Abfolge von Tupeln mit Elementen aus den beiden angegebenen Sequenzen.
Zip<TFirst,TSecond,TThird>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>)	Erzeugt eine Abfolge von Tupeln mit Elementen aus den drei angegebenen Sequenzen.
Zip<TFirst,TSecond,TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>)	Wendet eine angegebene Funktion auf die entsprechenden Elemente von zwei Sequenzen an, wodurch eine Folge der Ergebnisse erzeugt wird.
AsParallel(IEnumerable)	Aktiviert die Parallelisierung einer Abfrage.
AsParallel<TSource>(IEnumerable<TSource>)	Aktiviert die Parallelisierung einer Abfrage.
AsQueryable(IEnumerable)	Wandelt eine IEnumerable in eine IQueryableum.
AsQueryable<TElement>(IEnumerable<TElement>)	Wandelt eine generische IEnumerable<T> in eine generische IQueryable<T>um.
Ancestors<T>(IEnumerable<T>)	Gibt eine Auflistung von Elementen zurück, die die Vorgänger aller Knoten in der Quellauflistung enthalten.
Ancestors<T>(IEnumerable<T>, XName)	Gibt eine gefilterte Auflistung von Elementen zurück, die die Vorgänger aller Knoten in der Quellauflistung enthalten. In der Auflistung sind nur Elemente enthalten, die über einen übereinstimmenden XName verfügen.
DescendantNodes<T>(IEnumerable<T>)	Gibt eine Auflistung der untergeordneten Knoten jedes Dokuments und Elements in der Quellauflistung zurück.
Descendants<T>(IEnumerable<T>)	Gibt eine Auflistung von Elementen zurück, die die untergeordneten Elemente jedes Elements und Dokuments in der Quellauflistung enthalten.
Descendants<T>(IEnumerable<T>, XName)	Gibt eine gefilterte Auflistung von Elementen zurück, die die untergeordneten Elemente jedes Elements und Dokuments in der Quellauflistung enthalten. In der Auflistung sind nur Elemente enthalten, die über einen übereinstimmenden XName verfügen.
Elements<T>(IEnumerable<T>)	Gibt eine Auflistung der untergeordneten Elemente jedes Elements und Dokuments in der Quellauflistung zurück.
Elements<T>(IEnumerable<T>, XName)	Gibt eine gefilterte Auflistung der untergeordneten Elemente jedes Elements und Dokuments in der Quellauflistung zurück. In der Auflistung sind nur Elemente enthalten, die über einen übereinstimmenden XName verfügen.
InDocumentOrder<T>(IEnumerable<T>)	Gibt eine Auflistung von Knoten zurück, die alle Knoten in der Quellauflistung enthält, sortiert in der Dokumentreihenfolge.
Nodes<T>(IEnumerable<T>)	Gibt eine Auflistung der untergeordneten Knoten jedes Dokuments und Elements in der Quellauflistung zurück.
Remove<T>(IEnumerable<T>)	Entfernt jeden Knoten in der Quellauflistung aus dem übergeordneten Knoten.

Threadsicherheit

Die Dispose-Methode ist nicht threadsicher. Alle anderen öffentlichen und geschützten Member von BlockingCollection<T> sind threadsicher und können gleichzeitig aus mehreren Threads verwendet werden.

Weitere Informationen

• Thread-Safe Sammlungen
• BlockingCollection Overview
• How to: Add Bounding and Blocking Functionality to a Collection Class