BlockingCollection<T> Klasa

Definicja

Przestrzeń nazw:

System.Collections.Concurrent

Zestaw:

System.Collections.Concurrent.dll

Źródło:

BlockingCollection.cs

Zapewnia możliwości blokowania i ograniczenia dla kolekcji bezpiecznych wątkowo, które implementują element 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.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)

Parametry typu

T

Typ elementów w kolekcji.

Dziedziczenie

Object

BlockingCollection<T>

Atrybuty

UnsupportedOSPlatformAttribute

Implementuje

IEnumerable<T> IReadOnlyCollection<T> ICollection IEnumerable IDisposable

Przykłady

W poniższym przykładzie pokazano, jak dodawać i pobierać elementy jednocześnie z kolekcji blokującej:

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

Uwagi

BlockingCollection<T> to klasa kolekcji bezpieczna wątkowo, która udostępnia następujące elementy:

• Implementacja wzorca producenta/konsumenta; BlockingCollection<T> to otoka interfejsu IProducerConsumerCollection<T> .

• Równoczesne dodawanie i usuwanie elementów z wielu wątków za Add pomocą metod i Take .

• Powiązana kolekcja, która blokuje Add i Take wykonuje operacje, gdy kolekcja jest pełna lub pusta.

• Add Anulowanie operacji lub Take przy użyciu CancellationToken obiektu w metodzie TryAdd lub TryTake .

Ważne

Ten typ implementuje IDisposable interfejs. Po zakończeniu korzystania z typu należy usunąć go bezpośrednio lub pośrednio. Aby bezpośrednio usunąć typ, wywołaj jego Dispose metodę try/catch w bloku. Aby usunąć go pośrednio, użyj konstrukcji języka, takiej jak using (w języku C#) lub Using (w Visual Basic). Aby uzyskać więcej informacji, zobacz sekcję "Using an Object that Implements IDisposable" (Używanie obiektu implementujące interfejs IDisposable) w temacie interfejsu IDisposable . Należy również pamiętać, że Dispose() metoda nie jest bezpieczna wątkowo. Wszystkie inne publiczne i chronione elementy członkowskie są BlockingCollection<T> bezpieczne wątkowo i mogą być używane współbieżnie z wielu wątków.

IProducerConsumerCollection<T> reprezentuje kolekcję, która umożliwia bezpieczne wątkowo dodawanie i usuwanie danych. BlockingCollection<T> jest używany jako otoka dla IProducerConsumerCollection<T> wystąpienia i umożliwia próby usunięcia z kolekcji, aby zablokować, dopóki dane nie będą dostępne do usunięcia. Podobnie można utworzyć element , BlockingCollection<T> aby wymusić górną granicę liczby elementów danych dozwolonych w elemecie IProducerConsumerCollection<T>; próby dodania do kolekcji mogą następnie blokować, dopóki miejsce nie będzie dostępne do przechowywania dodanych elementów. W ten sposób BlockingCollection<T> jest podobny do tradycyjnej struktury danych kolejki blokującej, z tą różnicą, że podstawowy mechanizm magazynu danych jest abstrahowany jako IProducerConsumerCollection<T>.

BlockingCollection<T> obsługuje ograniczenia i blokowanie. Ograniczenie oznacza, że można ustawić maksymalną pojemność kolekcji. Ograniczenie jest ważne w niektórych scenariuszach, ponieważ umożliwia kontrolowanie maksymalnego rozmiaru kolekcji w pamięci i uniemożliwia tworzenie wątków zbyt daleko przed zużyciem wątków. Wiele wątków lub zadań może jednocześnie dodawać elementy do kolekcji, a jeśli kolekcja osiągnie określoną maksymalną pojemność, wątki produkujące będą blokowane do momentu usunięcia elementu. Wielu odbiorców może jednocześnie usuwać elementy, a jeśli kolekcja stanie się pusta, wątki zużywające będą blokowane do momentu, gdy producent doda element. Wątek tworzący może wywołać metodę CompleteAdding , aby wskazać, że nie zostaną dodane żadne elementy. Konsumenci monitorują IsCompleted właściwość, aby wiedzieć, kiedy kolekcja jest pusta i nie zostaną dodane żadne elementy.

Add operacje i Take są zwykle wykonywane w pętli. Pętlę można anulować, przekazując CancellationToken obiekt do TryAdd metody lub TryTake , a następnie sprawdzając wartość właściwości tokenu IsCancellationRequested w każdej iteracji. Jeśli wartość to true, odpowiadasz na żądanie anulowania, czyszcząc wszelkie zasoby i zamykając pętlę.

Podczas tworzenia BlockingCollection<T> obiektu można określić nie tylko ograniczoną pojemność, ale także typ kolekcji do użycia. Można na przykład określić ConcurrentQueue<T> obiekt dla pierwszego w, pierwszy na wyjście (FIFO) zachowanie lub obiekt dla ostatniego ConcurrentStack<T> in, pierwszy na out (LIFO) zachowanie. Można użyć dowolnej klasy kolekcji, która implementuje IProducerConsumerCollection<T> interfejs. Domyślnym typem kolekcji dla elementu BlockingCollection<T> jest ConcurrentQueue<T>.

Nie należy bezpośrednio modyfikować podstawowej kolekcji. Używanie BlockingCollection<T> metod do dodawania lub usuwania elementów. Obiekt BlockingCollection<T> może ulec uszkodzeniu, jeśli bezpośrednio zmienisz podstawową kolekcję.

BlockingCollection<T> nie został zaprojektowany z myślą o dostępie asynchronicznym. Jeśli aplikacja wymaga scenariuszy asynchronicznych producentów/konsumentów, rozważ użycie zamiast tego Channel<T> .

Konstruktory

BlockingCollection<T>()	Inicjuje BlockingCollection<T> nowe wystąpienie klasy bez górnej granicy.
BlockingCollection<T>(Int32)	Inicjuje BlockingCollection<T> nowe wystąpienie klasy z określoną górną granicą.
BlockingCollection<T>(IProducerConsumerCollection<T>)	Inicjuje BlockingCollection<T> nowe wystąpienie klasy bez górnej granicy i używa podanego IProducerConsumerCollection<T> jako podstawowego magazynu danych.
BlockingCollection<T>(IProducerConsumerCollection<T>, Int32)	Inicjuje BlockingCollection<T> nowe wystąpienie klasy o określonej górnej granicy i używa podanego IProducerConsumerCollection<T> jako podstawowego magazynu danych.

Właściwości

BoundedCapacity	Pobiera powiązaną pojemność tego BlockingCollection<T> wystąpienia.
Count	Pobiera liczbę elementów zawartych w elemecie BlockingCollection<T>.
IsAddingCompleted	Pobiera, czy zostało to BlockingCollection<T> oznaczone jako ukończone do dodania.
IsCompleted	Pobiera, czy ta BlockingCollection<T> funkcja została oznaczona jako ukończona do dodawania i jest pusta.

Metody

Add(T)	Dodaje element do elementu BlockingCollection<T>.
Add(T, CancellationToken)	Dodaje element do elementu BlockingCollection<T>.
AddToAny(BlockingCollection<T>[], T)	Dodaje określony element do dowolnego z określonych BlockingCollection<T> wystąpień.
AddToAny(BlockingCollection<T>[], T, CancellationToken)	Dodaje określony element do dowolnego z określonych BlockingCollection<T> wystąpień.
CompleteAdding()	BlockingCollection<T> Oznacza wystąpienia jako nieakceptowanie dodatkowych dodatków.
CopyTo(T[], Int32)	Kopiuje wszystkie elementy w wystąpieniu BlockingCollection<T> do zgodnej tablicy jednowymiarowej, zaczynając od określonego indeksu tablicy docelowej.
Dispose()	Zwalnia wszystkie zasoby używane przez bieżące wystąpienie klasy BlockingCollection<T>.
Dispose(Boolean)	Zwalnia zasoby używane przez BlockingCollection<T> wystąpienie.
Equals(Object)	Określa, czy dany obiekt jest taki sam, jak bieżący obiekt. (Odziedziczone po Object)
GetConsumingEnumerable()	Zapewnia użycie IEnumerable<T> elementów w kolekcji.
GetConsumingEnumerable(CancellationToken)	Zapewnia użycie IEnumerable<T> elementów w kolekcji.
GetHashCode()	Służy jako domyślna funkcja skrótu. (Odziedziczone po Object)
GetType()	Type Pobiera wartość bieżącego wystąpienia. (Odziedziczone po Object)
MemberwiseClone()	Tworzy płytkią kopię bieżącego Objectelementu . (Odziedziczone po Object)
Take()	Usuwa element z elementu BlockingCollection<T>.
Take(CancellationToken)	Usuwa element z elementu BlockingCollection<T>.
TakeFromAny(BlockingCollection<T>[], T)	Pobiera element z dowolnego z określonych BlockingCollection<T> wystąpień.
TakeFromAny(BlockingCollection<T>[], T, CancellationToken)	Pobiera element z dowolnego z określonych BlockingCollection<T> wystąpień podczas obserwowania określonego tokenu anulowania.
ToArray()	Kopiuje elementy z BlockingCollection<T> wystąpienia do nowej tablicy.
ToString()	Zwraca ciąg reprezentujący bieżący obiekt. (Odziedziczone po Object)
TryAdd(T)	Próbuje dodać określony element do elementu BlockingCollection<T>.
TryAdd(T, Int32)	Próbuje dodać określony element do określonego BlockingCollection<T> okresu.
TryAdd(T, Int32, CancellationToken)	Próbuje dodać określony element do określonego BlockingCollection<T> okresu, obserwując token anulowania.
TryAdd(T, TimeSpan)	Próbuje dodać określony element do elementu BlockingCollection<T>.
TryAddToAny(BlockingCollection<T>[], T)	Próbuje dodać określony element do dowolnego z określonych BlockingCollection<T> wystąpień.
TryAddToAny(BlockingCollection<T>[], T, Int32)	Próbuje dodać określony element do dowolnego z określonych BlockingCollection<T> wystąpień.
TryAddToAny(BlockingCollection<T>[], T, Int32, CancellationToken)	Próbuje dodać określony element do dowolnego z określonych BlockingCollection<T> wystąpień.
TryAddToAny(BlockingCollection<T>[], T, TimeSpan)	Próbuje dodać określony element do dowolnego z określonych BlockingCollection<T> wystąpień podczas obserwowania określonego tokenu anulowania.
TryTake(T)	Próbuje usunąć element z elementu BlockingCollection<T>.
TryTake(T, Int32)	Próbuje usunąć element z określonego BlockingCollection<T> okresu.
TryTake(T, Int32, CancellationToken)	Próbuje usunąć element z BlockingCollection<T> określonego okresu podczas obserwowania tokenu anulowania.
TryTake(T, TimeSpan)	Próbuje usunąć element z określonego BlockingCollection<T> okresu.
TryTakeFromAny(BlockingCollection<T>[], T)	Próbuje usunąć element z dowolnego z określonych BlockingCollection<T> wystąpień.
TryTakeFromAny(BlockingCollection<T>[], T, Int32)	Próbuje usunąć element z dowolnego z określonych BlockingCollection<T> wystąpień.
TryTakeFromAny(BlockingCollection<T>[], T, Int32, CancellationToken)	Próbuje usunąć element z dowolnego z określonych BlockingCollection<T> wystąpień.
TryTakeFromAny(BlockingCollection<T>[], T, TimeSpan)	Próbuje usunąć element z dowolnego z określonych BlockingCollection<T> wystąpień.

Jawne implementacje interfejsu

ICollection.CopyTo(Array, Int32)	Kopiuje wszystkie elementy w wystąpieniu BlockingCollection<T> do zgodnej tablicy jednowymiarowej, zaczynając od określonego indeksu tablicy docelowej.
ICollection.IsSynchronized	Pobiera wartość wskazującą, czy dostęp do elementu ICollection jest synchronizowany (bezpieczny wątek).
ICollection.SyncRoot	Pobiera obiekt, który może służyć do synchronizowania dostępu do obiektu ICollection. Ta właściwość nie jest obsługiwana.
IEnumerable.GetEnumerator()	Udostępnia element IEnumerator dla elementów w kolekcji.
IEnumerable<T>.GetEnumerator()	Udostępnia element IEnumerator<T> dla elementów w kolekcji.

Metody rozszerzania

ToFrozenDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Tworzy element FrozenDictionary<TKey,TValue>IEnumerable<T> na podstawie określonej funkcji selektora kluczy.
ToFrozenDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Tworzy element FrozenDictionary<TKey,TValue>IEnumerable<T> na podstawie określonych funkcji selektora kluczy i selektora elementów.
ToFrozenSet<T>(IEnumerable<T>, IEqualityComparer<T>)	Tworzy element FrozenSet<T> z określonymi wartościami.
ToImmutableArray<TSource>(IEnumerable<TSource>)	Tworzy niezmienną tablicę z określonej kolekcji.
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Tworzy niezmienny słownik z istniejącej kolekcji elementów, stosując funkcję przekształcania do kluczy źródłowych.
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Tworzy niezmienny słownik na podstawie pewnej transformacji sekwencji.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)	Wylicza i przekształca sekwencję i tworzy niezmienny słownik jego zawartości.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>)	Wylicza i przekształca sekwencję i tworzy niezmienny słownik jego zawartości przy użyciu określonego modułu porównywania kluczy.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>)	Wylicza i przekształca sekwencję i tworzy niezmienny słownik jego zawartości przy użyciu określonych porównań kluczy i wartości.
ToImmutableHashSet<TSource>(IEnumerable<TSource>)	Wylicza sekwencję i tworzy niezmienny zestaw skrótów jego zawartości.
ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Wylicza sekwencję, tworzy niezmienny zestaw skrótów jego zawartości i używa określonego porównania równości dla typu zestawu.
ToImmutableList<TSource>(IEnumerable<TSource>)	Wylicza sekwencję i tworzy niezmienną listę jego zawartości.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)	Wylicza i przekształca sekwencję i tworzy niezmienny posortowany słownik jego zawartości.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>)	Wylicza i przekształca sekwencję i tworzy niezmienny posortowany słownik jego zawartości przy użyciu określonego modułu porównywania kluczy.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>, IEqualityComparer<TValue>)	Wylicza i przekształca sekwencję i tworzy niezmienny posortowany słownik jego zawartości przy użyciu określonych porównań kluczy i wartości.
ToImmutableSortedSet<TSource>(IEnumerable<TSource>)	Wylicza sekwencję i tworzy niezmienny zestaw posortowany jego zawartości.
ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>)	Wylicza sekwencję, tworzy niezmienny zestaw posortowany jego zawartości i używa określonego porównania.
CopyToDataTable<T>(IEnumerable<T>)	Zwraca element DataTable zawierający kopie DataRow obiektów, biorąc pod uwagę obiekt wejściowy IEnumerable<T> , w którym parametr T ogólny to DataRow.
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)	Kopiuje DataRow obiekty do określonego DataTableobiektu , podanego obiektu wejściowego IEnumerable<T> , w którym parametr T ogólny to DataRow.
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)	Kopiuje DataRow obiekty do określonego DataTableobiektu , podanego obiektu wejściowego IEnumerable<T> , w którym parametr T ogólny to DataRow.
Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>)	Stosuje funkcję akumulatora po sekwencji.
Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>)	Stosuje funkcję akumulatora po sekwencji. Określona wartość nasion jest używana jako początkowa wartość akumulatorowa.
Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>)	Stosuje funkcję akumulatora po sekwencji. Określona wartość inicjowania jest używana jako początkowa wartość akumulatora, a określona funkcja jest używana do wybierania wartości wyniku.
All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Określa, czy wszystkie elementy sekwencji spełniają warunek.
Any<TSource>(IEnumerable<TSource>)	Określa, czy sekwencja zawiera jakiekolwiek elementy.
Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Określa, czy dowolny element sekwencji spełnia warunek.
Append<TSource>(IEnumerable<TSource>, TSource)	Dołącza wartość na końcu sekwencji.
AsEnumerable<TSource>(IEnumerable<TSource>)	Zwraca dane wejściowe wpisane jako IEnumerable<T>.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Oblicza średnią sekwencji Decimal wartości uzyskanych przez wywołanie funkcji transform w każdym elemecie sekwencji danych wejściowych.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Oblicza średnią sekwencji Double wartości uzyskanych przez wywołanie funkcji transform w każdym elemecie sekwencji danych wejściowych.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Oblicza średnią sekwencji Int32 wartości uzyskanych przez wywołanie funkcji transform w każdym elemecie sekwencji danych wejściowych.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Oblicza średnią sekwencji Int64 wartości uzyskanych przez wywołanie funkcji transform w każdym elemecie sekwencji danych wejściowych.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Oblicza średnią sekwencji wartości dopuszczających wartość null uzyskaną Decimal przez wywołanie funkcji transform dla każdego elementu sekwencji danych wejściowych.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Oblicza średnią sekwencji wartości dopuszczających wartość null uzyskaną Double przez wywołanie funkcji transform dla każdego elementu sekwencji danych wejściowych.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Oblicza średnią sekwencji wartości dopuszczających wartość null uzyskaną Int32 przez wywołanie funkcji transform dla każdego elementu sekwencji danych wejściowych.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Oblicza średnią sekwencji wartości dopuszczających wartość null uzyskaną Int64 przez wywołanie funkcji transform dla każdego elementu sekwencji danych wejściowych.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Oblicza średnią sekwencji wartości dopuszczających wartość null uzyskaną Single przez wywołanie funkcji transform dla każdego elementu sekwencji danych wejściowych.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Oblicza średnią sekwencji Single wartości uzyskanych przez wywołanie funkcji transform w każdym elemecie sekwencji danych wejściowych.
Cast<TResult>(IEnumerable)	Rzutuje elementy elementu IEnumerable do określonego typu.
Chunk<TSource>(IEnumerable<TSource>, Int32)	Dzieli elementy sekwencji na fragmenty rozmiaru w większości size.
Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Łączy dwie sekwencje.
Contains<TSource>(IEnumerable<TSource>, TSource)	Określa, czy sekwencja zawiera określony element przy użyciu domyślnego porównywania równości.
Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>)	Określa, czy sekwencja zawiera określony element przy użyciu określonego IEqualityComparer<T>elementu .
Count<TSource>(IEnumerable<TSource>)	Zwraca liczbę elementów w sekwencji.
Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Zwraca liczbę reprezentującą, ile elementów w określonej sekwencji spełnia warunek.
DefaultIfEmpty<TSource>(IEnumerable<TSource>)	Zwraca elementy określonej sekwencji lub wartość domyślną parametru typu w kolekcji pojedynczej, jeśli sekwencja jest pusta.
DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource)	Zwraca elementy określonej sekwencji lub określoną wartość w kolekcji pojedynczej, jeśli sekwencja jest pusta.
Distinct<TSource>(IEnumerable<TSource>)	Zwraca różne elementy z sekwencji przy użyciu domyślnego porównywania równości do porównywania wartości.
Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Zwraca różne elementy z sekwencji przy użyciu określonej wartości IEqualityComparer<T> do porównywania wartości.
DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Zwraca różne elementy z sekwencji zgodnie z określoną funkcją selektora kluczy.
DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Zwraca różne elementy z sekwencji zgodnie z określoną funkcją selektora kluczy i przy użyciu określonego porównania kluczy.
ElementAt<TSource>(IEnumerable<TSource>, Index)	Zwraca element w określonym indeksie w sekwencji.
ElementAt<TSource>(IEnumerable<TSource>, Int32)	Zwraca element w określonym indeksie w sekwencji.
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Index)	Zwraca element w określonym indeksie w sekwencji lub wartość domyślną, jeśli indeks jest poza zakresem.
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32)	Zwraca element w określonym indeksie w sekwencji lub wartość domyślną, jeśli indeks jest poza zakresem.
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Tworzy różnicę zestawu dwóch sekwencji przy użyciu domyślnego porównywania równości do porównywania wartości.
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Tworzy różnicę zestawu dwóch sekwencji przy użyciu określonej wartości IEqualityComparer<T> do porównania wartości.
ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>)	Tworzy różnicę zestawu dwóch sekwencji zgodnie z określoną funkcją selektora kluczy.
ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Tworzy różnicę zestawu dwóch sekwencji zgodnie z określoną funkcją selektora kluczy.
First<TSource>(IEnumerable<TSource>)	Zwraca pierwszy element sekwencji.
First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Zwraca pierwszy element w sekwencji, który spełnia określony warunek.
FirstOrDefault<TSource>(IEnumerable<TSource>)	Zwraca pierwszy element sekwencji lub wartość domyślną, jeśli sekwencja nie zawiera żadnych elementów.
FirstOrDefault<TSource>(IEnumerable<TSource>, TSource)	Zwraca pierwszy element sekwencji lub określoną wartość domyślną, jeśli sekwencja nie zawiera żadnych elementów.
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Zwraca pierwszy element sekwencji, który spełnia warunek lub wartość domyślną, jeśli taki element nie zostanie znaleziony.
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)	Zwraca pierwszy element sekwencji, który spełnia warunek lub określoną wartość domyślną, jeśli taki element nie zostanie znaleziony.
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Grupuje elementy sekwencji zgodnie z określoną funkcją selektora kluczy.
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Grupuje elementy sekwencji zgodnie z określoną funkcją selektora kluczy i porównuje klucze przy użyciu określonego porównania.
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Grupuje elementy sekwencji zgodnie z określoną funkcją selektora kluczy i projektuje elementy dla każdej grupy przy użyciu określonej funkcji.
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Grupuje elementy sekwencji zgodnie z funkcją selektora kluczy. Klucze są porównywane przy użyciu modułu porównania, a elementy każdej grupy są przewidywane przy użyciu określonej funkcji.
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>)	Grupuje elementy sekwencji zgodnie z określoną kluczową funkcją wyboru i tworzy wartość wyniku z każdej grupy i klucza.
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>)	Grupuje elementy sekwencji zgodnie z określoną kluczową funkcją wyboru i tworzy wartość wyniku z każdej grupy i klucza. Klucze są porównywane przy użyciu określonego porównania.
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>)	Grupuje elementy sekwencji zgodnie z określoną kluczową funkcją wyboru i tworzy wartość wyniku z każdej grupy i klucza. Elementy każdej grupy są przewidywane przy użyciu określonej funkcji.
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>)	Grupuje elementy sekwencji zgodnie z określoną kluczową funkcją wyboru i tworzy wartość wyniku z każdej grupy i klucza. Wartości klucza są porównywane przy użyciu określonego porównania, a elementy każdej grupy są przewidywane przy użyciu określonej funkcji.
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>)	Koreluje elementy dwóch sekwencji na podstawie równości kluczy i grupuje wyniki. Domyślny moduł porównywania równości służy do porównywania kluczy.
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>)	Koreluje elementy dwóch sekwencji na podstawie równości klucza i grupuje wyniki. Określony IEqualityComparer<T> jest używany do porównywania kluczy.
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Tworzy przecięcie zestawu dwóch sekwencji przy użyciu domyślnego porównywania równości do porównywania wartości.
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Tworzy przecięcie zestawu dwóch sekwencji przy użyciu określonej wartości IEqualityComparer<T> do porównania wartości.
IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>)	Tworzy przecięcie zestawu dwóch sekwencji zgodnie z określoną funkcją selektora kluczy.
IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Tworzy przecięcie zestawu dwóch sekwencji zgodnie z określoną funkcją selektora kluczy.
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>)	Koreluje elementy dwóch sekwencji na podstawie pasujących kluczy. Domyślny moduł porównywania równości służy do porównywania kluczy.
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>)	Koreluje elementy dwóch sekwencji na podstawie pasujących kluczy. Określony IEqualityComparer<T> jest używany do porównywania kluczy.
Last<TSource>(IEnumerable<TSource>)	Zwraca ostatni element sekwencji.
Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Zwraca ostatni element sekwencji, który spełnia określony warunek.
LastOrDefault<TSource>(IEnumerable<TSource>)	Zwraca ostatni element sekwencji lub wartość domyślną, jeśli sekwencja nie zawiera żadnych elementów.
LastOrDefault<TSource>(IEnumerable<TSource>, TSource)	Zwraca ostatni element sekwencji lub określoną wartość domyślną, jeśli sekwencja nie zawiera żadnych elementów.
LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Zwraca ostatni element sekwencji, który spełnia warunek lub wartość domyślną, jeśli taki element nie zostanie znaleziony.
LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)	Zwraca ostatni element sekwencji, który spełnia warunek lub określoną wartość domyślną, jeśli taki element nie zostanie znaleziony.
LongCount<TSource>(IEnumerable<TSource>)	Zwraca element Int64 reprezentujący całkowitą liczbę elementów w sekwencji.
LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Zwraca element Int64 reprezentujący liczbę elementów w sekwencji spełniających warunek.
Max<TSource>(IEnumerable<TSource>)	Zwraca maksymalną wartość w sekwencji ogólnej.
Max<TSource>(IEnumerable<TSource>, IComparer<TSource>)	Zwraca maksymalną wartość w sekwencji ogólnej.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną Decimal wartość.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną Double wartość.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną Int32 wartość.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną Int64 wartość.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną wartość dopuszczaną Decimal do wartości null.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną wartość dopuszczaną Double do wartości null.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną wartość dopuszczaną Int32 do wartości null.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną wartość dopuszczaną Int64 do wartości null.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną wartość dopuszczaną Single do wartości null.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną Single wartość.
Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Wywołuje funkcję transform dla każdego elementu sekwencji ogólnej i zwraca maksymalną wynikową wartość.
MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Zwraca wartość maksymalną w sekwencji ogólnej zgodnie z określoną funkcją selektora kluczy.
MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Zwraca wartość maksymalną w sekwencji ogólnej zgodnie z określoną funkcją selektora kluczy i modułem porównującym klucz.
Min<TSource>(IEnumerable<TSource>)	Zwraca wartość minimalną w sekwencji ogólnej.
Min<TSource>(IEnumerable<TSource>, IComparer<TSource>)	Zwraca wartość minimalną w sekwencji ogólnej.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca wartość minimalną Decimal .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca wartość minimalną Double .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca wartość minimalną Int32 .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca wartość minimalną Int64 .
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca minimalną wartość dopuszczaną Decimal do wartości null.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca minimalną wartość dopuszczaną Double do wartości null.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca minimalną wartość dopuszczaną Int32 do wartości null.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca minimalną wartość dopuszczaną Int64 do wartości null.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca minimalną wartość dopuszczaną Single do wartości null.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca wartość minimalną Single .
Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Wywołuje funkcję transform dla każdego elementu sekwencji ogólnej i zwraca minimalną wynikową wartość.
MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Zwraca wartość minimalną w sekwencji ogólnej zgodnie z określoną funkcją selektora kluczy.
MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Zwraca wartość minimalną w sekwencji ogólnej zgodnie z określoną funkcją selektora kluczy i modułem porównującym klucz.
OfType<TResult>(IEnumerable)	Filtruje elementy elementu IEnumerable na podstawie określonego typu.
Order<T>(IEnumerable<T>)	Sortuje elementy sekwencji w kolejności rosnącej.
Order<T>(IEnumerable<T>, IComparer<T>)	Sortuje elementy sekwencji w kolejności rosnącej.
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Sortuje elementy sekwencji w kolejności rosnącej zgodnie z kluczem.
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Sortuje elementy sekwencji w kolejności rosnącej przy użyciu określonego porównania.
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Sortuje elementy sekwencji w kolejności malejącej zgodnie z kluczem.
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Sortuje elementy sekwencji w kolejności malejącej przy użyciu określonego porównania.
OrderDescending<T>(IEnumerable<T>)	Sortuje elementy sekwencji w kolejności malejącej.
OrderDescending<T>(IEnumerable<T>, IComparer<T>)	Sortuje elementy sekwencji w kolejności malejącej.
Prepend<TSource>(IEnumerable<TSource>, TSource)	Dodaje wartość na początku sekwencji.
Reverse<TSource>(IEnumerable<TSource>)	Odwraca kolejność elementów w sekwencji.
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Projektuje każdy element sekwencji w nowym formularzu.
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>)	Projektuje każdy element sekwencji w nowym formularzu, dołączając indeks elementu.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>)	Projektuje każdy element sekwencji do IEnumerable<T> elementu i spłaszcza wynikowe sekwencje w jedną sekwencję.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)	Projektuje każdy element sekwencji do IEnumerable<T>elementu i spłaszcza wynikowe sekwencje w jedną sekwencję. Indeks każdego elementu źródłowego jest używany w przewidywanej formie tego elementu.
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)	Projektuje każdy element sekwencji do IEnumerable<T>elementu , spłaszcza wynikowe sekwencje w jedną sekwencję i wywołuje funkcję selektora wyników w każdym elemecie.
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)	Projektuje każdy element sekwencji do IEnumerable<T>elementu , spłaszcza wynikowe sekwencje w jedną sekwencję i wywołuje funkcję selektora wyników w każdym elemecie. Indeks każdego elementu źródłowego jest używany w przewidywanej formie pośredniej tego elementu.
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Określa, czy dwie sekwencje są równe, porównując elementy przy użyciu domyślnego porównywarki równości dla ich typu.
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Określa, czy dwie sekwencje są równe, porównując swoje elementy przy użyciu określonego IEqualityComparer<T>elementu .
Single<TSource>(IEnumerable<TSource>)	Zwraca jedyny element sekwencji i zgłasza wyjątek, jeśli nie ma dokładnie jednego elementu w sekwencji.
Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Zwraca jedyny element sekwencji, który spełnia określony warunek, i zgłasza wyjątek, jeśli istnieje więcej niż jeden taki element.
SingleOrDefault<TSource>(IEnumerable<TSource>)	Zwraca jedyny element sekwencji lub wartość domyślną, jeśli sekwencja jest pusta; Ta metoda zgłasza wyjątek, jeśli sekwencja zawiera więcej niż jeden element.
SingleOrDefault<TSource>(IEnumerable<TSource>, TSource)	Zwraca jedyny element sekwencji lub określoną wartość domyślną, jeśli sekwencja jest pusta; Ta metoda zgłasza wyjątek, jeśli sekwencja zawiera więcej niż jeden element.
SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Zwraca jedyny element sekwencji, który spełnia określony warunek lub wartość domyślną, jeśli taki element nie istnieje; Ta metoda zgłasza wyjątek, jeśli warunek spełnia więcej niż jeden element.
SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)	Zwraca jedyny element sekwencji, który spełnia określony warunek lub określoną wartość domyślną, jeśli taki element nie istnieje; Ta metoda zgłasza wyjątek, jeśli warunek spełnia więcej niż jeden element.
Skip<TSource>(IEnumerable<TSource>, Int32)	Pomija określoną liczbę elementów w sekwencji, a następnie zwraca pozostałe elementy.
SkipLast<TSource>(IEnumerable<TSource>, Int32)	Zwraca nową kolekcję wyliczalną zawierającą elementy z source ostatnich count elementów kolekcji źródłowej pominiętą.
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Pomija elementy w sekwencji, o ile określony warunek jest spełniony, a następnie zwraca pozostałe elementy.
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Pomija elementy w sekwencji, o ile określony warunek jest spełniony, a następnie zwraca pozostałe elementy. Indeks elementu jest używany w logice funkcji predykatu.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Oblicza sumę sekwencji Decimal wartości uzyskanych przez wywołanie funkcji przekształcania dla każdego elementu sekwencji danych wejściowych.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Oblicza sumę sekwencji Double wartości uzyskanych przez wywołanie funkcji przekształcania dla każdego elementu sekwencji danych wejściowych.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Oblicza sumę sekwencji Int32 wartości uzyskanych przez wywołanie funkcji przekształcania dla każdego elementu sekwencji danych wejściowych.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Oblicza sumę sekwencji Int64 wartości uzyskanych przez wywołanie funkcji przekształcania dla każdego elementu sekwencji danych wejściowych.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Oblicza sumę sekwencji wartości dopuszczających wartość null, które są uzyskiwane Decimal przez wywołanie funkcji przekształcania dla każdego elementu sekwencji danych wejściowych.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Oblicza sumę sekwencji wartości dopuszczających wartość null, które są uzyskiwane Double przez wywołanie funkcji przekształcania dla każdego elementu sekwencji danych wejściowych.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Oblicza sumę sekwencji wartości dopuszczających wartość null, które są uzyskiwane Int32 przez wywołanie funkcji przekształcania dla każdego elementu sekwencji danych wejściowych.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Oblicza sumę sekwencji wartości dopuszczających wartość null, które są uzyskiwane Int64 przez wywołanie funkcji przekształcania dla każdego elementu sekwencji danych wejściowych.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Oblicza sumę sekwencji wartości dopuszczających wartość null, które są uzyskiwane Single przez wywołanie funkcji przekształcania dla każdego elementu sekwencji danych wejściowych.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Oblicza sumę sekwencji Single wartości uzyskanych przez wywołanie funkcji przekształcania dla każdego elementu sekwencji danych wejściowych.
Take<TSource>(IEnumerable<TSource>, Int32)	Zwraca określoną liczbę ciągłych elementów od początku sekwencji.
Take<TSource>(IEnumerable<TSource>, Range)	Zwraca określony zakres ciągłych elementów z sekwencji.
TakeLast<TSource>(IEnumerable<TSource>, Int32)	Zwraca nową kolekcję wyliczalną zawierającą ostatnie count elementy z klasy source.
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Zwraca elementy z sekwencji, o ile określony warunek ma wartość true.
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Zwraca elementy z sekwencji, o ile określony warunek ma wartość true. Indeks elementu jest używany w logice funkcji predykatu.
ToArray<TSource>(IEnumerable<TSource>)	Tworzy tablicę na podstawie elementu IEnumerable<T>.
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Tworzy obiekt Dictionary<TKey,TValue> na podstawie IEnumerable<T> określonej funkcji selektora klucza.
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Tworzy element Dictionary<TKey,TValue>IEnumerable<T> na podstawie określonej funkcji selektora kluczy i modułu porównania kluczy.
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Tworzy obiekt Dictionary<TKey,TValue>IEnumerable<T> na podstawie określonych funkcji selektora kluczy i selektora elementów.
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Tworzy element Dictionary<TKey,TValue> na podstawie IEnumerable<T> określonej funkcji selektora kluczy, modułu porównującego i funkcji selektora elementów.
ToHashSet<TSource>(IEnumerable<TSource>)	Tworzy obiekt na HashSet<T> podstawie elementu IEnumerable<T>.
ToHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Tworzy obiekt HashSet<T>IEnumerable<T> na podstawie elementu comparer , aby porównać klucze.
ToList<TSource>(IEnumerable<TSource>)	Tworzy obiekt na List<T> podstawie elementu IEnumerable<T>.
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Tworzy obiekt Lookup<TKey,TElement> na podstawie IEnumerable<T> określonej funkcji selektora klucza.
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Tworzy element Lookup<TKey,TElement>IEnumerable<T> na podstawie określonej funkcji selektora kluczy i modułu porównania kluczy.
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Tworzy obiekt Lookup<TKey,TElement>IEnumerable<T> na podstawie określonych funkcji selektora kluczy i selektora elementów.
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Tworzy element Lookup<TKey,TElement> na podstawie IEnumerable<T> określonej funkcji selektora kluczy, modułu porównującego i funkcji selektora elementów.
TryGetNonEnumeratedCount<TSource>(IEnumerable<TSource>, Int32)	Próbuje określić liczbę elementów w sekwencji bez wymuszania wyliczenia.
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Tworzy połączenie zestawu dwóch sekwencji przy użyciu domyślnego porównania równości.
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Tworzy zestaw unii dwóch sekwencji przy użyciu określonego IEqualityComparer<T>.
UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>)	Tworzy połączenie zestawu dwóch sekwencji zgodnie z określoną funkcją selektora kluczy.
UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Tworzy połączenie zestawu dwóch sekwencji zgodnie z określoną funkcją selektora kluczy.
Where<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Filtruje sekwencję wartości na podstawie predykatu.
Where<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Filtruje sekwencję wartości na podstawie predykatu. Indeks każdego elementu jest używany w logice funkcji predykatu.
Zip<TFirst,TSecond>(IEnumerable<TFirst>, IEnumerable<TSecond>)	Tworzy sekwencję krotki z elementami z dwóch określonych sekwencji.
Zip<TFirst,TSecond,TThird>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>)	Tworzy sekwencję krotki z elementami z trzech określonych sekwencji.
Zip<TFirst,TSecond,TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>)	Stosuje określoną funkcję do odpowiednich elementów dwóch sekwencji, tworząc sekwencję wyników.
AsParallel(IEnumerable)	Umożliwia równoległość zapytania.
AsParallel<TSource>(IEnumerable<TSource>)	Umożliwia równoległość zapytania.
AsQueryable(IEnumerable)	Konwertuje element IEnumerable na .IQueryable
AsQueryable<TElement>(IEnumerable<TElement>)	Konwertuje rodzajowy IEnumerable<T> na ogólny IQueryable<T>.
Ancestors<T>(IEnumerable<T>)	Zwraca kolekcję elementów, które zawierają elementy podrzędne każdego węzła w kolekcji źródłowej.
Ancestors<T>(IEnumerable<T>, XName)	Zwraca przefiltrowaną kolekcję elementów, które zawierają elementy będące elementami głównymi każdego węzła w kolekcji źródłowej. W kolekcji znajdują się tylko elementy, które mają dopasowanie XName .
DescendantNodes<T>(IEnumerable<T>)	Zwraca kolekcję węzłów podrzędnych każdego dokumentu i elementu w kolekcji źródłowej.
Descendants<T>(IEnumerable<T>)	Zwraca kolekcję elementów, które zawierają elementy podrzędne każdego elementu i dokumentu w kolekcji źródłowej.
Descendants<T>(IEnumerable<T>, XName)	Zwraca filtrowaną kolekcję elementów, które zawierają elementy podrzędne każdego elementu i dokumentu w kolekcji źródłowej. W kolekcji znajdują się tylko elementy, które mają dopasowanie XName .
Elements<T>(IEnumerable<T>)	Zwraca kolekcję elementów podrzędnych każdego elementu i dokumentu w kolekcji źródłowej.
Elements<T>(IEnumerable<T>, XName)	Zwraca filtrowaną kolekcję elementów podrzędnych każdego elementu i dokumentu w kolekcji źródłowej. W kolekcji znajdują się tylko elementy, które mają dopasowanie XName .
InDocumentOrder<T>(IEnumerable<T>)	Zwraca kolekcję węzłów zawierającą wszystkie węzły w kolekcji źródłowej posortowane w kolejności dokumentu.
Nodes<T>(IEnumerable<T>)	Zwraca kolekcję węzłów podrzędnych każdego dokumentu i elementu w kolekcji źródłowej.
Remove<T>(IEnumerable<T>)	Usuwa każdy węzeł w kolekcji źródłowej z węzła nadrzędnego.

Bezpieczeństwo wątkowe

Metoda Dispose nie jest bezpieczna wątkowo. Wszystkie inne publiczne i chronione elementy członkowskie są BlockingCollection<T> bezpieczne wątkowo i mogą być używane współbieżnie z wielu wątków.

Zobacz też

• Kolekcje bezpieczne wątkowo
• BlockingCollection — Przegląd
• Instrukcje: dodawanie funkcji ograniczenia i blokowania do klasy kolekcji