BlockingCollection<T> BlockingCollection<T> BlockingCollection<T> BlockingCollection<T> Class

정의

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>BlockingCollection<T>BlockingCollection<T>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:

중요

이 형식이 구현 하는 IDisposable 인터페이스입니다.This type implements the IDisposable interface. 형식을 사용 하 여 마쳤으면 직접 또는 간접적으로의 삭제 해야 있습니다.When you have finished using the type, you should dispose of it either directly or indirectly. 직접 형식의 dispose 호출 해당 Dispose 의 메서드를 try / catch 블록입니다.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. 또한는 Dispose() 메서드는 스레드로부터 안전 하지 않습니다.Also, note that the Dispose() method is not thread-safe. 다른 모든 public 및 protected 멤버만 BlockingCollection<T> 는 스레드로부터 안전 하 고 여러 스레드에서 동시에 사용할 수 있습니다.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. 마찬가지로, 만들 수 있습니다는 BlockingCollection<T> 에 허용 되는 데이터 요소의 수에 상한값을 적용 하는 IProducerConsumerCollection<T>; 공간 추가 항목을 저장할 수 있을 때까지 컬렉션에 추가 시도 차단 될 수 있습니다.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. 여러 소비자에서 항목을 동시에 제거할 수 있습니다. 컬렉션이 비어 있는 경우 공급자가 항목 하나를 추가할 때까지 소비자 스레드를 차단합니다.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. 소비자 스레드는 컬렉션이 비어 있고 항목이 더 이상 추가되지 않는 시점을 파악하기 위해 IsCompleted 속성을 모니터링합니다.Consumers monitor the IsCompleted property to know when the collection is empty and no more items will be added.

AddTake 루프 작업은 일반적으로 수행 합니다.Add and Take operations are typically performed in a loop. 전달 하 여 루프를 취소할 수 있습니다는 CancellationToken 개체를 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. 값이 true, 모든 리소스를 정리 하 고 루프를 종료 하 여 취소 요청에 응답 하는 것입니다.If the value is true, it is up to you to respond the cancellation request by cleaning up any resources and exiting the loop.

만들 때를 BlockingCollection<T> 개체 한계 용량 뿐만 아니라 컬렉션의 형식을 사용 하도록 지정할 수 있습니다.When you create a BlockingCollection<T> object, you can specify not only the bounded capacity but also the type of collection to use. 예를 들어 지정할 수 있습니다는 ConcurrentQueue<T> FIFO (선입 선출) 동작의 첫 번째에 대 한 개체 또는 ConcurrentStack<T> 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. 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>() BlockingCollection<T>() BlockingCollection<T>()

상한을 사용하지 않고 BlockingCollection<T> 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the BlockingCollection<T> class without an upper-bound.

BlockingCollection<T>(Int32) BlockingCollection<T>(Int32) BlockingCollection<T>(Int32) 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>) BlockingCollection<T>(IProducerConsumerCollection<T>) 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>, Int32) BlockingCollection<T>(IProducerConsumerCollection<T>, Int32) 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 BoundedCapacity BoundedCapacity BoundedCapacity

BlockingCollection<T> 인스턴스의 한계 용량을 가져옵니다.Gets the bounded capacity of this BlockingCollection<T> instance.

Count Count Count Count

BlockingCollection<T>에 들어 있는 항목 수를 가져옵니다.Gets the number of items contained in the BlockingCollection<T>.

IsAddingCompleted IsAddingCompleted IsAddingCompleted IsAddingCompleted

BlockingCollection<T>이 추가에 대해 완료 상태로 표시되었는지 여부를 가져옵니다.Gets whether this BlockingCollection<T> has been marked as complete for adding.

IsCompleted IsCompleted IsCompleted IsCompleted

BlockingCollection<T>이 추가에 대해 완료 상태로 표시되었으며 비어 있는지 여부를 가져옵니다.Gets whether this BlockingCollection<T> has been marked as complete for adding and is empty.

메서드

Add(T) Add(T) Add(T) Add(T)

BlockingCollection<T>에 항목을 추가합니다.Adds the item to the BlockingCollection<T>.

Add(T, CancellationToken) Add(T, CancellationToken) Add(T, CancellationToken) Add(T, CancellationToken)

BlockingCollection<T>에 항목을 추가합니다.Adds the item to the BlockingCollection<T>.

AddToAny(BlockingCollection<T>[], T) AddToAny(BlockingCollection<T>[], T) AddToAny(BlockingCollection<T>[], 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) AddToAny(BlockingCollection<T>[], T, CancellationToken) AddToAny(BlockingCollection<T>[], T, CancellationToken) AddToAny(BlockingCollection<T>[], T, CancellationToken)

지정된 BlockingCollection<T> 인스턴스 중 하나에 지정된 항목을 추가합니다.Adds the specified item to any one of the specified BlockingCollection<T> instances.

CompleteAdding() CompleteAdding() CompleteAdding() CompleteAdding()

BlockingCollection<T> 인스턴스를 더 이상 추가를 허용하지 않는 상태로 표시합니다.Marks the BlockingCollection<T> instances as not accepting any more additions.

CopyTo(T[], Int32) CopyTo(T[], Int32) CopyTo(T[], Int32) 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() Dispose() Dispose() Dispose()

BlockingCollection<T> 클래스의 현재 인스턴스에서 사용하는 모든 리소스를 해제합니다.Releases all resources used by the current instance of the BlockingCollection<T> class.

Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) Dispose(Boolean)

BlockingCollection<T> 인스턴스에서 사용하는 리소스를 해제합니다.Releases resources used by the BlockingCollection<T> instance.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

지정한 개체와 현재 개체가 같은지 여부를 확인합니다.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetConsumingEnumerable() GetConsumingEnumerable() GetConsumingEnumerable() GetConsumingEnumerable()

컬렉션에 있는 항목에 사용하는 IEnumerator<T>을 제공합니다.Provides a consuming IEnumerator<T> for items in the collection.

GetConsumingEnumerable(CancellationToken) GetConsumingEnumerable(CancellationToken) GetConsumingEnumerable(CancellationToken) GetConsumingEnumerable(CancellationToken)

컬렉션에 있는 항목에 사용하는 IEnumerable<T>을 제공합니다.Provides a consuming IEnumerable<T> for items in the collection.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

기본 해시 함수로 작동합니다.Serves as the default hash function.

(Inherited from Object)
GetType() GetType() GetType() GetType()

현재 인스턴스의 Type을 가져옵니다.Gets the Type of the current instance.

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

현재 Object의 단순 복사본을 만듭니다.Creates a shallow copy of the current Object.

(Inherited from Object)
Take() Take() Take() Take()

BlockingCollection<T>에서 항목을 제거합니다.Removes an item from the BlockingCollection<T>.

Take(CancellationToken) Take(CancellationToken) Take(CancellationToken) Take(CancellationToken)

BlockingCollection<T>에서 항목을 제거합니다.Removes an item from the BlockingCollection<T>.

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

지정된 BlockingCollection<T> 인스턴스 중 하나에서 항목을 빼냅니다.Takes an item from any one of the specified BlockingCollection<T> instances.

TakeFromAny(BlockingCollection<T>[], T, CancellationToken) TakeFromAny(BlockingCollection<T>[], T, CancellationToken) TakeFromAny(BlockingCollection<T>[], T, CancellationToken) 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() ToArray() ToArray() ToArray()

BlockingCollection<T> 인스턴스의 항목을 새 배열로 복사합니다.Copies the items from the BlockingCollection<T> instance into a new array.

ToString() ToString() ToString() ToString()

현재 개체를 나타내는 문자열을 반환합니다.Returns a string that represents the current object.

(Inherited from Object)
TryAdd(T) TryAdd(T) TryAdd(T) TryAdd(T)

BlockingCollection<T>에 지정된 항목을 추가하려고 시도합니다.Tries to add the specified item to the BlockingCollection<T>.

TryAdd(T, Int32) TryAdd(T, Int32) TryAdd(T, Int32) TryAdd(T, Int32)

지정된 시간 안에 지정된 항목을 BlockingCollection<T>에 추가하려고 시도합니다.Tries to add the specified item to the BlockingCollection<T> within the specified time period.

TryAdd(T, Int32, CancellationToken) TryAdd(T, Int32, CancellationToken) TryAdd(T, Int32, CancellationToken) 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) TryAdd(T, TimeSpan) TryAdd(T, TimeSpan) TryAdd(T, TimeSpan)

BlockingCollection<T>에 지정된 항목을 추가하려고 시도합니다.Tries to add the specified item to the BlockingCollection<T>.

TryAddToAny(BlockingCollection<T>[], T) TryAddToAny(BlockingCollection<T>[], T) TryAddToAny(BlockingCollection<T>[], 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) TryAddToAny(BlockingCollection<T>[], T, Int32) TryAddToAny(BlockingCollection<T>[], T, Int32) 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) TryAddToAny(BlockingCollection<T>[], T, Int32, CancellationToken) TryAddToAny(BlockingCollection<T>[], T, Int32, CancellationToken) 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) TryAddToAny(BlockingCollection<T>[], T, TimeSpan) TryAddToAny(BlockingCollection<T>[], T, TimeSpan) 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) TryTake(T) TryTake(T) TryTake(T)

BlockingCollection<T>에서 항목을 제거하려고 시도합니다.Tries to remove an item from the BlockingCollection<T>.

TryTake(T, Int32) TryTake(T, Int32) TryTake(T, Int32) TryTake(T, Int32)

지정된 시간 안에 BlockingCollection<T>에서 항목을 제거하려고 시도합니다.Tries to remove an item from the BlockingCollection<T> in the specified time period.

TryTake(T, Int32, CancellationToken) TryTake(T, Int32, CancellationToken) TryTake(T, Int32, CancellationToken) 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) TryTake(T, TimeSpan) TryTake(T, TimeSpan) TryTake(T, TimeSpan)

지정된 시간 안에 BlockingCollection<T>에서 항목을 제거하려고 시도합니다.Tries to remove an item from the BlockingCollection<T> in the specified time period.

TryTakeFromAny(BlockingCollection<T>[], T) TryTakeFromAny(BlockingCollection<T>[], T) TryTakeFromAny(BlockingCollection<T>[], T) 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) TryTakeFromAny(BlockingCollection<T>[], T, Int32) TryTakeFromAny(BlockingCollection<T>[], T, Int32) 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) TryTakeFromAny(BlockingCollection<T>[], T, Int32, CancellationToken) TryTakeFromAny(BlockingCollection<T>[], T, Int32, CancellationToken) 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) TryTakeFromAny(BlockingCollection<T>[], T, TimeSpan) TryTakeFromAny(BlockingCollection<T>[], T, TimeSpan) 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) ICollection.CopyTo(Array, Int32) ICollection.CopyTo(Array, Int32) 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.IsSynchronized ICollection.IsSynchronized ICollection.IsSynchronized

ICollection에 대한 액세스가 동기화되어 스레드로부터 안전하게 보호되는지를 나타내는 값을 가져옵니다.Gets a value indicating whether access to the ICollection is synchronized (thread safe).

ICollection.SyncRoot ICollection.SyncRoot ICollection.SyncRoot ICollection.SyncRoot

ICollection에 대한 액세스를 동기화하는 데 사용할 수 있는 개체를 가져옵니다.Gets an object that can be used to synchronize access to the ICollection. 이 속성이 지원되지 않는 경우This property is not supported.

IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator()

컬렉션에 있는 항목에 대한 IEnumerator을 제공합니다.Provides an IEnumerator for items in the collection.

IEnumerable<T>.GetEnumerator() IEnumerable<T>.GetEnumerator() IEnumerable<T>.GetEnumerator() IEnumerable<T>.GetEnumerator()

컬렉션에 있는 항목에 대한 IEnumerator<T>을 제공합니다.Provides an IEnumerator<T> for items in the collection.

Extension Methods

CopyToDataTable<T>(IEnumerable<T>) CopyToDataTable<T>(IEnumerable<T>) CopyToDataTable<T>(IEnumerable<T>) CopyToDataTable<T>(IEnumerable<T>)

반환을 DataTable 복사본이 들어 있는 DataRow 개체를 지정 된 입력 IEnumerable<T> 개체는 제네릭 매개 변수 TDataRow.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) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)

복사본 DataRow 지정 된 개체 DataTable, 지정 된 입력 IEnumerable<T> 개체는 제네릭 매개 변수 TDataRow합니다.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) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)

복사본 DataRow 지정 된 개체 DataTable, 지정 된 입력 IEnumerable<T> 개체는 제네릭 매개 변수 TDataRow합니다.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable)

IEnumerable의 요소를 지정된 형식으로 캐스팅합니다.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable)

지정된 형식에 따라 IEnumerable의 요소를 필터링합니다.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable)

쿼리를 병렬화할 수 있도록 합니다.Enables parallelization of a query.

AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable)

변환를 IEnumerableIQueryable합니다.Converts an IEnumerable to an IQueryable.

Ancestors<T>(IEnumerable<T>) Ancestors<T>(IEnumerable<T>) Ancestors<T>(IEnumerable<T>) 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) Ancestors<T>(IEnumerable<T>, XName) Ancestors<T>(IEnumerable<T>, XName) 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>) DescendantNodes<T>(IEnumerable<T>) DescendantNodes<T>(IEnumerable<T>) DescendantNodes<T>(IEnumerable<T>)

소스 컬렉션에 있는 모든 문서 및 요소의 하위 노드 컬렉션을 반환합니다.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>) Descendants<T>(IEnumerable<T>) Descendants<T>(IEnumerable<T>) 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) Descendants<T>(IEnumerable<T>, XName) Descendants<T>(IEnumerable<T>, XName) 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>) Elements<T>(IEnumerable<T>) Elements<T>(IEnumerable<T>) 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) Elements<T>(IEnumerable<T>, XName) Elements<T>(IEnumerable<T>, XName) 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>) InDocumentOrder<T>(IEnumerable<T>) InDocumentOrder<T>(IEnumerable<T>) 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>) Nodes<T>(IEnumerable<T>) Nodes<T>(IEnumerable<T>) Nodes<T>(IEnumerable<T>)

소스 컬렉션에 있는 모든 문서 및 요소의 자식 노드 컬렉션을 반환합니다.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>) Remove<T>(IEnumerable<T>) Remove<T>(IEnumerable<T>) Remove<T>(IEnumerable<T>)

부모 노드에서 소스 컬렉션의 모든 노드를 제거합니다.Removes every node in the source collection from its parent node.

적용 대상

스레드 보안

Dispose 메서드에서 스레드로부터 안전한 아닙니다.The Dispose method is not thread-safe. 다른 모든 public 및 protected 멤버만 BlockingCollection<T> 는 스레드로부터 안전 하 고 여러 스레드에서 동시에 사용할 수 있습니다.All other public and protected members of BlockingCollection<T> are thread-safe and may be used concurrently from multiple threads.

추가 정보