BlockingCollection<T> Classe

Définition

Espace de noms:

System.Collections.Concurrent

Assembly:

System.Collections.Concurrent.dll

Source:

BlockingCollection.cs

Fournit des fonctionnalités de blocage et de délimitation pour les collections thread-safe qui implémentent 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.Versioning.UnsupportedOSPlatform("browser")]
public class BlockingCollection<T> : IDisposable, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.ICollection

[<System.Runtime.Versioning.UnsupportedOSPlatform("browser")>]
type BlockingCollection<'T> = class
    interface seq<'T>
    interface IEnumerable
    interface IReadOnlyCollection<'T>
    interface ICollection
    interface IDisposable

Public Class BlockingCollection(Of T)
Implements ICollection, IDisposable, IEnumerable(Of T), IReadOnlyCollection(Of T)

Paramètres de type

T

Type d’éléments dans la collection.

Héritage

Object

BlockingCollection<T>

Attributs

UnsupportedOSPlatformAttribute

Implémente

IEnumerable<T> IReadOnlyCollection<T> ICollection IEnumerable IDisposable

Exemples

L’exemple suivant montre comment ajouter et prendre des éléments simultanément à partir d’une collection bloquante :

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
            Task t1 = Task.Run(() =>
            {
                bc.Add(1);
                bc.Add(2);
                bc.Add(3);
                bc.CompleteAdding();
            });

            // Spin up a Task to consume the BlockingCollection
            Task t2 = Task.Run(() =>
            {
                try
                {
                    // 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
            var producerTask = Task.Run(async () =>
            {
                for (int i = 0; i < 10; i++)
                {
                    bc.Add(i);
                    Console.WriteLine($"Producing: {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($"Consuming: {item}");
            }
            await producerTask; // Allow task to complete cleanup
        }
    }
}

open System
open System.Collections.Concurrent
open System.Threading
open System.Threading.Tasks

module AddTakeDemo =
    // Demonstrates:
    //      BlockingCollection<T>.Add()
    //      BlockingCollection<T>.Take()
    //      BlockingCollection<T>.CompleteAdding()
    let blockingCollectionAddTakeCompleteAdding () =
        task {
            use bc = new BlockingCollection<int>()
            // Spin up a Task to populate the BlockingCollection
            let t1 = 
                task {
                    bc.Add 1
                    bc.Add 2
                    bc.Add 3
                    bc.CompleteAdding()
                }

            // Spin up a Task to consume the BlockingCollection
            let t2 = 
                task {
                    try
                        // Consume consume the BlockingCollection
                        while true do 
                            printfn $"{bc.Take()}"
                    with :? InvalidOperationException ->
                        // An InvalidOperationException means that Take() was called on a completed collection
                        printfn "That's All!"
                }
            let! _ = Task.WhenAll(t1, t2)
            ()
        }

module TryTakeDemo =
    // Demonstrates:
    //      BlockingCollection<T>.Add()
    //      BlockingCollection<T>.CompleteAdding()
    //      BlockingCollection<T>.TryTake()
    //      BlockingCollection<T>.IsCompleted
    let blockingCollectionTryTake () =
        // Construct and fill our BlockingCollection
        use bc = new BlockingCollection<int>()
        let NUMITEMS = 10000;
        for i = 0 to NUMITEMS - 1 do
            bc.Add i
        bc.CompleteAdding()
        let mutable outerSum = 0

        // Delegate for consuming the BlockingCollection and adding up all items
        let action = 
            Action(fun () ->
                let mutable localItem = 0
                let mutable localSum = 0

                while bc.TryTake &localItem do
                    localSum <- localSum + localItem
                Interlocked.Add(&outerSum, localSum)
                |> ignore)

        // Launch three parallel actions to consume the BlockingCollection
        Parallel.Invoke(action, action, action)

        printfn $"Sum[0..{NUMITEMS}) = {outerSum}, should be {((NUMITEMS * (NUMITEMS - 1)) / 2)}"
        printfn $"bc.IsCompleted = {bc.IsCompleted} (should be true)"

module FromToAnyDemo =
    // Demonstrates:
    //      Bounded BlockingCollection<T>
    //      BlockingCollection<T>.TryAddToAny()
    //      BlockingCollection<T>.TryTakeFromAny()
    let blockingCollectionFromToAny () =
        let bcs = 
            [|
                new BlockingCollection<int>(5) // collection bounded to 5 items
                new BlockingCollection<int>(5) // collection bounded to 5 items
             |]
        // Should be able to add 10 items w/o blocking
        let mutable numFailures = 0;
        for i = 0 to 9 do
            if BlockingCollection<int>.TryAddToAny(bcs, i) = -1 then
                numFailures <- numFailures + 1
        printfn $"TryAddToAny: {numFailures} failures (should be 0)"

        // Should be able to retrieve 10 items
        let mutable numItems = 0
        let mutable item = 0
        while BlockingCollection<int>.TryTakeFromAny(bcs, &item) <> -1 do
            numItems <- numItems + 1
        printfn $"TryTakeFromAny: retrieved {numItems} items (should be 10)"

module ConsumingEnumerableDemo =
    // Demonstrates:
    //      BlockingCollection<T>.Add()
    //      BlockingCollection<T>.CompleteAdding()
    //      BlockingCollection<T>.GetConsumingEnumerable()
    let blockingCollectionGetConsumingEnumerable () =
        task {
            use bc = new BlockingCollection<int>()
            // Kick off a producer task
            let producerTask =
                task {
                    for i = 0 to 9 do
                        bc.Add i
                        printfn $"Producing: {i}"

                        do! 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.
            for item in bc.GetConsumingEnumerable() do
                printfn $"Consuming: {item}"
            do! producerTask // Allow task to complete cleanup
        }

let main =
    task {
        do! AddTakeDemo.blockingCollectionAddTakeCompleteAdding ()
        TryTakeDemo.blockingCollectionTryTake ()
        FromToAnyDemo.blockingCollectionFromToAny ()
        do! ConsumingEnumerableDemo.blockingCollectionGetConsumingEnumerable ()
        printfn "Press any key to exit."
        Console.ReadKey(true) |> ignore
    }
main.Wait()

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

Remarques

BlockingCollection<T> est une classe de collection thread-safe qui fournit les éléments suivants :

• Implémentation du modèle producteur/consommateur ; BlockingCollection<T> est un wrapper pour l’interface IProducerConsumerCollection<T>.

• Ajout et suppression simultanés d’éléments de plusieurs threads avec les méthodes Add et Take.

• Collection limitée qui bloque Add et Take opérations lorsque la collection est pleine ou vide.

• Annulation d’opérations de Add ou de Take à l’aide d’un objet CancellationToken dans la méthode TryAdd ou TryTake.

Important

Ce type implémente l’interface IDisposable. Une fois que vous avez fini d’utiliser le type, vous devez le supprimer directement ou indirectement. Pour supprimer le type directement, appelez sa méthode Dispose dans un bloc try/catch. Pour le supprimer indirectement, utilisez une construction de langage telle que using (en C#) ou Using (en Visual Basic). Pour plus d’informations, consultez la section « Utilisation d’un objet implémentant IDisposable » dans la rubrique de l’interface IDisposable. Notez également que la méthode Dispose() n’est pas thread-safe. Tous les autres membres publics et protégés de BlockingCollection<T> sont thread-safe et peuvent être utilisés simultanément à partir de plusieurs threads.

IProducerConsumerCollection<T> représente une collection qui permet l’ajout et la suppression de données thread-safe. BlockingCollection<T> est utilisé comme wrapper pour une instance de IProducerConsumerCollection<T> et autorise la suppression des tentatives de suppression de la collection jusqu’à ce que les données soient supprimées. De même, vous pouvez créer une BlockingCollection<T> pour appliquer une limite supérieure au nombre d’éléments de données autorisés dans le IProducerConsumerCollection<T>; les tentatives d’ajout à la collection peuvent ensuite bloquer jusqu’à ce que l’espace soit disponible pour stocker les éléments ajoutés. De cette façon, BlockingCollection<T> est similaire à une structure de données de file d’attente de blocage classique, sauf que le mécanisme de stockage de données sous-jacent est extrait sous la forme d’un IProducerConsumerCollection<T>.

BlockingCollection<T> prend en charge la délimitation et le blocage. La limite signifie que vous pouvez définir la capacité maximale de la collection. La délimitation est importante dans certains scénarios, car elle vous permet de contrôler la taille maximale de la collection en mémoire et empêche les threads de production de se déplacer trop loin devant les threads consommants. Plusieurs threads ou tâches peuvent ajouter des éléments à la collection simultanément, et si la collection atteint sa capacité maximale spécifiée, les threads de production bloquent jusqu’à ce qu’un élément soit supprimé. Plusieurs consommateurs peuvent supprimer des éléments simultanément et, si la collection devient vide, les threads consommants bloquent jusqu’à ce qu’un producteur ajoute un élément. Un thread de production peut appeler la méthode CompleteAdding pour indiquer qu’aucun autre élément n’est ajouté. Les consommateurs surveillent la propriété IsCompleted pour savoir quand la collection est vide et aucun autre élément n’est ajouté.

Add et les opérations de Take sont généralement effectuées dans une boucle. Vous pouvez annuler une boucle en passant un objet CancellationToken à la méthode TryAdd ou TryTake, puis en vérifiant la valeur de la propriété IsCancellationRequested du jeton sur chaque itération. Si la valeur est true, il vous incombe de répondre à la demande d’annulation en nettoyant les ressources et en quittant la boucle.

Lorsque vous créez un objet BlockingCollection<T>, vous pouvez spécifier non seulement la capacité limitée, mais également le type de collection à utiliser. Par exemple, vous pouvez spécifier un objet ConcurrentQueue<T> pour le comportement de premier entré, premier sorti (FIFO) ou un objet ConcurrentStack<T> pour le dernier dans, premier sorti (LIFO). Vous pouvez utiliser n’importe quelle classe de collection qui implémente l’interface IProducerConsumerCollection<T>. Le type de collection par défaut pour BlockingCollection<T> est ConcurrentQueue<T>.

Ne modifiez pas directement la collection sous-jacente. Utilisez BlockingCollection<T> méthodes pour ajouter ou supprimer des éléments. L’objet BlockingCollection<T> peut être endommagé si vous modifiez directement la collection sous-jacente.

BlockingCollection<T> n’a pas été conçu avec un accès asynchrone à l’esprit. Si votre application nécessite des scénarios de producteur/consommateur asynchrones, envisagez d’utiliser Channel<T> à la place.

Constructeurs

BlockingCollection<T>()	Initialise une nouvelle instance de la classe BlockingCollection<T> sans limite supérieure.
BlockingCollection<T>(Int32)	Initialise une nouvelle instance de la classe BlockingCollection<T> avec la limite supérieure spécifiée.
BlockingCollection<T>(IProducerConsumerCollection<T>)	Initialise une nouvelle instance de la classe BlockingCollection<T> sans limite supérieure et utilise le IProducerConsumerCollection<T> fourni comme magasin de données sous-jacent.
BlockingCollection<T>(IProducerConsumerCollection<T>, Int32)	Initialise une nouvelle instance de la classe BlockingCollection<T> avec la limite supérieure spécifiée et utilise le IProducerConsumerCollection<T> fourni comme magasin de données sous-jacent.

Propriétés

BoundedCapacity	Obtient la capacité limitée de cette instance BlockingCollection<T>.
Count	Obtient le nombre d’éléments contenus dans la BlockingCollection<T>.
IsAddingCompleted	Obtient si cette BlockingCollection<T> a été marquée comme terminée pour l’ajout.
IsCompleted	Obtient si cette BlockingCollection<T> a été marquée comme terminée pour l’ajout et est vide.

Méthodes

Add(T)	Ajoute l’élément au BlockingCollection<T>.
Add(T, CancellationToken)	Ajoute l’élément au BlockingCollection<T>.
AddToAny(BlockingCollection<T>[], T)	Ajoute l’élément spécifié à l’une des instances BlockingCollection<T> spécifiées.
AddToAny(BlockingCollection<T>[], T, CancellationToken)	Ajoute l’élément spécifié à l’une des instances BlockingCollection<T> spécifiées.
CompleteAdding()	Marque les instances BlockingCollection<T> comme n’acceptant plus d’ajouts.
CopyTo(T[], Int32)	Copie tous les éléments de l’instance BlockingCollection<T> dans un tableau unidimensionnel compatible, en commençant à l’index spécifié du tableau cible.
Dispose()	Libère toutes les ressources utilisées par l’instance actuelle de la classe BlockingCollection<T>.
Dispose(Boolean)	Libère les ressources utilisées par l’instance BlockingCollection<T>.
Equals(Object)	Détermine si l’objet spécifié est égal à l’objet actuel. (Hérité de Object)
GetConsumingEnumerable()	Fournit une IEnumerable<T> consommatrice pour les éléments de la collection.
GetConsumingEnumerable(CancellationToken)	Fournit une IEnumerable<T> consommatrice pour les éléments de la collection.
GetHashCode()	Sert de fonction de hachage par défaut. (Hérité de Object)
GetType()	Obtient la Type de l’instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Objectactuel. (Hérité de Object)
Take()	Supprime un élément du BlockingCollection<T>.
Take(CancellationToken)	Supprime un élément du BlockingCollection<T>.
TakeFromAny(BlockingCollection<T>[], T)	Prend un élément de l’une des instances de BlockingCollection<T> spécifiées.
TakeFromAny(BlockingCollection<T>[], T, CancellationToken)	Prend un élément de l’une des instances de BlockingCollection<T> spécifiées lors de l’observation du jeton d’annulation spécifié.
ToArray()	Copie les éléments de l’instance BlockingCollection<T> dans un nouveau tableau.
ToString()	Retourne une chaîne qui représente l’objet actuel. (Hérité de Object)
TryAdd(T)	Tente d’ajouter l’élément spécifié au BlockingCollection<T>.
TryAdd(T, Int32)	Tente d’ajouter l’élément spécifié au BlockingCollection<T> dans la période spécifiée.
TryAdd(T, Int32, CancellationToken)	Tente d’ajouter l’élément spécifié à l'BlockingCollection<T> dans la période spécifiée, tout en observant un jeton d’annulation.
TryAdd(T, TimeSpan)	Tente d’ajouter l’élément spécifié au BlockingCollection<T>.
TryAddToAny(BlockingCollection<T>[], T)	Tente d’ajouter l’élément spécifié à l’une des instances BlockingCollection<T> spécifiées.
TryAddToAny(BlockingCollection<T>[], T, Int32)	Tente d’ajouter l’élément spécifié à l’une des instances BlockingCollection<T> spécifiées.
TryAddToAny(BlockingCollection<T>[], T, Int32, CancellationToken)	Tente d’ajouter l’élément spécifié à l’une des instances BlockingCollection<T> spécifiées.
TryAddToAny(BlockingCollection<T>[], T, TimeSpan)	Tente d’ajouter l’élément spécifié à l’une des instances de BlockingCollection<T> spécifiées lors de l’observation du jeton d’annulation spécifié.
TryTake(T)	Tente de supprimer un élément du BlockingCollection<T>.
TryTake(T, Int32)	Tente de supprimer un élément de la BlockingCollection<T> dans la période spécifiée.
TryTake(T, Int32, CancellationToken)	Tente de supprimer un élément du BlockingCollection<T> dans la période spécifiée lors de l’observation d’un jeton d’annulation.
TryTake(T, TimeSpan)	Tente de supprimer un élément de la BlockingCollection<T> dans la période spécifiée.
TryTakeFromAny(BlockingCollection<T>[], T)	Tente de supprimer un élément de l’une des instances BlockingCollection<T> spécifiées.
TryTakeFromAny(BlockingCollection<T>[], T, Int32)	Tente de supprimer un élément de l’une des instances BlockingCollection<T> spécifiées.
TryTakeFromAny(BlockingCollection<T>[], T, Int32, CancellationToken)	Tente de supprimer un élément de l’une des instances BlockingCollection<T> spécifiées.
TryTakeFromAny(BlockingCollection<T>[], T, TimeSpan)	Tente de supprimer un élément de l’une des instances BlockingCollection<T> spécifiées.

Implémentations d’interfaces explicites

ICollection.CopyTo(Array, Int32)	Copie tous les éléments de l’instance BlockingCollection<T> dans un tableau unidimensionnel compatible, en commençant à l’index spécifié du tableau cible.
ICollection.IsSynchronized	Obtient une valeur indiquant si l’accès au ICollection est synchronisé (thread safe).
ICollection.SyncRoot	Obtient un objet qui peut être utilisé pour synchroniser l’accès au ICollection. Cette propriété n’est pas prise en charge.
IEnumerable.GetEnumerator()	Fournit une IEnumerator pour les éléments de la collection.
IEnumerable<T>.GetEnumerator()	Fournit une IEnumerator<T> pour les éléments de la collection.

Méthodes d’extension

ToFrozenDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Crée un FrozenDictionary<TKey,TValue> à partir d’un IEnumerable<T> en fonction de la fonction de sélecteur de clé spécifiée.
ToFrozenDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Crée un FrozenDictionary<TKey,TValue> à partir d’un IEnumerable<T> en fonction des fonctions de sélecteur de clé et de sélecteur d’élément spécifiées.
ToFrozenSet<T>(IEnumerable<T>, IEqualityComparer<T>)	Crée un FrozenSet<T> avec les valeurs spécifiées.
ToImmutableArray<TSource>(IEnumerable<TSource>)	Crée un tableau immuable à partir de la collection spécifiée.
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Construit un dictionnaire immuable à partir d’une collection existante d’éléments, en appliquant une fonction de transformation aux clés sources.
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Construit un dictionnaire immuable basé sur une transformation d’une séquence.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)	Énumère et transforme une séquence et produit un dictionnaire immuable de son contenu.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>)	Énumère et transforme une séquence et produit un dictionnaire immuable de son contenu à l’aide du comparateur de clés spécifié.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>)	Énumère et transforme une séquence et produit un dictionnaire immuable de son contenu à l’aide des comparateurs de clé et de valeur spécifiés.
ToImmutableHashSet<TSource>(IEnumerable<TSource>)	Énumère une séquence et produit un ensemble de hachage immuable de son contenu.
ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Énumère une séquence, produit un jeu de hachage immuable de son contenu et utilise le comparateur d’égalité spécifié pour le type set.
ToImmutableList<TSource>(IEnumerable<TSource>)	Énumère une séquence et produit une liste immuable de son contenu.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)	Énumère et transforme une séquence et produit un dictionnaire trié immuable de son contenu.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>)	Énumère et transforme une séquence et produit un dictionnaire trié immuable de son contenu à l’aide du comparateur de clés spécifié.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>, IEqualityComparer<TValue>)	Énumère et transforme une séquence et produit un dictionnaire trié immuable de son contenu à l’aide des comparateurs de clé et de valeur spécifiés.
ToImmutableSortedSet<TSource>(IEnumerable<TSource>)	Énumère une séquence et produit un ensemble trié immuable de son contenu.
ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>)	Énumère une séquence, produit un ensemble trié immuable de son contenu et utilise le comparateur spécifié.
CopyToDataTable<T>(IEnumerable<T>)	Renvoie un DataTable qui contient des copies des objets DataRow, en fonction d’un objet IEnumerable<T> d’entrée où le paramètre générique T est DataRow.
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)	Copie DataRow objets dans le DataTablespécifié, en fonction d’un objet IEnumerable<T> d’entrée où le paramètre générique T est DataRow.
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)	Copie DataRow objets dans le DataTablespécifié, en fonction d’un objet IEnumerable<T> d’entrée où le paramètre générique T est DataRow.
Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>)	Applique une fonction d’accumulation sur une séquence.
Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>)	Applique une fonction d’accumulation sur une séquence. La valeur initiale spécifiée est utilisée comme valeur d’accumulation initiale.
Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>)	Applique une fonction d’accumulation sur une séquence. La valeur initiale spécifiée est utilisée comme valeur d’accumulation initiale et la fonction spécifiée est utilisée pour sélectionner la valeur de résultat.
All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Détermine si tous les éléments d’une séquence répondent à une condition.
Any<TSource>(IEnumerable<TSource>)	Détermine si une séquence contient des éléments.
Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Détermine si un élément d’une séquence satisfait à une condition.
Append<TSource>(IEnumerable<TSource>, TSource)	Ajoute une valeur à la fin de la séquence.
AsEnumerable<TSource>(IEnumerable<TSource>)	Retourne l’entrée typée en tant que IEnumerable<T>.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Calcule la moyenne d’une séquence de valeurs Decimal obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Calcule la moyenne d’une séquence de valeurs Double obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Calcule la moyenne d’une séquence de valeurs Int32 obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Calcule la moyenne d’une séquence de valeurs Int64 obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Calcule la moyenne d’une séquence de valeurs nullables Decimal obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Calcule la moyenne d’une séquence de valeurs nullables Double obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Calcule la moyenne d’une séquence de valeurs nullables Int32 obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Calcule la moyenne d’une séquence de valeurs nullables Int64 obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Calcule la moyenne d’une séquence de valeurs nullables Single obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Calcule la moyenne d’une séquence de valeurs Single obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.
Cast<TResult>(IEnumerable)	Convertit les éléments d’un IEnumerable en type spécifié.
Chunk<TSource>(IEnumerable<TSource>, Int32)	Fractionne les éléments d’une séquence en blocs de taille au plus size.
Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Concatène deux séquences.
Contains<TSource>(IEnumerable<TSource>, TSource)	Détermine si une séquence contient un élément spécifié à l’aide du comparateur d’égalité par défaut.
Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>)	Détermine si une séquence contient un élément spécifié à l’aide d’un IEqualityComparer<T>spécifié.
Count<TSource>(IEnumerable<TSource>)	Retourne le nombre d’éléments d’une séquence.
Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Retourne un nombre qui représente le nombre d’éléments de la séquence spécifiée qui répondent à une condition.
DefaultIfEmpty<TSource>(IEnumerable<TSource>)	Retourne les éléments de la séquence spécifiée ou la valeur par défaut du paramètre de type dans une collection singleton si la séquence est vide.
DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource)	Retourne les éléments de la séquence spécifiée ou la valeur spécifiée dans une collection singleton si la séquence est vide.
Distinct<TSource>(IEnumerable<TSource>)	Retourne des éléments distincts d’une séquence à l’aide du comparateur d’égalité par défaut pour comparer les valeurs.
Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Retourne des éléments distincts d’une séquence à l’aide d’un IEqualityComparer<T> spécifié pour comparer les valeurs.
DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Retourne des éléments distincts d’une séquence en fonction d’une fonction de sélecteur de clé spécifiée.
DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Retourne des éléments distincts d’une séquence en fonction d’une fonction de sélecteur de clé spécifiée et à l’aide d’un comparateur spécifié pour comparer les clés.
ElementAt<TSource>(IEnumerable<TSource>, Index)	Retourne l’élément à un index spécifié dans une séquence.
ElementAt<TSource>(IEnumerable<TSource>, Int32)	Retourne l’élément à un index spécifié dans une séquence.
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Index)	Retourne l’élément à un index spécifié dans une séquence ou une valeur par défaut si l’index est hors plage.
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32)	Retourne l’élément à un index spécifié dans une séquence ou une valeur par défaut si l’index est hors plage.
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Produit la différence de jeu de deux séquences à l’aide du comparateur d’égalité par défaut pour comparer les valeurs.
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Produit la différence de jeu de deux séquences à l’aide de la IEqualityComparer<T> spécifiée pour comparer les valeurs.
ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>)	Produit la différence de jeu de deux séquences en fonction d’une fonction de sélecteur de clé spécifiée.
ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Produit la différence de jeu de deux séquences en fonction d’une fonction de sélecteur de clé spécifiée.
First<TSource>(IEnumerable<TSource>)	Retourne le premier élément d’une séquence.
First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Retourne le premier élément d’une séquence qui satisfait à une condition spécifiée.
FirstOrDefault<TSource>(IEnumerable<TSource>)	Retourne le premier élément d’une séquence ou une valeur par défaut si la séquence ne contient aucun élément.
FirstOrDefault<TSource>(IEnumerable<TSource>, TSource)	Retourne le premier élément d’une séquence ou une valeur par défaut spécifiée si la séquence ne contient aucun élément.
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Retourne le premier élément de la séquence qui satisfait à une condition ou une valeur par défaut si aucun élément de ce type n’est trouvé.
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)	Retourne le premier élément de la séquence qui satisfait à une condition ou une valeur par défaut spécifiée si aucun élément de ce type n’est trouvé.
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Regroupe les éléments d’une séquence en fonction d’une fonction de sélecteur de clé spécifiée.
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Regroupe les éléments d’une séquence en fonction d’une fonction de sélecteur de clé spécifiée et compare les clés à l’aide d’un comparateur spécifié.
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Regroupe les éléments d’une séquence en fonction d’une fonction de sélecteur de clé spécifiée et projette les éléments pour chaque groupe à l’aide d’une fonction spécifiée.
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Regroupe les éléments d’une séquence en fonction d’une fonction de sélecteur de clé. Les clés sont comparées à l’aide d’un comparateur et les éléments de chaque groupe sont projetés à l’aide d’une fonction spécifiée.
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>)	Regroupe les éléments d’une séquence en fonction d’une fonction de sélecteur de clé spécifiée et crée une valeur de résultat à partir de chaque groupe et de sa clé.
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>)	Regroupe les éléments d’une séquence en fonction d’une fonction de sélecteur de clé spécifiée et crée une valeur de résultat à partir de chaque groupe et de sa clé. Les clés sont comparées à l’aide d’un comparateur spécifié.
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>)	Regroupe les éléments d’une séquence en fonction d’une fonction de sélecteur de clé spécifiée et crée une valeur de résultat à partir de chaque groupe et de sa clé. Les éléments de chaque groupe sont projetés à l’aide d’une fonction spécifiée.
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>)	Regroupe les éléments d’une séquence en fonction d’une fonction de sélecteur de clé spécifiée et crée une valeur de résultat à partir de chaque groupe et de sa clé. Les valeurs de clé sont comparées à l’aide d’un comparateur spécifié et les éléments de chaque groupe sont projetés à l’aide d’une fonction spécifiée.
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>)	Met en corrélation les éléments de deux séquences en fonction de l’égalité des clés et regroupe les résultats. Le comparateur d’égalité par défaut est utilisé pour comparer les clés.
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>)	Met en corrélation les éléments de deux séquences en fonction de l’égalité des clés et regroupe les résultats. Une IEqualityComparer<T> spécifiée est utilisée pour comparer les clés.
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Produit l’intersection définie de deux séquences à l’aide du comparateur d’égalité par défaut pour comparer les valeurs.
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Produit l’intersection définie de deux séquences à l’aide de la IEqualityComparer<T> spécifiée pour comparer les valeurs.
IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>)	Produit l’intersection définie de deux séquences en fonction d’une fonction de sélecteur de clé spécifiée.
IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Produit l’intersection définie de deux séquences en fonction d’une fonction de sélecteur de clé spécifiée.
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>)	Met en corrélation les éléments de deux séquences en fonction des clés correspondantes. Le comparateur d’égalité par défaut est utilisé pour comparer les clés.
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>)	Met en corrélation les éléments de deux séquences en fonction des clés correspondantes. Une IEqualityComparer<T> spécifiée est utilisée pour comparer les clés.
Last<TSource>(IEnumerable<TSource>)	Retourne le dernier élément d’une séquence.
Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Retourne le dernier élément d’une séquence qui satisfait à une condition spécifiée.
LastOrDefault<TSource>(IEnumerable<TSource>)	Retourne le dernier élément d’une séquence ou une valeur par défaut si la séquence ne contient aucun élément.
LastOrDefault<TSource>(IEnumerable<TSource>, TSource)	Retourne le dernier élément d’une séquence ou une valeur par défaut spécifiée si la séquence ne contient aucun élément.
LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Retourne le dernier élément d’une séquence qui satisfait à une condition ou une valeur par défaut si aucun élément de ce type n’est trouvé.
LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)	Retourne le dernier élément d’une séquence qui satisfait à une condition ou une valeur par défaut spécifiée si aucun élément de ce type n’est trouvé.
LongCount<TSource>(IEnumerable<TSource>)	Retourne un Int64 qui représente le nombre total d’éléments d’une séquence.
LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Retourne une Int64 qui représente le nombre d’éléments d’une séquence qui répondent à une condition.
Max<TSource>(IEnumerable<TSource>)	Retourne la valeur maximale dans une séquence générique.
Max<TSource>(IEnumerable<TSource>, IComparer<TSource>)	Retourne la valeur maximale dans une séquence générique.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur maximale Decimal.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur maximale Double.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur maximale Int32.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur maximale Int64.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur de Decimal nullable maximale.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur de Double nullable maximale.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur de Int32 nullable maximale.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur de Int64 nullable maximale.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur de Single nullable maximale.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur maximale Single.
Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Appelle une fonction de transformation sur chaque élément d’une séquence générique et retourne la valeur maximale résultante.
MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Retourne la valeur maximale dans une séquence générique en fonction d’une fonction de sélecteur de clé spécifiée.
MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Retourne la valeur maximale dans une séquence générique en fonction d’une fonction de sélecteur de clé et d’un comparateur de clés spécifiés.
Min<TSource>(IEnumerable<TSource>)	Retourne la valeur minimale dans une séquence générique.
Min<TSource>(IEnumerable<TSource>, IComparer<TSource>)	Retourne la valeur minimale dans une séquence générique.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur minimale Decimal.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur minimale Double.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur minimale Int32.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur minimale Int64.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur de Decimal nullable minimale.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur de Double nullable minimale.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur de Int32 nullable minimale.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur de Int64 nullable minimale.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur de Single nullable minimale.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Appelle une fonction de transformation sur chaque élément d’une séquence et retourne la valeur minimale Single.
Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Appelle une fonction de transformation sur chaque élément d’une séquence générique et retourne la valeur minimale résultante.
MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Retourne la valeur minimale dans une séquence générique en fonction d’une fonction de sélecteur de clé spécifiée.
MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Retourne la valeur minimale dans une séquence générique en fonction d’une fonction de sélecteur de clé et d’un comparateur de clés spécifiés.
OfType<TResult>(IEnumerable)	Filtre les éléments d’une IEnumerable en fonction d’un type spécifié.
Order<T>(IEnumerable<T>)	Trie les éléments d’une séquence dans l’ordre croissant.
Order<T>(IEnumerable<T>, IComparer<T>)	Trie les éléments d’une séquence dans l’ordre croissant.
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Trie les éléments d’une séquence dans l’ordre croissant en fonction d’une clé.
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Trie les éléments d’une séquence dans l’ordre croissant à l’aide d’un comparateur spécifié.
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Trie les éléments d’une séquence dans l’ordre décroissant en fonction d’une clé.
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Trie les éléments d’une séquence dans l’ordre décroissant à l’aide d’un comparateur spécifié.
OrderDescending<T>(IEnumerable<T>)	Trie les éléments d’une séquence dans l’ordre décroissant.
OrderDescending<T>(IEnumerable<T>, IComparer<T>)	Trie les éléments d’une séquence dans l’ordre décroissant.
Prepend<TSource>(IEnumerable<TSource>, TSource)	Ajoute une valeur au début de la séquence.
Reverse<TSource>(IEnumerable<TSource>)	Inverse l’ordre des éléments dans une séquence.
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Projette chaque élément d’une séquence dans un nouveau formulaire.
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>)	Projette chaque élément d’une séquence dans un nouveau formulaire en incorporant l’index de l’élément.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>)	Projette chaque élément d’une séquence vers une IEnumerable<T> et aplatit les séquences obtenues en une seule séquence.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)	Projette chaque élément d’une séquence dans une IEnumerable<T>et aplatit les séquences obtenues en une seule séquence. L’index de chaque élément source est utilisé sous la forme projetée de cet élément.
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)	Projette chaque élément d’une séquence vers une IEnumerable<T>, aplatit les séquences obtenues en une seule séquence et appelle une fonction de sélecteur de résultats sur chaque élément dans celui-ci.
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)	Projette chaque élément d’une séquence vers une IEnumerable<T>, aplatit les séquences obtenues en une seule séquence et appelle une fonction de sélecteur de résultats sur chaque élément dans celui-ci. L’index de chaque élément source est utilisé dans la forme projetée intermédiaire de cet élément.
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Détermine si deux séquences sont égales en comparant les éléments à l’aide du comparateur d’égalité par défaut pour leur type.
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Détermine si deux séquences sont égales en comparant leurs éléments à l’aide d’un IEqualityComparer<T>spécifié.
Single<TSource>(IEnumerable<TSource>)	Retourne le seul élément d’une séquence et lève une exception s’il n’y a pas exactement un élément dans la séquence.
Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Retourne le seul élément d’une séquence qui satisfait à une condition spécifiée et lève une exception si plusieurs éléments de ce type existent.
SingleOrDefault<TSource>(IEnumerable<TSource>)	Retourne le seul élément d’une séquence ou une valeur par défaut si la séquence est vide ; cette méthode lève une exception s’il existe plusieurs éléments dans la séquence.
SingleOrDefault<TSource>(IEnumerable<TSource>, TSource)	Retourne le seul élément d’une séquence ou une valeur par défaut spécifiée si la séquence est vide ; cette méthode lève une exception s’il existe plusieurs éléments dans la séquence.
SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Retourne le seul élément d’une séquence qui satisfait à une condition spécifiée ou à une valeur par défaut s’il n’existe aucun élément de ce type ; cette méthode lève une exception si plusieurs éléments répondent à la condition.
SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)	Retourne le seul élément d’une séquence qui satisfait à une condition spécifiée ou une valeur par défaut spécifiée s’il n’existe aucun élément de ce type ; cette méthode lève une exception si plusieurs éléments répondent à la condition.
Skip<TSource>(IEnumerable<TSource>, Int32)	Contourne un nombre spécifié d’éléments dans une séquence, puis retourne les éléments restants.
SkipLast<TSource>(IEnumerable<TSource>, Int32)	Retourne une nouvelle collection énumérable qui contient les éléments de source avec les derniers éléments count de la collection source omis.
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Contourne les éléments d’une séquence tant qu’une condition spécifiée est vraie, puis retourne les éléments restants.
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Contourne les éléments d’une séquence tant qu’une condition spécifiée est vraie, puis retourne les éléments restants. L’index de l’élément est utilisé dans la logique de la fonction de prédicat.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Calcule la somme de la séquence de valeurs Decimal obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Calcule la somme de la séquence de valeurs Double obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Calcule la somme de la séquence de valeurs Int32 obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Calcule la somme de la séquence de valeurs Int64 obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Calcule la somme de la séquence de valeurs nullables Decimal obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Calcule la somme de la séquence de valeurs nullables Double obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Calcule la somme de la séquence de valeurs nullables Int32 obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Calcule la somme de la séquence de valeurs nullables Int64 obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Calcule la somme de la séquence de valeurs nullables Single obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Calcule la somme de la séquence de valeurs Single obtenues en appelant une fonction de transformation sur chaque élément de la séquence d’entrée.
Take<TSource>(IEnumerable<TSource>, Int32)	Retourne un nombre spécifié d’éléments contigus à partir du début d’une séquence.
Take<TSource>(IEnumerable<TSource>, Range)	Retourne une plage spécifiée d’éléments contigus à partir d’une séquence.
TakeLast<TSource>(IEnumerable<TSource>, Int32)	Retourne une nouvelle collection énumérable qui contient les derniers éléments count de source.
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Retourne des éléments d’une séquence tant qu’une condition spécifiée est vraie.
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Retourne des éléments d’une séquence tant qu’une condition spécifiée est vraie. L’index de l’élément est utilisé dans la logique de la fonction de prédicat.
ToArray<TSource>(IEnumerable<TSource>)	Crée un tableau à partir d’un IEnumerable<T>.
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Crée un Dictionary<TKey,TValue> à partir d’un IEnumerable<T> en fonction d’une fonction de sélecteur de clé spécifiée.
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Crée un Dictionary<TKey,TValue> à partir d’un IEnumerable<T> en fonction d’une fonction de sélecteur de clé et d’un comparateur de clés spécifiés.
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Crée un Dictionary<TKey,TValue> à partir d’un IEnumerable<T> en fonction des fonctions de sélecteur de clé et de sélecteur d’élément spécifiées.
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Crée une Dictionary<TKey,TValue> à partir d’un IEnumerable<T> en fonction d’une fonction de sélecteur de clé spécifiée, d’un comparateur et d’une fonction de sélecteur d’élément.
ToHashSet<TSource>(IEnumerable<TSource>)	Crée un HashSet<T> à partir d’un IEnumerable<T>.
ToHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Crée un HashSet<T> à partir d’un IEnumerable<T> à l’aide de l'comparer pour comparer les clés.
ToList<TSource>(IEnumerable<TSource>)	Crée un List<T> à partir d’un IEnumerable<T>.
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Crée un Lookup<TKey,TElement> à partir d’un IEnumerable<T> en fonction d’une fonction de sélecteur de clé spécifiée.
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Crée un Lookup<TKey,TElement> à partir d’un IEnumerable<T> en fonction d’une fonction de sélecteur de clé et d’un comparateur de clés spécifiés.
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Crée un Lookup<TKey,TElement> à partir d’un IEnumerable<T> en fonction des fonctions de sélecteur de clé et de sélecteur d’élément spécifiées.
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Crée un Lookup<TKey,TElement> à partir d’un IEnumerable<T> en fonction d’une fonction de sélecteur de clé spécifiée, d’un comparateur et d’une fonction de sélecteur d’élément.
TryGetNonEnumeratedCount<TSource>(IEnumerable<TSource>, Int32)	Tente de déterminer le nombre d’éléments d’une séquence sans forcer une énumération.
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Produit l’union définie de deux séquences à l’aide du comparateur d’égalité par défaut.
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Produit l’union définie de deux séquences à l’aide d’une IEqualityComparer<T>spécifiée.
UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>)	Produit l’union définie de deux séquences en fonction d’une fonction de sélecteur de clé spécifiée.
UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Produit l’union définie de deux séquences en fonction d’une fonction de sélecteur de clé spécifiée.
Where<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Filtre une séquence de valeurs basée sur un prédicat.
Where<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Filtre une séquence de valeurs basée sur un prédicat. L’index de chaque élément est utilisé dans la logique de la fonction de prédicat.
Zip<TFirst,TSecond>(IEnumerable<TFirst>, IEnumerable<TSecond>)	Produit une séquence de tuples avec des éléments des deux séquences spécifiées.
Zip<TFirst,TSecond,TThird>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>)	Produit une séquence de tuples avec des éléments des trois séquences spécifiées.
Zip<TFirst,TSecond,TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>)	Applique une fonction spécifiée aux éléments correspondants de deux séquences, produisant une séquence des résultats.
AsParallel(IEnumerable)	Active la parallélisation d’une requête.
AsParallel<TSource>(IEnumerable<TSource>)	Active la parallélisation d’une requête.
AsQueryable(IEnumerable)	Convertit un IEnumerable en IQueryable.
AsQueryable<TElement>(IEnumerable<TElement>)	Convertit un IEnumerable<T> générique en IQueryable<T>générique.
Ancestors<T>(IEnumerable<T>)	Retourne une collection d’éléments qui contient les ancêtres de chaque nœud de la collection source.
Ancestors<T>(IEnumerable<T>, XName)	Retourne une collection filtrée d’éléments qui contient les ancêtres de chaque nœud de la collection source. Seuls les éléments qui ont un XName correspondant sont inclus dans la collection.
DescendantNodes<T>(IEnumerable<T>)	Retourne une collection des nœuds descendants de chaque document et élément de la collection source.
Descendants<T>(IEnumerable<T>)	Retourne une collection d’éléments qui contient les éléments descendants de chaque élément et document de la collection source.
Descendants<T>(IEnumerable<T>, XName)	Retourne une collection filtrée d’éléments qui contient les éléments descendants de chaque élément et document de la collection source. Seuls les éléments qui ont un XName correspondant sont inclus dans la collection.
Elements<T>(IEnumerable<T>)	Retourne une collection des éléments enfants de chaque élément et document de la collection source.
Elements<T>(IEnumerable<T>, XName)	Retourne une collection filtrée des éléments enfants de chaque élément et document de la collection source. Seuls les éléments qui ont un XName correspondant sont inclus dans la collection.
InDocumentOrder<T>(IEnumerable<T>)	Retourne une collection de nœuds qui contient tous les nœuds de la collection source, triées dans l’ordre des documents.
Nodes<T>(IEnumerable<T>)	Retourne une collection des nœuds enfants de chaque document et élément de la collection source.
Remove<T>(IEnumerable<T>)	Supprime chaque nœud de la collection source de son nœud parent.

Cohérence de thread

La méthode Dispose n’est pas thread-safe. Tous les autres membres publics et protégés de BlockingCollection<T> sont thread-safe et peuvent être utilisés simultanément à partir de plusieurs threads.

Voir aussi

• Thread-Safe collections
• Vue d’ensemble BlockingCollection
• Comment : ajouter des fonctionnalités englobantes et bloquantes à une classe de collection