BlockingCollection<T> Klasa

Definicja

Oferuje funkcje blokowania i ograniczania dla kolekcji bezpiecznych dla wątków, które implementują IProducerConsumerCollection<T>.Provides blocking and bounding capabilities for thread-safe collections that implement IProducerConsumerCollection<T>.

generic <typename T>
public ref class BlockingCollection : IDisposable, System::Collections::Generic::IEnumerable<T>, System::Collections::Generic::IReadOnlyCollection<T>, System::Collections::ICollection
[System.Runtime.InteropServices.ComVisible(false)]
public class BlockingCollection<T> : IDisposable, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.ICollection
type BlockingCollection<'T> = class
    interface seq<'T>
    interface ICollection
    interface IDisposable
    interface IReadOnlyCollection<'T>
    interface IEnumerable
Public Class BlockingCollection(Of T)
Implements ICollection, IDisposable, IEnumerable(Of T), IReadOnlyCollection(Of T)

Parametry typu

T

Typ elementów w kolekcji.The type of elements in the collection.

Dziedziczenie
BlockingCollection<T>
Atrybuty
Implementuje

Przykłady

Poniższy przykład pokazuje, jak dodawać i przyjmować elementy jednocześnie z kolekcji blokującej:The following example shows how to add and take items concurrently from a blocking collection:

using System;
using System.Collections.Concurrent;
using System.Threading;
using System.Threading.Tasks;

class BlockingCollectionDemo
{
    static async Task Main()
    {
        await AddTakeDemo.BC_AddTakeCompleteAdding();
        TryTakeDemo.BC_TryTake();
        FromToAnyDemo.BC_FromToAny();
        await ConsumingEnumerableDemo.BC_GetConsumingEnumerable();
        Console.WriteLine("Press any key to exit.");
        Console.ReadKey();
    }
}
class AddTakeDemo
{
    // Demonstrates:
    //      BlockingCollection<T>.Add()
    //      BlockingCollection<T>.Take()
    //      BlockingCollection<T>.CompleteAdding()
    public static async Task BC_AddTakeCompleteAdding()
    {
        using (BlockingCollection<int> bc = new BlockingCollection<int>())
        {
            // Spin up a Task to populate the BlockingCollection
            using (Task t1 = Task.Run(() =>
            {
                bc.Add(1);
                bc.Add(2);
                bc.Add(3);
                bc.CompleteAdding();
            }))
            {
                // Spin up a Task to consume the BlockingCollection
                using (Task t2 = Task.Run(() =>
                {
                    try
                    {
                        // Consume consume the BlockingCollection
                        while (true) Console.WriteLine(bc.Take());
                    }
                    catch (InvalidOperationException)
                    {
                        // An InvalidOperationException means that Take() was called on a completed collection
                        Console.WriteLine("That's All!");
                    }
                }))
                {
                    await Task.WhenAll(t1, t2);
                }
            }
        }
    }
}

class TryTakeDemo
{
    // Demonstrates:
    //      BlockingCollection<T>.Add()
    //      BlockingCollection<T>.CompleteAdding()
    //      BlockingCollection<T>.TryTake()
    //      BlockingCollection<T>.IsCompleted
    public static void BC_TryTake()
    {
        // Construct and fill our BlockingCollection
        using (BlockingCollection<int> bc = new BlockingCollection<int>())
        {
            int NUMITEMS = 10000;
            for (int i = 0; i < NUMITEMS; i++) bc.Add(i);
            bc.CompleteAdding();
            int outerSum = 0;

            // Delegate for consuming the BlockingCollection and adding up all items
            Action action = () =>
            {
                int localItem;
                int localSum = 0;

                while (bc.TryTake(out localItem)) localSum += localItem;
                Interlocked.Add(ref outerSum, localSum);
            };

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

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

class FromToAnyDemo
{
    // Demonstrates:
    //      Bounded BlockingCollection<T>
    //      BlockingCollection<T>.TryAddToAny()
    //      BlockingCollection<T>.TryTakeFromAny()
    public static void BC_FromToAny()
    {
        BlockingCollection<int>[] bcs = new BlockingCollection<int>[2];
        bcs[0] = new BlockingCollection<int>(5); // collection bounded to 5 items
        bcs[1] = new BlockingCollection<int>(5); // collection bounded to 5 items

        // Should be able to add 10 items w/o blocking
        int numFailures = 0;
        for (int i = 0; i < 10; i++)
        {
            if (BlockingCollection<int>.TryAddToAny(bcs, i) == -1) numFailures++;
        }
        Console.WriteLine("TryAddToAny: {0} failures (should be 0)", numFailures);

        // Should be able to retrieve 10 items
        int numItems = 0;
        int item;
        while (BlockingCollection<int>.TryTakeFromAny(bcs, out item) != -1) numItems++;
        Console.WriteLine("TryTakeFromAny: retrieved {0} items (should be 10)", numItems);
    }
}

class ConsumingEnumerableDemo
{
    // Demonstrates:
    //      BlockingCollection<T>.Add()
    //      BlockingCollection<T>.CompleteAdding()
    //      BlockingCollection<T>.GetConsumingEnumerable()
    public static async Task BC_GetConsumingEnumerable()
    {
        using (BlockingCollection<int> bc = new BlockingCollection<int>())
        {
            // Kick off a producer task
            await Task.Run(async () =>
            {
                for (int i = 0; i < 10; i++)
                {
                    bc.Add(i);
                    await Task.Delay(100); // sleep 100 ms between adds
                }

                // Need to do this to keep foreach below from hanging
                bc.CompleteAdding();
            });

            // Now consume the blocking collection with foreach.
            // Use bc.GetConsumingEnumerable() instead of just bc because the
            // former will block waiting for completion and the latter will
            // simply take a snapshot of the current state of the underlying collection.
            foreach (var item in bc.GetConsumingEnumerable())
            {
                Console.WriteLine(item);
            }
        }
    }
}
Imports System.Threading.Tasks
Imports System.Collections.Concurrent
Imports System.Threading

Class BlockingCollectionDemo
    Shared Sub Main()
        AddTakeDemo.BC_AddTakeCompleteAdding()
        TryTakeDemo.BC_TryTake()
        ToAnyDemo.BC_ToAny()
        ConsumingEnumerableDemo.BC_GetConsumingEnumerable()
        ' Keep the console window open in debug mode
        Console.WriteLine("Press any key to exit.")
        Console.ReadKey()
    End Sub
End Class

Class AddTakeDemo

    ' Demonstrates:
    ' BlockingCollection<T>.Add()
    ' BlockingCollection<T>.Take()
    ' BlockingCollection<T>.CompleteAdding()
    Shared Sub BC_AddTakeCompleteAdding()
        Using bc As New BlockingCollection(Of Integer)()

            ' Spin up a Task to populate the BlockingCollection 
            Using t1 As Task = Task.Factory.StartNew(
                Sub()
                    bc.Add(1)
                    bc.Add(2)
                    bc.Add(3)
                    bc.CompleteAdding()
                End Sub)
                ' Spin up a Task to consume the BlockingCollection
                Using t2 As Task = Task.Factory.StartNew(
                Sub()
                    Try
                        ' Consume the BlockingCollection
                        While True
                            Console.WriteLine(bc.Take())
                        End While
                    Catch generatedExceptionName As InvalidOperationException
                        ' An InvalidOperationException means that Take() was called on a completed collection
                        Console.WriteLine("That's All!")
                    End Try
                End Sub)

                    Task.WaitAll(t1, t2)
                End Using
            End Using
        End Using
    End Sub



End Class

'Imports System.Collections.Concurrent
'Imports System.Threading
'Imports System.Threading.Tasks

Class TryTakeDemo
    ' Demonstrates:
    ' BlockingCollection<T>.Add()
    ' BlockingCollection<T>.CompleteAdding()
    ' BlockingCollection<T>.TryTake()
    ' BlockingCollection<T>.IsCompleted
    Shared Sub BC_TryTake()
        ' Construct and fill our BlockingCollection
        Using bc As New BlockingCollection(Of Integer)()
            Dim NUMITEMS As Integer = 10000
            For i As Integer = 0 To NUMITEMS - 1
                bc.Add(i)
            Next
            bc.CompleteAdding()
            Dim outerSum As Integer = 0

            ' Delegate for consuming the BlockingCollection and adding up all items
            Dim action As Action =
                Sub()
                    Dim localItem As Integer
                    Dim localSum As Integer = 0

                    While bc.TryTake(localItem)
                        localSum += localItem
                    End While
                    Interlocked.Add(outerSum, localSum)
                End Sub

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

            Console.WriteLine("Sum[0..{0}) = {1}, should be {2}", NUMITEMS, outerSum, ((NUMITEMS * (NUMITEMS - 1)) / 2))
            Console.WriteLine("bc.IsCompleted = {0} (should be true)", bc.IsCompleted)
        End Using
    End Sub

End Class

'Imports System.Threading.Tasks
'Imports System.Collections.Concurrent

' Demonstrates:
' Bounded BlockingCollection<T>
' BlockingCollection<T>.TryAddToAny()
' BlockingCollection<T>.TryTakeFromAny()
Class ToAnyDemo
    Shared Sub BC_ToAny()
        Dim bcs As BlockingCollection(Of Integer)() = New BlockingCollection(Of Integer)(1) {}
        bcs(0) = New BlockingCollection(Of Integer)(5)
        ' collection bounded to 5 items
        bcs(1) = New BlockingCollection(Of Integer)(5)
        ' collection bounded to 5 items
        ' Should be able to add 10 items w/o blocking
        Dim numFailures As Integer = 0
        For i As Integer = 0 To 9
            If BlockingCollection(Of Integer).TryAddToAny(bcs, i) = -1 Then
                numFailures += 1
            End If
        Next
        Console.WriteLine("TryAddToAny: {0} failures (should be 0)", numFailures)

        ' Should be able to retrieve 10 items
        Dim numItems As Integer = 0
        Dim item As Integer
        While BlockingCollection(Of Integer).TryTakeFromAny(bcs, item) <> -1
            numItems += 1
        End While
        Console.WriteLine("TryTakeFromAny: retrieved {0} items (should be 10)", numItems)
    End Sub
End Class

'Imports System.Threading.Tasks
'Imports System.Collections.Concurrent

' Demonstrates:
' BlockingCollection<T>.Add()
' BlockingCollection<T>.CompleteAdding()
' BlockingCollection<T>.GetConsumingEnumerable()

Class ConsumingEnumerableDemo
    Shared Sub BC_GetConsumingEnumerable()
        Using bc As New BlockingCollection(Of Integer)()

            ' Kick off a producer task
            Task.Factory.StartNew(
                Sub()
                    For i As Integer = 0 To 9
                        bc.Add(i)
                        ' sleep 100 ms between adds
                        Thread.Sleep(100)
                    Next

                    ' Need to do this to keep foreach below from not responding.
                    bc.CompleteAdding()
                End Sub)
            ' Now consume the blocking collection with foreach.
            ' Use bc.GetConsumingEnumerable() instead of just bc because the
            ' former will block waiting for completion and the latter will
            ' simply take a snapshot of the current state of the underlying collection.
            For Each item In bc.GetConsumingEnumerable()
                Console.WriteLine(item)
            Next
        End Using
    End Sub
End Class

Uwagi

BlockingCollection<T> to Klasa kolekcji z bezpieczną wątkiem, która zapewnia następujące informacje:BlockingCollection<T> is a thread-safe collection class that provides the following:

Ważne

Ten typ implementuje interfejs IDisposable.This type implements the IDisposable interface. Po zakończeniu korzystania z typu należy usunąć jego wartość bezpośrednio lub pośrednio.When you have finished using the type, you should dispose of it either directly or indirectly. Aby usunąć typ bezpośrednio, wywołaj metodę Dispose w bloku try / catch.To dispose of the type directly, call its Dispose method in a try/catch block. Aby usunąć go pośrednio, użyj konstrukcji językowej, takiej jak using (in C#) lub Using (w Visual Basic).To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Aby uzyskać więcej informacji, zobacz sekcję "Używanie obiektu implementującego interfejs IDisposable" w temacie interfejsu IDisposable.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic. Należy również pamiętać, że metoda Dispose() nie jest bezpieczna wątkowo.Also, note that the Dispose() method is not thread-safe. Wszystkie inne publiczne i chronione elementy członkowskie BlockingCollection<T> są bezpieczne dla wątków i mogą być używane współbieżnie z wielu wątków.All other public and protected members of BlockingCollection<T> are thread-safe and may be used concurrently from multiple threads.

IProducerConsumerCollection<T> reprezentuje kolekcję, która umożliwia bezpieczne Dodawanie i usuwanie danych przez wątki.IProducerConsumerCollection<T> represents a collection that allows for thread-safe adding and removal of data. BlockingCollection<T> jest używany jako otoka dla wystąpienia IProducerConsumerCollection<T> i umożliwia usunięcie prób z kolekcji w celu zablokowania do momentu, gdy dane będą dostępne do usunięcia.BlockingCollection<T> is used as a wrapper for an IProducerConsumerCollection<T> instance, and allows removal attempts from the collection to block until data is available to be removed. Podobnie można utworzyć BlockingCollection<T>, aby wymusić górną granicę liczby elementów danych dozwolonych w IProducerConsumerCollection<T>; Dodawanie prób do kolekcji może następnie zablokować do momentu, w którym będzie można przechowywać dodane elementy.Similarly, you can create a BlockingCollection<T> to enforce an upper bound on the number of data elements allowed in the IProducerConsumerCollection<T>; addition attempts to the collection may then block until space is available to store the added items. W ten sposób BlockingCollection<T> przypomina tradycyjną strukturę danych kolejki blokującej, z tą różnicą, że mechanizm magazynu danych jest abstrakcyjny jako IProducerConsumerCollection<T>.In this manner, BlockingCollection<T> is similar to a traditional blocking queue data structure, except that the underlying data storage mechanism is abstracted away as an IProducerConsumerCollection<T>.

BlockingCollection<T> obsługuje ograniczenia i blokowanie.BlockingCollection<T> supports bounding and blocking. Ograniczenie oznacza, że można ustawić maksymalną pojemność kolekcji.Bounding means that you can set the maximum capacity of the collection. Ograniczenia są istotne w niektórych scenariuszach, ponieważ umożliwiają kontrolowanie maksymalnego rozmiaru kolekcji w pamięci i uniemożliwia przechodzenie przez nie wątki do zużywanych wątków. Wiele wątków lub zadań może jednocześnie dodawać elementy do kolekcji, a jeśli kolekcja osiągnie swoją określoną maksymalną pojemność, wątki wytwarzające będą blokować do momentu usunięcia elementu.Bounding is important in certain scenarios because it enables you to control the maximum size of the collection in memory, and it prevents the producing threads from moving too far ahead of the consuming threads.Multiple threads or tasks can add items to the collection concurrently, and if the collection reaches its specified maximum capacity, the producing threads will block until an item is removed. Wielu odbiorców może usuwać elementy współbieżnie, a jeśli kolekcja stanie się pusta, zużywające wątki będą blokować do momentu dodania elementu do producenta.Multiple consumers can remove items concurrently, and if the collection becomes empty, the consuming threads will block until a producer adds an item. Wątek produkcji może wywołać metodę CompleteAdding, aby wskazać, że nie zostaną dodane żadne dodatkowe elementy.A producing thread can call the CompleteAdding method to indicate that no more items will be added. Odbiorcy monitorują Właściwość IsCompleted, aby wiedzieć, kiedy kolekcja jest pusta i nie zostaną dodane żadne elementy.Consumers monitor the IsCompleted property to know when the collection is empty and no more items will be added.

operacje Add i Take są zwykle wykonywane w pętli.Add and Take operations are typically performed in a loop. Możesz anulować pętlę, przechodząc do CancellationToken obiektu do metody TryAdd lub TryTake, a następnie sprawdzając wartość właściwości IsCancellationRequested tokenu dla każdej iteracji.You can cancel a loop by passing in a CancellationToken object to the TryAdd or TryTake method, and then checking the value of the token's IsCancellationRequested property on each iteration. Jeśli wartość jest true, można odpowiedzieć na żądanie anulowania przez oczyszczenie wszystkich zasobów i wyjście z pętli.If the value is true, it is up to you to respond the cancellation request by cleaning up any resources and exiting the loop.

Podczas tworzenia obiektu BlockingCollection<T> można określić nie tylko powiązane pojemności, ale również typ kolekcji do użycia.When you create a BlockingCollection<T> object, you can specify not only the bounded capacity but also the type of collection to use. Na przykład, można określić obiekt ConcurrentQueue<T> dla zachowania First In, First Out (FIFO) lub obiektu ConcurrentStack<T> dla ostatniego zachowania w, First Out (LIFO).For example, you could specify a ConcurrentQueue<T> object for first in, first out (FIFO) behavior, or a ConcurrentStack<T> object for last in, first out (LIFO) behavior. Można użyć dowolnej klasy kolekcji implementującej interfejs IProducerConsumerCollection<T>.You can use any collection class that implements the IProducerConsumerCollection<T> interface. Domyślny typ kolekcji dla BlockingCollection<T> jest ConcurrentQueue<T>.The default collection type for BlockingCollection<T> is ConcurrentQueue<T>.

Nie należy bezpośrednio modyfikować źródłowej kolekcji.Do not modify the underlying collection directly. Użyj metod BlockingCollection<T>, aby dodać lub usunąć elementy.Use BlockingCollection<T> methods to add or remove elements. Obiekt BlockingCollection<T> może ulec uszkodzeniu, jeśli bezpośrednio zmienisz kolekcję źródłową.The BlockingCollection<T> object can become corrupted if you change the underlying collection directly.

Konstruktory

BlockingCollection<T>()

Inicjuje nowe wystąpienie klasy BlockingCollection<T> bez górnego powiązania.Initializes a new instance of the BlockingCollection<T> class without an upper-bound.

BlockingCollection<T>(Int32)

Inicjuje nowe wystąpienie klasy BlockingCollection<T> z określoną górną granicą.Initializes a new instance of the BlockingCollection<T> class with the specified upper-bound.

BlockingCollection<T>(IProducerConsumerCollection<T>)

Inicjuje nowe wystąpienie klasy BlockingCollection<T> bez górnego powiązania i korzystając z podanego IProducerConsumerCollection<T> jako bazowego magazynu danych.Initializes a new instance of the BlockingCollection<T> class without an upper-bound and using the provided IProducerConsumerCollection<T> as its underlying data store.

BlockingCollection<T>(IProducerConsumerCollection<T>, Int32)

Inicjuje nowe wystąpienie klasy BlockingCollection<T> z określoną górną granicą i przy użyciu dostarczonego IProducerConsumerCollection<T> jako bazowego magazynu danych.Initializes a new instance of the BlockingCollection<T> class with the specified upper-bound and using the provided IProducerConsumerCollection<T> as its underlying data store.

Właściwości

BoundedCapacity

Pobiera powiązaną pojemność tego wystąpienia BlockingCollection<T>.Gets the bounded capacity of this BlockingCollection<T> instance.

Count

Pobiera liczbę elementów zawartych w BlockingCollection<T>.Gets the number of items contained in the BlockingCollection<T>.

IsAddingCompleted

Określa, czy ta BlockingCollection<T> została oznaczona jako kompletna do dodania.Gets whether this BlockingCollection<T> has been marked as complete for adding.

IsCompleted

Określa, czy ta BlockingCollection<T> została oznaczona jako ukończona do dodawania i jest pusta.Gets whether this BlockingCollection<T> has been marked as complete for adding and is empty.

Metody

Add(T)

Dodaje element do BlockingCollection<T>.Adds the item to the BlockingCollection<T>.

Add(T, CancellationToken)

Dodaje element do BlockingCollection<T>.Adds the item to the BlockingCollection<T>.

AddToAny(BlockingCollection<T>[], T)

Dodaje określony element do dowolnego z określonych wystąpień BlockingCollection<T>.Adds the specified item to any one of the specified BlockingCollection<T> instances.

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

Dodaje określony element do dowolnego z określonych wystąpień BlockingCollection<T>.Adds the specified item to any one of the specified BlockingCollection<T> instances.

CompleteAdding()

Oznacza BlockingCollection<T> wystąpień jako nieakceptujących dodatkowych dodatków.Marks the BlockingCollection<T> instances as not accepting any more additions.

CopyTo(T[], Int32)

Kopiuje wszystkie elementy z wystąpienia BlockingCollection<T> do zgodnej jednowymiarowej tablicy, rozpoczynając od określonego indeksu tablicy docelowej.Copies all of the items in the BlockingCollection<T> instance to a compatible one-dimensional array, starting at the specified index of the target array.

Dispose()

Zwalnia wszystkie zasoby używane przez bieżące wystąpienie klasy BlockingCollection<T>.Releases all resources used by the current instance of the BlockingCollection<T> class.

Dispose(Boolean)

Zwalnia zasoby używane przez wystąpienie BlockingCollection<T>.Releases resources used by the BlockingCollection<T> instance.

Equals(Object)

Określa, czy określony obiekt jest równy bieżącemu obiektowi.Determines whether the specified object is equal to the current object.

(Odziedziczone po Object)
GetConsumingEnumerable()

Zapewnia zużywaną IEnumerator<T> dla elementów w kolekcji.Provides a consuming IEnumerator<T> for items in the collection.

GetConsumingEnumerable(CancellationToken)

Zapewnia zużywaną IEnumerable<T> dla elementów w kolekcji.Provides a consuming IEnumerable<T> for items in the collection.

GetHashCode()

Służy jako domyślna funkcja skrótu.Serves as the default hash function.

(Odziedziczone po Object)
GetType()

Type Pobiera bieżące wystąpienie.Gets the Type of the current instance.

(Odziedziczone po Object)
MemberwiseClone()

Tworzy skróconą kopię bieżącego Objectelementu.Creates a shallow copy of the current Object.

(Odziedziczone po Object)
Take()

Usuwa element z BlockingCollection<T>.Removes an item from the BlockingCollection<T>.

Take(CancellationToken)

Usuwa element z BlockingCollection<T>.Removes an item from the BlockingCollection<T>.

TakeFromAny(BlockingCollection<T>[], T)

Pobiera element z jednego z określonych wystąpień BlockingCollection<T>.Takes an item from any one of the specified BlockingCollection<T> instances.

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

Pobiera element z dowolnego jednego z określonych wystąpień BlockingCollection<T> podczas przestrzegania określonego tokenu anulowania.Takes an item from any one of the specified BlockingCollection<T> instances while observing the specified cancellation token.

ToArray()

Kopiuje elementy z wystąpienia BlockingCollection<T> do nowej tablicy.Copies the items from the BlockingCollection<T> instance into a new array.

ToString()

Zwraca ciąg, który reprezentuje bieżący obiekt.Returns a string that represents the current object.

(Odziedziczone po Object)
TryAdd(T)

Próbuje dodać określony element do BlockingCollection<T>.Tries to add the specified item to the BlockingCollection<T>.

TryAdd(T, Int32)

Próbuje dodać określony element do BlockingCollection<T> w określonym przedziale czasu.Tries to add the specified item to the BlockingCollection<T> within the specified time period.

TryAdd(T, Int32, CancellationToken)

Próbuje dodać określony element do BlockingCollection<T> w określonym przedziale czasu, zachowując token anulowania.Tries to add the specified item to the BlockingCollection<T> within the specified time period, while observing a cancellation token.

TryAdd(T, TimeSpan)

Próbuje dodać określony element do BlockingCollection<T>.Tries to add the specified item to the BlockingCollection<T>.

TryAddToAny(BlockingCollection<T>[], T)

Próbuje dodać określony element do jednego z określonych wystąpień BlockingCollection<T>.Tries to add the specified item to any one of the specified BlockingCollection<T> instances.

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

Próbuje dodać określony element do jednego z określonych wystąpień BlockingCollection<T>.Tries to add the specified item to any one of the specified BlockingCollection<T> instances.

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

Próbuje dodać określony element do jednego z określonych wystąpień BlockingCollection<T>.Tries to add the specified item to any one of the specified BlockingCollection<T> instances.

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

Próbuje dodać określony element do dowolnego z określonych wystąpień BlockingCollection<T> podczas przestrzegania określonego tokenu anulowania.Tries to add the specified item to any one of the specified BlockingCollection<T> instances while observing the specified cancellation token.

TryTake(T)

Próbuje usunąć element z BlockingCollection<T>.Tries to remove an item from the BlockingCollection<T>.

TryTake(T, Int32)

Próbuje usunąć element z BlockingCollection<T> w określonym przedziale czasu.Tries to remove an item from the BlockingCollection<T> in the specified time period.

TryTake(T, Int32, CancellationToken)

Próbuje usunąć element z BlockingCollection<T> w określonym przedziale czasu, zachowując token anulowania.Tries to remove an item from the BlockingCollection<T> in the specified time period while observing a cancellation token.

TryTake(T, TimeSpan)

Próbuje usunąć element z BlockingCollection<T> w określonym przedziale czasu.Tries to remove an item from the BlockingCollection<T> in the specified time period.

TryTakeFromAny(BlockingCollection<T>[], T)

Próbuje usunąć element z jednego z określonych wystąpień BlockingCollection<T>.Tries to remove an item from any one of the specified BlockingCollection<T> instances.

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

Próbuje usunąć element z jednego z określonych wystąpień BlockingCollection<T>.Tries to remove an item from any one of the specified BlockingCollection<T> instances.

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

Próbuje usunąć element z jednego z określonych wystąpień BlockingCollection<T>.Tries to remove an item from any one of the specified BlockingCollection<T> instances.

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

Próbuje usunąć element z jednego z określonych wystąpień BlockingCollection<T>.Tries to remove an item from any one of the specified BlockingCollection<T> instances.

Jawne implementacje interfejsu

ICollection.CopyTo(Array, Int32)

Kopiuje wszystkie elementy z wystąpienia BlockingCollection<T> do zgodnej jednowymiarowej tablicy, rozpoczynając od określonego indeksu tablicy docelowej.Copies all of the items in the BlockingCollection<T> instance to a compatible one-dimensional array, starting at the specified index of the target array.

ICollection.IsSynchronized

Pobiera wartość wskazującą, czy dostęp do ICollection jest synchronizowany (bezpieczny wątkowo).Gets a value indicating whether access to the ICollection is synchronized (thread safe).

ICollection.SyncRoot

Pobiera obiekt, którego można użyć do synchronizowania dostępu do ICollection.Gets an object that can be used to synchronize access to the ICollection. Ta właściwość nie jest obsługiwana.This property is not supported.

IEnumerable.GetEnumerator()

Udostępnia IEnumerator dla elementów w kolekcji.Provides an IEnumerator for items in the collection.

IEnumerable<T>.GetEnumerator()

Udostępnia IEnumerator<T> dla elementów w kolekcji.Provides an IEnumerator<T> for items in the collection.

Metody rozszerzania

CopyToDataTable<T>(IEnumerable<T>)

DataRow T IEnumerable<T> Zwraca obiekt, DataRow który zawiera kopie obiektów, z uwzględnieniem obiektu wejściowego, w którym parametr generyczny jest. DataTableReturns a DataTable that contains copies of the DataRow objects, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)

Kopiuje DataRow obiekty do określonego DataTable, przy użyciu obiektu wejściowego IEnumerable<T> , w którym jest T DataRowparametr generyczny.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)

Kopiuje DataRow obiekty do określonego DataTable, przy użyciu obiektu wejściowego IEnumerable<T> , w którym jest T DataRowparametr generyczny.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

Cast<TResult>(IEnumerable)

Rzutuje elementy IEnumerable do określonego typu.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtruje elementy IEnumerable w oparciu o określony typ.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Włącza przetwarzanie równoległe zapytania.Enables parallelization of a query.

AsQueryable(IEnumerable)

IEnumerable KonwertujeIQueryabledo.Converts an IEnumerable to an IQueryable.

Ancestors<T>(IEnumerable<T>)

Zwraca kolekcję elementów, które zawierają elementy nadrzędne każdego węzła w kolekcji źródłowej.Returns a collection of elements that contains the ancestors of every node in the source collection.

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

Zwraca przefiltrowany kolekcji elementów, które zawierają elementy nadrzędne każdego węzła w kolekcji źródłowej.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Kolekcja zawiera tylko elementy, które XName mają zgodne.Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>)

Zwraca kolekcję węzłów podrzędnych każdego dokumentu i elementu w kolekcji źródłowej.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>)

Zwraca kolekcję elementów, które zawierają elementy podrzędne każdego elementu i dokumentu w kolekcji źródłowej.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

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

Zwraca przefiltrowany kolekcji elementów, które zawierają elementy podrzędne każdego elementu i dokumentu w kolekcji źródłowej.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Kolekcja zawiera tylko elementy, które XName mają zgodne.Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>)

Zwraca kolekcję elementów podrzędnych każdego elementu i dokumentu w kolekcji źródłowej.Returns a collection of the child elements of every element and document in the source collection.

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

Zwraca filtrowaną kolekcję elementów podrzędnych każdego elementu i dokumentu w kolekcji źródłowej.Returns a filtered collection of the child elements of every element and document in the source collection. Kolekcja zawiera tylko elementy, które XName mają zgodne.Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>)

Zwraca kolekcję węzłów, która zawiera wszystkie węzły w kolekcji źródłowej, posortowane w kolejności dokumentu.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>)

Zwraca kolekcję węzłów podrzędnych każdego dokumentu i elementu w kolekcji źródłowej.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>)

Usuwa każdy węzeł w kolekcji źródłowej z węzła nadrzędnego.Removes every node in the source collection from its parent node.

Dotyczy

Bezpieczeństwo wątkowe

Metoda Dispose nie jest bezpieczna wątkowo.The Dispose method is not thread-safe. Wszystkie inne publiczne i chronione elementy członkowskie BlockingCollection<T> są bezpieczne dla wątków i mogą być używane współbieżnie z wielu wątków.All other public and protected members of BlockingCollection<T> are thread-safe and may be used concurrently from multiple threads.

Zobacz też