BlockingCollection<T> Class

IProducerConsumerCollection<T> represents a collection that allows for thread-safe adding and removing of data. BlockingCollection<T> is used as a wrapper for an IProducerConsumerCollection<T> instance, allowing removal attempts from the collection to block until data is available to be removed. Similarly, a BlockingCollection<T> can be created 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 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>.

We do not recommend that you modify the underlying collection directly. use the BlockingCollection<T> methods to add or take elements. The BlockingCollection<T> can become corrupted if the underlying collection is changed directly.

Note

The HostProtectionAttribute attribute applied to this type or member has the following Resources property value: Synchronization | ExternalThreading. The HostProtectionAttribute does not affect desktop applications (which are typically started by double-clicking an icon, typing a command, or entering a URL in a browser). For more information, see the HostProtectionAttribute class or SQL Server Programming and Host Protection Attributes.

The following example shows how to add and take items concurrently from a blocking collection:

class AddTakeDemo
{
        // Demonstrates:
        //      BlockingCollection<T>.Add()
        //      BlockingCollection<T>.Take()
        //      BlockingCollection<T>.CompleteAdding()
        static void Main()
        {
            BlockingCollection<int> bc = new BlockingCollection<int>();

            // Spin up a Task to populate the BlockingCollection 
            Task t1 = Task.Factory.StartNew(() =>
            {
                bc.Add(1);
                bc.Add(2);
                bc.Add(3);
                bc.CompleteAdding();
            });

            // Spin up a Task to consume the BlockingCollection
            Task t2 = Task.Factory.StartNew(() =>
            {
                try
                {
                    // Consume bc
                    while (true) Console.WriteLine(bc.Take());
                }
                catch (InvalidOperationException)
                {
                    // IOE means that Take() was called on a completed collection
                    Console.WriteLine("That's All!");
                }
            });

            Task.WaitAll(t1, t2);
        }
}

.NET Framework

.NET Framework Client Profile

Windows 7, Windows Vista SP1 or later, Windows XP SP3, Windows Server 2008 (Server Core not supported), Windows Server 2008 R2 (Server Core supported with SP1 or later), Windows Server 2003 SP2

The Dispose method is not thread-safe. All other public and protected members of BlockingCollection<T> are thread-safe and may be used concurrently from multiple threads.

Reference

Other Resources