ConcurrentBag<T> Clase

Definición

Representa una colección de objetos desordenada y segura para subprocesos.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)

Parámetros de tipo

T

Tipo de los elementos que se van a almacenar en la colección.The type of the elements to be stored in the collection.

Herencia
ConcurrentBag<T>
Atributos
Implementaciones

Ejemplos

En el ejemplo siguiente se muestra cómo agregar y quitar elementos de una 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

Comentarios

Los contenedores son útiles para almacenar objetos cuando el orden no es importante y, a diferencia de los conjuntos, los contenedores admiten duplicados.Bags are useful for storing objects when ordering doesn't matter, and unlike sets, bags support duplicates. ConcurrentBag<T> es una implementación de contenedor segura para subprocesos, optimizada para escenarios en los que el mismo subproceso va a generar y consumir datos almacenados en el contenedor.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> acepta null como un valor válido para los tipos de referencia.ConcurrentBag<T> accepts null as a valid value for reference types.

Para obtener más información, vea las preguntas más frecuentes sobre las entradas: ¿son todas las nuevas colecciones simultáneas sin bloqueo? en el blog de programación en paralelo con .net.For more information, see the entry FAQ: Are all of the new concurrent collections lock-free? in the Parallel Programming with .NET blog.

Constructores

ConcurrentBag<T>()

Inicializa una nueva instancia de la clase ConcurrentBag<T>.Initializes a new instance of the ConcurrentBag<T> class.

ConcurrentBag<T>(IEnumerable<T>)

Inicializa una nueva instancia de la clase ConcurrentBag<T> que contiene los elementos copiados de la colección especificada.Initializes a new instance of the ConcurrentBag<T> class that contains elements copied from the specified collection.

Propiedades

Count

Obtiene el número de elementos incluidos en ConcurrentBag<T>.Gets the number of elements contained in the ConcurrentBag<T>.

IsEmpty

Obtiene un valor que indica si la colección ConcurrentBag<T> está vacía.Gets a value that indicates whether the ConcurrentBag<T> is empty.

Métodos

Add(T)

Agrega un objeto a ConcurrentBag<T>.Adds an object to the ConcurrentBag<T>.

Clear()

Quita todos los valores de ConcurrentBag<T>.Removes all values from the ConcurrentBag<T>.

CopyTo(T[], Int32)

Copia los elementos de ConcurrentBag<T> en una Array unidimensional existente, a partir del índice especificado de la matriz.Copies the ConcurrentBag<T> elements to an existing one-dimensional Array, starting at the specified array index.

Equals(Object)

Determina si el objeto especificado es igual al objeto actual.Determines whether the specified object is equal to the current object.

(Heredado de Object)
GetEnumerator()

Devuelve un enumerador que itera en ConcurrentBag<T>.Returns an enumerator that iterates through the ConcurrentBag<T>.

GetHashCode()

Sirve como función hash predeterminada.Serves as the default hash function.

(Heredado de Object)
GetType()

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

(Heredado de Object)
MemberwiseClone()

Crea una copia superficial del Object actual.Creates a shallow copy of the current Object.

(Heredado de Object)
ToArray()

Copia los elementos de ConcurrentBag<T> en una nueva matriz.Copies the ConcurrentBag<T> elements to a new array.

ToString()

Devuelve un valor de tipo string que representa el objeto actual.Returns a string that represents the current object.

(Heredado de Object)
TryPeek(T)

Intenta devolver un objeto de ConcurrentBag<T> sin quitarlo.Attempts to return an object from the ConcurrentBag<T> without removing it.

TryTake(T)

Intenta quitar y devolver un objeto de ConcurrentBag<T>.Attempts to remove and return an object from the ConcurrentBag<T>.

Implementaciones de interfaz explícitas

ICollection.CopyTo(Array, Int32)

Copia los elementos de ICollection en Array, empezando por un índice determinado de Array .Copies the elements of the ICollection to an Array, starting at a particular Array index.

ICollection.IsSynchronized

Obtiene un valor que indica si el acceso a la interfaz ICollection está sincronizado con SyncRoot.Gets a value indicating whether access to the ICollection is synchronized with the SyncRoot.

ICollection.SyncRoot

Obtiene un objeto que se puede usar para sincronizar el acceso a ICollection.Gets an object that can be used to synchronize access to the ICollection. Esta propiedad no es compatible.This property is not supported.

IEnumerable.GetEnumerator()

Devuelve un enumerador que itera en ConcurrentBag<T>.Returns an enumerator that iterates through the ConcurrentBag<T>.

IProducerConsumerCollection<T>.TryAdd(T)

Intenta agregar un objeto a ConcurrentBag<T>.Attempts to add an object to the ConcurrentBag<T>.

Métodos de extensión

CopyToDataTable<T>(IEnumerable<T>)

Devuelve un objeto DataTable que contiene copias de los objetos DataRow, dado un objeto IEnumerable<T> de entrada donde el parámetro T genérico es 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)

Copia objetos DataRow en el objeto DataTable especificado, dado un objeto IEnumerable<T> de entrada donde el parámetro T genérico es 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)

Copia objetos DataRow en el objeto DataTable especificado, dado un objeto IEnumerable<T> de entrada donde el parámetro T genérico es DataRow.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

Cast<TResult>(IEnumerable)

Convierte los elementos de IEnumerable en el tipo especificado.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtra los elementos de IEnumerable en función de un tipo especificado.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Habilita la paralelización de una consulta.Enables parallelization of a query.

AsQueryable(IEnumerable)

Convierte una interfaz IEnumerable en IQueryable.Converts an IEnumerable to an IQueryable.

Ancestors<T>(IEnumerable<T>)

Devuelve una colección de elementos que contiene los antecesores de todos los nodos de la colección de origen.Returns a collection of elements that contains the ancestors of every node in the source collection.

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

Devuelve una colección de elementos filtrada que contiene los antecesores de todos los nodos de la colección de origen.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. En la colección sólo se incluyen los elementos que tienen un objeto XName coincidente.Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>)

Devuelve una colección de los nodos descendientes de todos los documentos y elementos de la colección de origen.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>)

Devuelve una colección de elementos que contiene los elementos descendientes de todos los elementos y documentos de la colección de origen.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

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

Devuelve una colección filtrada de elementos que contiene los elementos descendientes de todos los elementos y documentos de la colección de origen.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. En la colección sólo se incluyen los elementos que tienen un objeto XName coincidente.Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>)

Devuelve una colección de los elementos secundarios de todos los elementos y documentos de la colección de origen.Returns a collection of the child elements of every element and document in the source collection.

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

Devuelve una colección filtrada de los elementos secundarios de todos los elementos y documentos de la colección de origen.Returns a filtered collection of the child elements of every element and document in the source collection. En la colección sólo se incluyen los elementos que tienen un objeto XName coincidente.Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>)

Devuelve una colección de nodos que contiene todos los nodos de la colección de origen, clasificados por documento.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>)

Devuelve una colección de los nodos secundarios de todos los documentos y elementos de la colección de origen.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>)

Quita todos los nodos de la colección de origen de su nodo primario.Removes every node in the source collection from its parent node.

Se aplica a

Seguridad para subprocesos

Todos los miembros públicos y protegidos de ConcurrentBag<T> son seguros para subprocesos y se pueden usar simultáneamente desde varios subprocesos.All public and protected members of ConcurrentBag<T> are thread-safe and may be used concurrently from multiple threads. Sin embargo, no se garantiza que los miembros a los que se tiene acceso a través de una de las interfaces que implementa el ConcurrentBag<T>, incluidos los métodos de extensión, sean seguros para subprocesos y que el llamador deba sincronizarlos.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.

Consulte también: