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

Definizione

Fornisce funzionalità di blocco e limitazione per le raccolte thread-safe che implementano 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)

Parametri di tipo

T

Tipo di elementi contenuti nella raccolta.The type of elements in the collection.

Ereditarietà
BlockingCollection<T>BlockingCollection<T>BlockingCollection<T>BlockingCollection<T>
Attributi
Implementazioni

Esempi

Nell'esempio seguente viene illustrato come aggiungere e rimuovere elementi contemporaneamente da una raccolta di blocco: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

Commenti

BlockingCollection<T> è una classe di raccolta thread-safe che offre quanto segue:BlockingCollection<T> is a thread-safe collection class that provides the following:

Importante

Questo tipo implementa la IDisposable interfaccia.This type implements the IDisposable interface. Dopo aver utilizzato il tipo, è necessario eliminarlo direttamente o indirettamente.When you have finished using the type, you should dispose of it either directly or indirectly. Per eliminare il tipo direttamente, chiamare relativi Dispose metodo in un try / catch blocco.To dispose of the type directly, call its Dispose method in a try/catch block. Per eliminarlo indirettamente, utilizzare un costrutto di linguaggio come ad esempio using in C# o Using in Visual Basic.To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Per altre informazioni, vedere la sezione "Utilizzo di oggetti che implementano IDisposable" nel IDisposable argomento relativo all'interfaccia.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic. Si noti inoltre che il Dispose() (metodo) non è thread-safe.Also, note that the Dispose() method is not thread-safe. Tutti gli altri membri pubblici e protetti della BlockingCollection<T> sono thread-safe e possono essere utilizzati contemporaneamente da più thread.All other public and protected members of BlockingCollection<T> are thread-safe and may be used concurrently from multiple threads.

IProducerConsumerCollection<T> rappresenta una raccolta che consente di aggiungere thread-safe e rimozione dei dati.IProducerConsumerCollection<T> represents a collection that allows for thread-safe adding and removal of data. BlockingCollection<T> viene usata come wrapper per un IProducerConsumerCollection<T> dell'istanza e consente tentativi di rimozione dalla raccolta bloccare fino a quando non sono disponibili dati per essere rimosso.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. Analogamente, è possibile creare un BlockingCollection<T> per imporre un limite massimo per il numero di elementi di dati consentiti nella IProducerConsumerCollection<T>; i tentativi di aggiunta alla raccolta possono quindi si bloccano fino a quando non è disponibile spazio per archiviare gli elementi aggiunti.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. In questo modo BlockingCollection<T> è simile a una struttura dei dati di coda di blocco tradizionali, ad eccezione del fatto che il meccanismo di archiviazione dati sottostante è astratta come un 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> supporta delimitazione e blocco.BlockingCollection<T> supports bounding and blocking. Rettangolo di selezione significa che è possibile impostare la capacità massima della raccolta.Bounding means that you can set the maximum capacity of the collection. Delimitazione è importante in determinati scenari poiché consente di controllare la dimensione massima della raccolta in memoria e impedisce il thread producer di spostarsi troppo oltre i thread consumer. Più thread o attività possono aggiungere contemporaneamente elementi alla raccolta e se la raccolta raggiunge la capacità massima specificata, il thread producer si bloccano fino a quando non viene rimosso un elemento.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. Più Consumer possono rimuovere contemporaneamente elementi e quando la raccolta diventa vuota, i thread Consumer si bloccano fino a quando un Producer aggiunge un elemento.Multiple consumers can remove items concurrently, and if the collection becomes empty, the consuming threads will block until a producer adds an item. Un thread producer può chiamare il CompleteAdding metodo per indicare che nessun ulteriore elemento verrà aggiunto.A producing thread can call the CompleteAdding method to indicate that no more items will be added. I Consumer monitorano la proprietà IsCompleted per sapere quando la raccolta è vuota e non verranno aggiunti altri elementi.Consumers monitor the IsCompleted property to know when the collection is empty and no more items will be added.

Add e Take operazioni vengono in genere eseguite in un ciclo.Add and Take operations are typically performed in a loop. È possibile annullare un ciclo passando un CancellationToken dell'oggetto per il TryAdd oppure TryTake (metodo) e quindi controllando il valore del token di IsCancellationRequested proprietà a ogni iterazione.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. Se il valore è true, è responsabilità dell'utente per rispondere alla richiesta di annullamento cancellando tutte le risorse e uscendo dal ciclo.If the value is true, it is up to you to respond the cancellation request by cleaning up any resources and exiting the loop.

Quando si crea un BlockingCollection<T> oggetto, è possibile specificare non solo la capacità delimitata ma anche il tipo di raccolta da usare.When you create a BlockingCollection<T> object, you can specify not only the bounded capacity but also the type of collection to use. Ad esempio, è possibile specificare un oggetto ConcurrentQueue<T> per il comportamento FIFO (First In, First Out) o un oggetto ConcurrentStack<T> per il comportamento LIFO (Last In, First Out).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. È possibile usare qualsiasi classe di raccolta che implementa l'interfaccia IProducerConsumerCollection<T>.You can use any collection class that implements the IProducerConsumerCollection<T> interface. Il tipo di raccolta predefinito per BlockingCollection<T> è ConcurrentQueue<T>.The default collection type for BlockingCollection<T> is ConcurrentQueue<T>.

Non modificare direttamente la raccolta sottostante.Do not modify the underlying collection directly. Usare BlockingCollection<T> metodi per aggiungere o rimuovere elementi.Use BlockingCollection<T> methods to add or remove elements. Il BlockingCollection<T> oggetto può risultare danneggiato se si modifica direttamente la raccolta sottostante.The BlockingCollection<T> object can become corrupted if you change the underlying collection directly.

Costruttori

BlockingCollection<T>() BlockingCollection<T>() BlockingCollection<T>() BlockingCollection<T>()

Inizializza una nuova istanza della classe BlockingCollection<T> senza un limite superiore.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)

Inizializza una nuova istanza della classe BlockingCollection<T> con il limite superiore specificato.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>)

Inizializza una nuova istanza della classe BlockingCollection<T> senza un limite superiore e usando l'oggetto IProducerConsumerCollection<T> fornito come archivio dati sottostante.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)

Inizializza una nuova istanza della classe BlockingCollection<T> con il limite superiore specificato e usando l'oggetto IProducerConsumerCollection<T> fornito come archivio dati sottostante.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.

Proprietà

BoundedCapacity BoundedCapacity BoundedCapacity BoundedCapacity

Ottiene un valore che indica la capacità delimitata di questa istanza di BlockingCollection<T>.Gets the bounded capacity of this BlockingCollection<T> instance.

Count Count Count Count

Ottiene il numero di elementi contenuti nella classe BlockingCollection<T>.Gets the number of items contained in the BlockingCollection<T>.

IsAddingCompleted IsAddingCompleted IsAddingCompleted IsAddingCompleted

Ottiene un valore che indica se questo oggetto BlockingCollection<T> è stato contrassegnato come completo per l'aggiunta.Gets whether this BlockingCollection<T> has been marked as complete for adding.

IsCompleted IsCompleted IsCompleted IsCompleted

Ottiene un valore che indica se questo oggetto BlockingCollection<T> è stato contrassegnato come completo per l'aggiunta ed è vuoto.Gets whether this BlockingCollection<T> has been marked as complete for adding and is empty.

Metodi

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

Aggiunge l'elemento all'oggetto BlockingCollection<T>.Adds the item to the BlockingCollection<T>.

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

Aggiunge l'elemento all'oggetto 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)

Aggiunge l'elemento specificato a una qualsiasi delle istanze di BlockingCollection<T> specificate.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)

Aggiunge l'elemento specificato a una qualsiasi delle istanze di BlockingCollection<T> specificate.Adds the specified item to any one of the specified BlockingCollection<T> instances.

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

Contrassegna le istanze di BlockingCollection<T> per non accettare più alcuna aggiunta.Marks the BlockingCollection<T> instances as not accepting any more additions.

CopyTo(T[], Int32) CopyTo(T[], Int32) CopyTo(T[], Int32) CopyTo(T[], Int32)

Copia tutti gli elementi dell'istanza di BlockingCollection<T> in una matrice unidimensionale compatibile, a partire dall'indice specificato della matrice di destinazione.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()

Rilascia tutte le risorse usate dall'istanza corrente della classe BlockingCollection<T>.Releases all resources used by the current instance of the BlockingCollection<T> class.

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

Rilascia risorse usate dall'istanza di BlockingCollection<T>.Releases resources used by the BlockingCollection<T> instance.

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

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

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

Fornisce un oggetto IEnumerator<T> usato per gli elementi nella raccolta.Provides a consuming IEnumerator<T> for items in the collection.

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

Fornisce un oggetto IEnumerable<T> usato per gli elementi nella raccolta.Provides a consuming IEnumerable<T> for items in the collection.

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

Funge da funzione hash predefinita.Serves as the default hash function.

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

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

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

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

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

Rimuove un elemento da BlockingCollection<T>.Removes an item from the BlockingCollection<T>.

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

Rimuove un elemento da 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)

Preleva un elemento da una delle istanze di BlockingCollection<T> specificate.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)

Preleva un elemento da una delle istanze di BlockingCollection<T> specificate considerando il token di annullamento specificato.Takes an item from any one of the specified BlockingCollection<T> instances while observing the specified cancellation token.

ToArray() ToArray() ToArray() ToArray()

Copia gli elementi dall'istanza di BlockingCollection<T> in una nuova matrice.Copies the items from the BlockingCollection<T> instance into a new array.

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

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

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

Prova ad aggiungere l'elemento specificato a BlockingCollection<T>.Tries to add the specified item to the BlockingCollection<T>.

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

Prova ad aggiungere l'elemento specificato a BlockingCollection<T> nel periodo di tempo specificato.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)

Prova ad aggiungere l'elemento specificato a BlockingCollection<T> nel periodo di tempo specificato, considerando un token di annullamento.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)

Prova ad aggiungere l'elemento specificato a 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)

Prova ad aggiungere l'elemento specificato a una delle istanze specifiche di 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)

Prova ad aggiungere l'elemento specificato a una delle istanze specifiche di 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)

Prova ad aggiungere l'elemento specificato a una delle istanze specifiche di 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)

Prova ad aggiungere l'elemento specificato a una delle istanze di BlockingCollection<T> specificate considerando il token di annullamento specificato.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)

Prova a rimuovere un elemento da BlockingCollection<T>.Tries to remove an item from the BlockingCollection<T>.

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

Prova rimuovere un elemento da BlockingCollection<T> entro il periodo di tempo specificato.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)

Prova a rimuovere un elemento da BlockingCollection<T> nel periodo di tempo specificato, considerando un token di annullamento.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)

Prova rimuovere un elemento da BlockingCollection<T> entro il periodo di tempo specificato.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)

Prova a rimuovere un elemento da una delle istanze specifiche di 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)

Prova a rimuovere un elemento da una delle istanze specifiche di 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)

Prova a rimuovere un elemento da una delle istanze specifiche di 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)

Prova a rimuovere un elemento da una delle istanze specifiche di BlockingCollection<T>.Tries to remove an item from any one of the specified BlockingCollection<T> instances.

Implementazioni dell'interfaccia esplicita

ICollection.CopyTo(Array, Int32) ICollection.CopyTo(Array, Int32) ICollection.CopyTo(Array, Int32) ICollection.CopyTo(Array, Int32)

Copia tutti gli elementi dell'istanza di BlockingCollection<T> in una matrice unidimensionale compatibile, a partire dall'indice specificato della matrice di destinazione.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

Ottiene un valore che indica se l'accesso a ICollection è sincronizzato (thread-safe).Gets a value indicating whether access to the ICollection is synchronized (thread safe).

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

Ottiene un oggetto che può essere usato per sincronizzare l'accesso a ICollection.Gets an object that can be used to synchronize access to the ICollection. Questa proprietà non è supportata.This property is not supported.

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

Fornisce un oggetto IEnumerator per gli elementi nella raccolta.Provides an IEnumerator for items in the collection.

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

Fornisce un oggetto IEnumerator<T> per gli elementi nella raccolta.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>)

Restituisce un DataTable che contiene copie del DataRow oggetti, dato un input IEnumerable<T> oggetto in cui il parametro generico 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) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)

Le copie DataRow oggetti specificata DataTable, un giudizio IEnumerable<T> oggetto in cui il parametro generico 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) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)

Le copie DataRow oggetti specificata DataTable, un giudizio IEnumerable<T> oggetto in cui il parametro generico 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) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable)

Esegue il cast degli elementi di un oggetto IEnumerable nel tipo specificato.Casts the elements of an IEnumerable to the specified type.

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

Filtra gli elementi di un oggetto IEnumerable in base a un tipo specificato.Filters the elements of an IEnumerable based on a specified type.

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

Consente la parallelizzazione di una query.Enables parallelization of a query.

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

Converte un' IEnumerable a un IQueryable.Converts an IEnumerable to an IQueryable.

Ancestors<T>(IEnumerable<T>) Ancestors<T>(IEnumerable<T>) Ancestors<T>(IEnumerable<T>) Ancestors<T>(IEnumerable<T>)

Restituisce una raccolta di elementi che contiene i predecessori di ciascun nodo nella raccolta di origine.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)

Restituisce una raccolta di elementi filtrati che contiene i predecessori di ciascun nodo nella raccolta di origine.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Solo gli elementi che hanno un oggetto XName corrispondente vengono inclusi nella raccolta.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>)

Restituisce una raccolta di nodi discendenti di ciascun documento ed elemento nella raccolta di origine.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>)

Restituisce una raccolta di elementi che contiene gli elementi discendenti di ciascun elemento e documento nella raccolta di origine.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)

Restituisce una raccolta filtrata di elementi che contiene gli elementi discendenti di ciascun elemento e documento nella raccolta di origine.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Solo gli elementi che hanno un oggetto XName corrispondente vengono inclusi nella raccolta.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>)

Restituisce una raccolta di elementi figlio di ciascun elemento e documento nella raccolta di origine.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)

Restituisce una raccolta filtrata degli elementi figlio di ciascun elemento e documento nella raccolta di origine.Returns a filtered collection of the child elements of every element and document in the source collection. Solo gli elementi che hanno un oggetto XName corrispondente vengono inclusi nella raccolta.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>)

Restituisce una raccolta di nodi che contiene tutti i nodi nella raccolta di origine ordinati in base all'ordine con cui sono riportati nel documento.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>)

Restituisce una raccolta di nodi figlio di ciascun documento ed elemento nella raccolta di origine.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>)

Rimuove ciascun nodo nella raccolta di origine dal nodo padre.Removes every node in the source collection from its parent node.

Si applica a

Thread safety

Il metodo Dispose non è thread-safe.The Dispose method is not thread-safe. Tutti gli altri membri pubblici e protetti della BlockingCollection<T> sono thread-safe e possono essere utilizzati contemporaneamente da più thread.All other public and protected members of BlockingCollection<T> are thread-safe and may be used concurrently from multiple threads.

Vedi anche