ConcurrentBag<T> Klasa

Definicja

Reprezentuje bezpieczną wątkowo, nieuporządkowaną kolekcję obiektów.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)

Parametry typu

T

Typ elementów, które mają być przechowywane w kolekcji.The type of the elements to be stored in the collection.

Dziedziczenie
ConcurrentBag<T>
Atrybuty
Implementuje

Przykłady

Poniższy przykład pokazuje, jak dodawać i usuwać elementy z 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

Uwagi

Torby są przydatne do przechowywania obiektów, gdy porządkowanie nie ma znaczenia, a w przeciwieństwie do zestawów, torby obsługują duplikaty.Bags are useful for storing objects when ordering doesn't matter, and unlike sets, bags support duplicates. ConcurrentBag<T> to implementacja bezpiecznego zbioru wątków, zoptymalizowana pod kątem scenariuszy, w których ten sam wątek będzie generował i zużywał dane przechowywane w zbiorze.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> akceptuje null jako prawidłową wartość dla typów referencyjnych.ConcurrentBag<T> accepts null as a valid value for reference types.

Aby uzyskać więcej informacji, zobacz temat często zadawane pytania: czy wszystkie nowe współbieżne kolekcje są wolne od blokady? w programie równoległe Programowanie przy użyciu platformy .NET.For more information, see the entry FAQ: Are all of the new concurrent collections lock-free? in the Parallel Programming with .NET blog.

Konstruktory

ConcurrentBag<T>()

Inicjuje nowe wystąpienie klasy ConcurrentBag<T>.Initializes a new instance of the ConcurrentBag<T> class.

ConcurrentBag<T>(IEnumerable<T>)

Inicjuje nowe wystąpienie klasy ConcurrentBag<T>, która zawiera elementy skopiowane z określonej kolekcji.Initializes a new instance of the ConcurrentBag<T> class that contains elements copied from the specified collection.

Właściwości

Count

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

IsEmpty

Pobiera wartość wskazującą, czy ConcurrentBag<T> jest pusta.Gets a value that indicates whether the ConcurrentBag<T> is empty.

Metody

Add(T)

Dodaje obiekt do ConcurrentBag<T>.Adds an object to the ConcurrentBag<T>.

Clear()

Usuwa wszystkie wartości z ConcurrentBag<T>.Removes all values from the ConcurrentBag<T>.

CopyTo(T[], Int32)

Kopiuje ConcurrentBag<T> elementy do istniejącego Array jednowymiarowego, rozpoczynając od określonego indeksu tablicy.Copies the ConcurrentBag<T> elements to an existing one-dimensional Array, starting at the specified array index.

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

Zwraca moduł wyliczający, który wykonuje iterację przez ConcurrentBag<T>.Returns an enumerator that iterates through the ConcurrentBag<T>.

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

Kopiuje elementy ConcurrentBag<T> do nowej tablicy.Copies the ConcurrentBag<T> elements to a new array.

ToString()

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

(Odziedziczone po Object)
TryPeek(T)

Próbuje zwrócić obiekt z ConcurrentBag<T> bez usuwania go.Attempts to return an object from the ConcurrentBag<T> without removing it.

TryTake(T)

Próbuje usunąć i zwrócić obiekt z ConcurrentBag<T>.Attempts to remove and return an object from the ConcurrentBag<T>.

Jawne implementacje interfejsu

ICollection.CopyTo(Array, Int32)

Kopiuje elementy ICollection do Array, zaczynając od określonego indeksu Array.Copies the elements of the ICollection to an Array, starting at a particular Array index.

ICollection.IsSynchronized

Pobiera wartość wskazującą, czy dostęp do ICollection jest synchronizowany z SyncRoot.Gets a value indicating whether access to the ICollection is synchronized with the SyncRoot.

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

Zwraca moduł wyliczający, który wykonuje iterację przez ConcurrentBag<T>.Returns an enumerator that iterates through the ConcurrentBag<T>.

IProducerConsumerCollection<T>.TryAdd(T)

Próbuje dodać obiekt do ConcurrentBag<T>.Attempts to add an object to the ConcurrentBag<T>.

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

Wszystkie publiczne i chronione elementy członkowskie ConcurrentBag<T> są bezpieczne dla wątków i mogą być używane współbieżnie z wielu wątków.All public and protected members of ConcurrentBag<T> are thread-safe and may be used concurrently from multiple threads. Jednak do członków, do których uzyskuje się dostęp za pomocą jednego z interfejsów, implementacje ConcurrentBag<T>, w tym metody rozszerzające, nie będą gwarantowane bezpieczny wątkowo i może być konieczne ich zsynchronizowanie przez obiekt wywołujący.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.

Zobacz też