BlockingCollection<T> クラス

定義

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)

型パラメーター

T

コレクション内の要素の型。The type of elements in the collection.

継承
BlockingCollection<T>
属性
実装

次の例は、ブロッキングコレクションから項目を同時に追加して取得する方法を示しています。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

注釈

BlockingCollection<T> は、次の機能を提供するスレッドセーフなコレクションクラスです。BlockingCollection<T> is a thread-safe collection class that provides the following:

  • プロデューサー/コンシューマーパターンの実装。BlockingCollection<T> は、IProducerConsumerCollection<T> インターフェイスのラッパーです。An implementation of the producer/consumer pattern; BlockingCollection<T> is a wrapper for the IProducerConsumerCollection<T> interface.

  • @No__t-0 および Take の各メソッドを使用して、複数のスレッドから項目を同時に追加または削除します。Concurrent addition and removal of items from multiple threads with the Add and Take methods.

  • コレクションが full または empty の場合に Add および Take の操作をブロックする、制限されたコレクション。A bounded collection that blocks Add and Take operations when the collection is full or empty.

  • @No__t-0 または Take の操作をキャンセルするには、TryAdd または TryTake メソッドの CancellationToken オブジェクトを使用します。Cancellation of Add or Take operations by using a CancellationToken object in the TryAdd or TryTake method.

重要

この型は IDisposable インターフェイスを実装します。This type implements the IDisposable interface. 型の使用が完了したら、直接的または間接的に型を破棄する必要があります。When you have finished using the type, you should dispose of it either directly or indirectly. 直接的に型を破棄するには、try / catch ブロック内で Dispose メソッドを呼び出します。To dispose of the type directly, call its Dispose method in a try/catch block. 間接的に型を破棄するには、using (C# の場合) または Using (Visual Basic 言語) などの言語構成要素を使用します。To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). 詳細については、IDisposable インターフェイスに関するトピック内の「IDisposable を実装するオブジェクトの使用」セクションを参照してください。For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic. また、@no__t 0 のメソッドはスレッドセーフではないことに注意してください。Also, note that the Dispose() method is not thread-safe. @No__t 0 の他のすべてのパブリックメンバーとプロテクトメンバーは、スレッドセーフであり、複数のスレッドから同時に使用することができます。All other public and protected members of BlockingCollection<T> are thread-safe and may be used concurrently from multiple threads.

IProducerConsumerCollection<T> は、スレッドセーフなデータの追加と削除を可能にするコレクションを表します。IProducerConsumerCollection<T> represents a collection that allows for thread-safe adding and removal of data. BlockingCollection<T> は、IProducerConsumerCollection<T> インスタンスのラッパーとして使用され、データを削除できるようになるまでコレクションからの削除試行をブロックすることを許可します。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. 同様に、IProducerConsumerCollection<T> で許可されるデータ要素の数に上限を適用するには、@no__t 0 を作成します。コレクションへの追加の試行は、追加された項目を格納するための領域が使用可能になるまでブロックされる可能性があります。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. このように、BlockingCollection<T> は従来のブロッキングキューデータ構造に似ていますが、基になるデータストレージメカニズムが 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> はバインドとブロックに対応しています。BlockingCollection<T> supports bounding and blocking. 境界は、コレクションの最大容量を設定できることを意味します。Bounding means that you can set the maximum capacity of the collection. 境界は、特定のシナリオで重要です。これにより、メモリ内のコレクションの最大サイズを制御できるようになり、生成しているスレッドが、消費スレッドよりも先に進んでしまうのを防ぐことができます。複数のスレッドまたはタスクでコレクションに項目を同時に追加できます。コレクションが指定された最大容量に達すると、生成したスレッドは項目が削除されるまでブロックされます。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. 複数の cosumer が同時に項目を削除できます。コレクションが空になった場合、consumer スレッドは、producer が項目を追加するまでブロックします。Multiple consumers can remove items concurrently, and if the collection becomes empty, the consuming threads will block until a producer adds an item. 生成スレッドは、CompleteAdding メソッドを呼び出して、それ以上項目が追加されないことを示すことができます。A producing thread can call the CompleteAdding method to indicate that no more items will be added. consumer では、IsCompleted プロパティを監視して、コレクションが空になったときや、それ以上の項目は追加されないことになったときを把握できます。Consumers monitor the IsCompleted property to know when the collection is empty and no more items will be added.

Add および Take の操作は、通常、ループで実行されます。Add and Take operations are typically performed in a loop. ループをキャンセルするには、@no__t 0 のオブジェクトを TryAdd または TryTake のメソッドに渡し、各反復処理でトークンの IsCancellationRequested プロパティの値を確認します。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. 値が @no__t 0 の場合は、リソースをクリーンアップしてループを終了することで、キャンセル要求に応答する必要があります。If the value is true, it is up to you to respond the cancellation request by cleaning up any resources and exiting the loop.

@No__t 0 オブジェクトを作成する場合は、制限された容量だけでなく、使用するコレクションの種類を指定することもできます。When you create a BlockingCollection<T> object, you can specify not only the bounded capacity but also the type of collection to use. たとえば、先入れ先出し法 (FIFO) の動作には ConcurrentQueue<T> オブジェクトを指定し、後入れ先出し法 (LIFO) の動作には ConcurrentStack<T> オブジェクトを指定できます。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. IProducerConsumerCollection<T> インターフェイスを実装する任意のコレクション クラスを使用できます。You can use any collection class that implements the IProducerConsumerCollection<T> interface. BlockingCollection<T> の既定のコレクション型は ConcurrentQueue<T> です。The default collection type for BlockingCollection<T> is ConcurrentQueue<T>.

基になるコレクションを直接変更しないでください。Do not modify the underlying collection directly. 要素を追加または削除するには BlockingCollection<T> メソッドを使用します。Use BlockingCollection<T> methods to add or remove elements. 基になるコレクションを直接変更すると、BlockingCollection<T> オブジェクトが破損する可能性があります。The BlockingCollection<T> object can become corrupted if you change the underlying collection directly.

コンストラクター

BlockingCollection<T>()

上限を指定せずに、BlockingCollection<T> クラスの新しいインスタンスを初期化します。Initializes a new instance of the BlockingCollection<T> class without an upper-bound.

BlockingCollection<T>(Int32)

上限を指定して、BlockingCollection<T> クラスの新しいインスタンスを初期化します。Initializes a new instance of the BlockingCollection<T> class with the specified upper-bound.

BlockingCollection<T>(IProducerConsumerCollection<T>)

上限を指定せずに、指定した BlockingCollection<T> を基になるデータ ストアとして使用して、IProducerConsumerCollection<T> クラスの新しいインスタンスを初期化します。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)

上限を指定し、指定した BlockingCollection<T> を基になるデータ ストアとして使用して、IProducerConsumerCollection<T> クラスの新しいインスタンスを初期化します。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.

プロパティ

BoundedCapacity

この BlockingCollection<T> インスタンスの容量の上限。Gets the bounded capacity of this BlockingCollection<T> instance.

Count

BlockingCollection<T> に格納されている項目の数を取得します。Gets the number of items contained in the BlockingCollection<T>.

IsAddingCompleted

この BlockingCollection<T> が追加完了としてマークされているかどうかを取得します。Gets whether this BlockingCollection<T> has been marked as complete for adding.

IsCompleted

この BlockingCollection<T> が追加完了としてマークされていて、かつ空であるかどうかを取得します。Gets whether this BlockingCollection<T> has been marked as complete for adding and is empty.

メソッド

Add(T)

BlockingCollection<T> に項目を追加します。Adds the item to the BlockingCollection<T>.

Add(T, CancellationToken)

BlockingCollection<T> に項目を追加します。Adds the item to the BlockingCollection<T>.

AddToAny(BlockingCollection<T>[], T)

指定したいずれかの BlockingCollection<T> インスタンスに、指定した項目を追加します。Adds the specified item to any one of the specified BlockingCollection<T> instances.

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

指定したいずれかの BlockingCollection<T> インスタンスに、指定した項目を追加します。Adds the specified item to any one of the specified BlockingCollection<T> instances.

CompleteAdding()

それ以上追加を受け入れないように、BlockingCollection<T> インスタンスをマークします。Marks the BlockingCollection<T> instances as not accepting any more additions.

CopyTo(T[], Int32)

BlockingCollection<T> インスタンス内のすべての項目を、互換性のある 1 次元配列にコピーします。コピー操作は、コピー先の配列の、指定したインデックスから始まります。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()

BlockingCollection<T> クラスの現在のインスタンスによって使用されているすべてのリソースを解放します。Releases all resources used by the current instance of the BlockingCollection<T> class.

Dispose(Boolean)

BlockingCollection<T> インスタンスによって使用されているリソースを解放します。Releases resources used by the BlockingCollection<T> instance.

Equals(Object)

指定されたオブジェクトが現在のオブジェクトと等しいかどうかを判定します。Determines whether the specified object is equal to the current object.

(継承元 Object)
GetConsumingEnumerable()

コレクション内の項目を取り出す IEnumerator<T> を提供します。Provides a consuming IEnumerator<T> for items in the collection.

GetConsumingEnumerable(CancellationToken)

コレクション内の項目を取り出す IEnumerable<T> を提供します。Provides a consuming IEnumerable<T> for items in the collection.

GetHashCode()

既定のハッシュ関数として機能します。Serves as the default hash function.

(継承元 Object)
GetType()

現在のインスタンスの Type を取得します。Gets the Type of the current instance.

(継承元 Object)
MemberwiseClone()

現在の Object の簡易コピーを作成します。Creates a shallow copy of the current Object.

(継承元 Object)
Take()

BlockingCollection<T> から項目を削除します。Removes an item from the BlockingCollection<T>.

Take(CancellationToken)

BlockingCollection<T> から項目を削除します。Removes an item from the BlockingCollection<T>.

TakeFromAny(BlockingCollection<T>[], T)

指定したいずれかの BlockingCollection<T> インスタンスから項目を取得します。Takes an item from any one of the specified BlockingCollection<T> instances.

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

指定したキャンセル トークンを観察しながら、指定した BlockingCollection<T> インスタンスのいずれかから項目を取得します。Takes an item from any one of the specified BlockingCollection<T> instances while observing the specified cancellation token.

ToArray()

BlockingCollection<T> インスタンスの項目を新しい配列にコピーします。Copies the items from the BlockingCollection<T> instance into a new array.

ToString()

現在のオブジェクトを表す string を返します。Returns a string that represents the current object.

(継承元 Object)
TryAdd(T)

BlockingCollection<T> に対して、指定した項目の追加を試みます。Tries to add the specified item to the BlockingCollection<T>.

TryAdd(T, Int32)

指定した期間内に、BlockingCollection<T> に対して指定した項目の追加を試みます。Tries to add the specified item to the BlockingCollection<T> within the specified time period.

TryAdd(T, Int32, CancellationToken)

キャンセル トークンを観察しながら、指定した期間内に、BlockingCollection<T> に対して指定した項目の追加を試みます。Tries to add the specified item to the BlockingCollection<T> within the specified time period, while observing a cancellation token.

TryAdd(T, TimeSpan)

BlockingCollection<T> に対して、指定した項目の追加を試みます。Tries to add the specified item to the BlockingCollection<T>.

TryAddToAny(BlockingCollection<T>[], T)

指定したいずれかの BlockingCollection<T> インスタンスに対して、指定した項目の追加を試みます。Tries to add the specified item to any one of the specified BlockingCollection<T> instances.

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

指定したいずれかの BlockingCollection<T> インスタンスに対して、指定した項目の追加を試みます。Tries to add the specified item to any one of the specified BlockingCollection<T> instances.

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

指定したいずれかの BlockingCollection<T> インスタンスに対して、指定した項目の追加を試みます。Tries to add the specified item to any one of the specified BlockingCollection<T> instances.

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

指定したキャンセル トークンを観察しながら、指定したいずれかの BlockingCollection<T> インスタンスに対して指定した項目の追加を試みます。Tries to add the specified item to any one of the specified BlockingCollection<T> instances while observing the specified cancellation token.

TryTake(T)

BlockingCollection<T> から項目の削除を試みます。Tries to remove an item from the BlockingCollection<T>.

TryTake(T, Int32)

指定した期間内に、BlockingCollection<T> から項目の削除を試みます。Tries to remove an item from the BlockingCollection<T> in the specified time period.

TryTake(T, Int32, CancellationToken)

キャンセル トークンを観察しながら、指定した期間内に、BlockingCollection<T> から項目の削除を試みます。Tries to remove an item from the BlockingCollection<T> in the specified time period while observing a cancellation token.

TryTake(T, TimeSpan)

指定した期間内に、BlockingCollection<T> から項目の削除を試みます。Tries to remove an item from the BlockingCollection<T> in the specified time period.

TryTakeFromAny(BlockingCollection<T>[], T)

指定したいずれかの BlockingCollection<T> インスタンスから項目の削除を試みます。Tries to remove an item from any one of the specified BlockingCollection<T> instances.

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

指定したいずれかの BlockingCollection<T> インスタンスから項目の削除を試みます。Tries to remove an item from any one of the specified BlockingCollection<T> instances.

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

指定したいずれかの BlockingCollection<T> インスタンスから項目の削除を試みます。Tries to remove an item from any one of the specified BlockingCollection<T> instances.

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

指定したいずれかの BlockingCollection<T> インスタンスから項目の削除を試みます。Tries to remove an item from any one of the specified BlockingCollection<T> instances.

明示的なインターフェイスの実装

ICollection.CopyTo(Array, Int32)

BlockingCollection<T> インスタンス内のすべての項目を、互換性のある 1 次元配列にコピーします。コピー操作は、コピー先の配列の、指定したインデックスから始まります。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

ICollection へのアクセスが同期されている (スレッド セーフである) かどうかを示す値を取得します。Gets a value indicating whether access to the ICollection is synchronized (thread safe).

ICollection.SyncRoot

ICollection へのアクセスを同期するために使用できるオブジェクトを取得します。Gets an object that can be used to synchronize access to the ICollection. このプロパティはサポートされていません。This property is not supported.

IEnumerable.GetEnumerator()

コレクション内の項目に対する IEnumerator を提供します。Provides an IEnumerator for items in the collection.

IEnumerable<T>.GetEnumerator()

コレクション内の項目に対する IEnumerator<T> を提供します。Provides an IEnumerator<T> for items in the collection.

拡張メソッド

CopyToDataTable<T>(IEnumerable<T>)

指定した入力 DataTable オブジェクトに応じて (ジェネリック パラメーター TDataRow)、IEnumerable<T> オブジェクトのコピーを格納する DataRow を返します。Returns 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)

指定した入力 DataRow オブジェクトに応じて (ジェネリック パラメーター TDataTable)、指定した IEnumerable<T>DataRow オブジェクトをコピーします。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)

指定した入力 DataRow オブジェクトに応じて (ジェネリック パラメーター TDataTable)、指定した IEnumerable<T>DataRow オブジェクトをコピーします。Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

Cast<TResult>(IEnumerable)

IEnumerable の要素を、指定した型にキャストします。Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

指定された型に基づいて IEnumerable の要素をフィルター処理します。Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

クエリの並列化を有効にします。Enables parallelization of a query.

AsQueryable(IEnumerable)

IEnumerableIQueryable に変換します。Converts an IEnumerable to an IQueryable.

Ancestors<T>(IEnumerable<T>)

ソース コレクション内のすべてのノードの先祖が格納された、要素のコレクションを返します。Returns a collection of elements that contains the ancestors of every node in the source collection.

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

ソース コレクション内のすべてのノードの先祖が格納され、フィルター処理された要素のコレクションを返します。Returns a filtered collection of elements that contains the ancestors of every node in the source collection. 一致する XName を持つ要素のみがコレクションに含められます。Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>)

ソース コレクション内のすべてのドキュメントおよび要素の子孫ノードのコレクションを返します。Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>)

ソース コレクション内のすべての要素とドキュメントの子孫要素が格納された要素のコレクションを返します。Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

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

ソース コレクション内のすべての要素とドキュメントの子孫要素が格納され、フィルター処理された要素のコレクションを返します。Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. 一致する XName を持つ要素のみがコレクションに含められます。Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>)

ソース コレクション内のすべての要素およびドキュメントの子要素のコレクションを返します。Returns a collection of the child elements of every element and document in the source collection.

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

ソース コレクション内のすべての要素およびドキュメントの、フィルター処理された子要素のコレクションを返します。Returns a filtered collection of the child elements of every element and document in the source collection. 一致する XName を持つ要素のみがコレクションに含められます。Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>)

ソース コレクション内のすべてのノードがドキュメント順に並べ替えて格納された、ノードのコレクションを返します。Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>)

ソース コレクション内のすべてのドキュメントおよび要素の子ノードのコレクションを返します。Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>)

ソース コレクション内の親ノードからすべてのノードを削除します。Removes every node in the source collection from its parent node.

適用対象

スレッド セーフ

Dispose メソッドはスレッドセーフではありません。The Dispose method is not thread-safe. @No__t 0 の他のすべてのパブリックメンバーとプロテクトメンバーは、スレッドセーフであり、複数のスレッドから同時に使用することができます。All other public and protected members of BlockingCollection<T> are thread-safe and may be used concurrently from multiple threads.

こちらもご覧ください