ConcurrentBag<T> 클래스

정의

스레드로부터 안전한 정렬되지 않은 개체 컬렉션을 나타냅니다.Represents a thread-safe, unordered collection of objects.

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

형식 매개 변수

T

컬렉션에 저장될 요소의 형식입니다.The type of the elements to be stored in the collection.

상속
ConcurrentBag<T>
특성
구현

예제

다음 예제에서 항목 추가 및 제거 하는 방법을 보여 줍니다는 ConcurrentBag<T>:The following example shows how to add and remove items from a ConcurrentBag<T>:

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

class ConcurrentBagDemo
{
    // Demonstrates:
    //      ConcurrentBag<T>.Add()
    //      ConcurrentBag<T>.IsEmpty
    //      ConcurrentBag<T>.TryTake()
    //      ConcurrentBag<T>.TryPeek()
    static void Main()
    {
        // Add to ConcurrentBag concurrently
        ConcurrentBag<int> cb = new ConcurrentBag<int>();
        List<Task> bagAddTasks = new List<Task>();
        for (int i = 0; i < 500; i++)
        {
            var numberToAdd = i;
            bagAddTasks.Add(Task.Run(() => cb.Add(numberToAdd)));
        }

        // Wait for all tasks to complete
        Task.WaitAll(bagAddTasks.ToArray());

        // Consume the items in the bag
        List<Task> bagConsumeTasks = new List<Task>();
        int itemsInBag = 0;
        while (!cb.IsEmpty)
        {
            bagConsumeTasks.Add(Task.Run(() =>
            {
                int item;
                if (cb.TryTake(out item))
                {
                    Console.WriteLine(item);
                    itemsInBag++;
                }
            }));
        }
        Task.WaitAll(bagConsumeTasks.ToArray());

        Console.WriteLine($"There were {itemsInBag} items in the bag");

        // Checks the bag for an item
        // The bag should be empty and this should not print anything
        int unexpectedItem;
        if (cb.TryPeek(out unexpectedItem))
            Console.WriteLine("Found an item in the bag when it should be empty");
    }

}
Imports System.Collections.Concurrent

Module ConcurrentBagDemo
    ' Demonstrates:
    ' ConcurrentBag<T>.Add()
    ' ConcurrentBag<T>.IsEmpty
    ' ConcurrentBag<T>.TryTake()
    ' ConcurrentBag<T>.TryPeek()
    Sub Main()
        ' Add to ConcurrentBag concurrently
        Dim cb As New ConcurrentBag(Of Integer)()
        Dim bagAddTasks As New List(Of Task)()
        For i = 1 To 500
            Dim numberToAdd As Integer = i
            bagAddTasks.Add(Task.Run(Sub() cb.Add(numberToAdd)))
        Next

        ' Wait for all tasks to complete
        Task.WaitAll(bagAddTasks.ToArray())

        ' Consume the items in the bag
        Dim bagConsumeTasks As New List(Of Task)()
        Dim itemsInBag As Integer = 0
        While Not cb.IsEmpty
            bagConsumeTasks.Add(Task.Run(Sub()
                                             Dim item As Integer
                                             If cb.TryTake(item) Then
                                                 Console.WriteLine(item)
                                                 itemsInBag = itemsInBag + 1
                                             End If
                                         End Sub))
        End While

        Task.WaitAll(bagConsumeTasks.ToArray())

        Console.WriteLine($"There were {itemsInBag} items in the bag")

        ' Checks the bag for an item
        ' The bag should be empty and this should not print anything
        Dim unexpectedItem As Integer
        If cb.TryPeek(unexpectedItem) Then
            Console.WriteLine("Found an item in the bag when it should be empty")
        End If
    End Sub
End Module

설명

모음 순서는 중요 하지 않습니다 하 고 중복 항목을 지 원하는 백 세트와 달리 개체를 저장 하는 데 유용 합니다.Bags are useful for storing objects when ordering doesn't matter, and unlike sets, bags support duplicates. ConcurrentBag<T> 여기서 동일한 스레드에서 모두 생성 되며 모음에 저장 된 데이터를 사용 하는 시나리오에 대 한 액세스에 최적화 된, 스레드로부터 안전한 모음 구현이입니다.ConcurrentBag<T> is a thread-safe bag implementation, optimized for scenarios where the same thread will be both producing and consuming data stored in the bag.

ConcurrentBag<T> 허용 null 참조 형식에 대 한 유효한 값으로.ConcurrentBag<T> accepts null as a valid value for reference types.

자세한 내용은 FAQ 항목을 참조 하세요. .NET 블로그를 사용 하 여 병렬 프로그래밍에서 모든 새 동시 컬렉션 잠금 해제가 필요 한가요? 입니다.For more information, see the entry FAQ: Are all of the new concurrent collections lock-free? in the Parallel Programming with .NET blog.

생성자

ConcurrentBag<T>()

ConcurrentBag<T> 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the ConcurrentBag<T> class.

ConcurrentBag<T>(IEnumerable<T>)

지정된 컬렉션에서 복사한 요소가 포함된 ConcurrentBag<T> 클래스의 새 인스턴스를 초기화합니다.Initializes a new instance of the ConcurrentBag<T> class that contains elements copied from the specified collection.

속성

Count

ConcurrentBag<T>에 포함된 요소 수를 가져옵니다.Gets the number of elements contained in the ConcurrentBag<T>.

IsEmpty

ConcurrentBag<T>가 비어 있는지 여부를 나타내는 값을 가져옵니다.Gets a value that indicates whether the ConcurrentBag<T> is empty.

메서드

Add(T)

ConcurrentBag<T>에 개체를 추가합니다.Adds an object to the ConcurrentBag<T>.

Clear()

ConcurrentBag<T>에서 모든 값을 제거합니다.Removes all values from the ConcurrentBag<T>.

CopyTo(T[], Int32)

ConcurrentBag<T> 요소를 지정한 배열 인덱스에서 시작하여 기존의 1차원 Array에 복사합니다.Copies the ConcurrentBag<T> elements to an existing one-dimensional Array, starting at the specified array index.

Equals(Object)

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

(다음에서 상속됨 Object)
GetEnumerator()

ConcurrentBag<T>를 반복하는 열거자를 반환합니다.Returns an enumerator that iterates through the ConcurrentBag<T>.

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)
ToArray()

ConcurrentBag<T> 요소를 새 배열에 복사합니다.Copies the ConcurrentBag<T> elements to a new array.

ToString()

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

(다음에서 상속됨 Object)
TryPeek(T)

ConcurrentBag<T>의 개체를 제거하지 않고 반환하려고 시도합니다.Attempts to return an object from the ConcurrentBag<T> without removing it.

TryTake(T)

ConcurrentBag<T>에서 개체를 제거하고 반환하려고 시도합니다.Attempts to remove and return an object from the ConcurrentBag<T>.

명시적 인터페이스 구현

ICollection.CopyTo(Array, Int32)

특정 ICollection 인덱스부터 시작하여 Array의 요소를 Array에 복사합니다.Copies the elements of the ICollection to an Array, starting at a particular Array index.

ICollection.IsSynchronized

ICollection에 대한 액세스가 SyncRoot와 동기화되는지 여부를 나타내는 값을 가져옵니다.Gets a value indicating whether access to the ICollection is synchronized with the SyncRoot.

ICollection.SyncRoot

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

IEnumerable.GetEnumerator()

ConcurrentBag<T>를 반복하는 열거자를 반환합니다.Returns an enumerator that iterates through the ConcurrentBag<T>.

IProducerConsumerCollection<T>.TryAdd(T)

ConcurrentBag<T>에 개체를 추가하려고 시도합니다.Attempts to add an object to the ConcurrentBag<T>.

확장 메서드

CopyToDataTable<T>(IEnumerable<T>)

제네릭 매개 변수 TDataTable인 지정된 입력 DataRow 개체를 사용하여 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)

제네릭 매개 변수 TDataRow인 지정된 입력 DataTable 개체를 사용하여 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)

제네릭 매개 변수 TDataRow인 지정된 입력 DataTable 개체를 사용하여 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.

적용 대상

스레드 보안

모든 public 및 protected 멤버만 ConcurrentBag<T> 는 스레드로부터 안전 하 고 여러 스레드에서 동시에 사용할 수 있습니다.All public and protected members of ConcurrentBag<T> are thread-safe and may be used concurrently from multiple threads. 멤버 인터페이스 중 하나를 통해 액세스 하는 반면는 ConcurrentBag<T> 구현, 확장 메서드를 포함 하 여 스레드로부터의 안전성이 보장 되지 않으며 호출자가 동기화 해야 할 수 있습니다.However, members accessed through one of the interfaces the ConcurrentBag<T> implements, including extension methods, are not guaranteed to be thread safe and may need to be synchronized by the caller.

추가 정보