Cancelling an Operation in a Concurrent Collection

using System;
using System.Collections.Concurrent;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

//
// .NET 4.5 Parallel Extensions Cookbook
// Chapter 5: Cancelling an operation in a concurrent collection
//
// When working with BlockingCollection, most Add and Take operations are
// performed in a loop. The TryAdd and TryTake methods of BlockingCollection can
// accept a CancellationToken parameter so that we can respond to cancellation
// requests and break out of a loop.
//
// In this recipe, we are going to create a Console application that has
// producer Task and consumer Task. The producer will be adding items to
// BlockingCollection using TryAdd, and the consumer will be removing items
// using Try.
//
// After the producer and consumer get started, we will call the Cancel method
// on a token source to see how we can use the TryAdd and TryTake overloads to
// handle cancellation of our operation.
//
// NOTE: For this recipe, we need to turn off the Visual Studio 2012 Exception
// Assistant. The Exception Assistant appears whenever a runtime Exception is
// thrown, and intercepts the Exception before it gets to our handler.
//
//  1. To turn off the Exception Assistant, go to the Debug menu and select Exceptions.
//  2. Uncheck the User-unhandled checkbox next to Common Language Runtime Exceptions.
//
// https://www.packtpub.com/application-development/net-45-parallel-extensions-cookbook
//

namespace CancelOperation
{
    class Program
    {
        static void Main(string[] args)
        {
            var data = Enumerable.Range(0, 100);
            var numbers = new BlockingCollection<int>(100);

            var tokenSource = new CancellationTokenSource();
            var token = tokenSource.Token;

            // A simple blocking producer
            Task.Factory.StartNew(() =>
            {
                foreach (var item in data)
                {
                    try
                    {
                        numbers.TryAdd(item, 5, token);
                        Console.WriteLine("Adding:{0} Item Count={1}", item, numbers.Count);
                    }
                    catch (OperationCanceledException)
                    {
                        Console.WriteLine("Adding operation has been cancelled");
                        numbers.CompleteAdding();
                        break;
                    }
                }
                numbers.CompleteAdding();
            }, token);

            // A simple blocking consumer
            Task.Factory.StartNew(() =>
            {
                int item = -1;

                while (!numbers.IsCompleted)
                {
                    try
                    {
                        numbers.TryTake(out item, 5, token);
                    }
                    catch (OperationCanceledException)
                    {
                        Console.WriteLine("Take operation has been cancelled");
                        break;
                    }
                    Console.WriteLine("Taking:{0} ", item);
                    // wait for a bit
                    Thread.SpinWait(10000);
                }

                Console.WriteLine("\rNo more items to take.");

            }, token);

            Thread.SpinWait(2000000);
            tokenSource.Cancel();

            Console.ReadLine();
        }
    }
}