Monitoring Task Cancellation with a Delegate (or callback)

//
// You cannot directly interrupt a Task in .NET while it's running. You can do it
// indirectly through the CancellationTokenSource object. This object has a
// CancellationToken property which must be passed into the constructor of the Task:
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
CancellationToken cancellationToken = cancellationTokenSource.Token;

//
// The cancellation token can be used as follows... create the task:
Task task = Task.Factory.StartNew(() =>
{
    // We simply count up to 100000 in the Task body. Note the
    // IsCancellationRequested property of the token. We monitor within the loop
    // whether the task has been cancelled.
    for (int i = 0; i < 100000; i++)
    {
        if (cancellationToken.IsCancellationRequested)
        {
            Console.WriteLine("Task cancelled, must throw exception.");
            throw new OperationCanceledException(cancellationToken);
        }
        else
        {
            Console.WriteLine(i);
        }
    }
}, cancellationToken);

//
// You can register a delegate on the token that should be called when the task is cancelled:
cancellationToken.Register(() =>
{
    DoSomethingUponTaskCancellation();
});

//
// You can clean up resources, cancel other tasks that rely on this particular
// task, notify the user, log the cancellation etc., it's up to you how you
// implement the delegate. The Register method accepts an Action object or an
// Action of T which allows you to provide a state parameter.
//
// You can cancel the task by calling the Cancel() method of the token like this:
cancellationTokenSource.Cancel();

//
// Note that this method only signals the wish to cancel a task. .NET will not
// actively interrupt the task, you'll have to monitor the status through the
// IsCancellationRequested property. It is your responsibility to stop the task.
// In this example we throw an OperationCanceledException which is a must in
// order to correctly acknowledge the cancellation. If you forget this step then
// the task status will not be set correctly. Once the task has been requested
// the stop it cannot be restarted.
//
// If that's all you want to do, i.e. throw an OperationCanceledException, then
// there's a shorter version:
cancellationToken.ThrowIfCancellationRequested();

//
// This will perform the cancellation check and throw the exception in one step.
// The loop can thus be simplified as follows:
Task task = Task.Factory.StartNew(() =>
{
    for (int i = 0; i < 100000; i++)
    {
        // shorthand
        cancellationToken.ThrowIfCancellationRequested();

        Console.WriteLine(i);
    }
}, cancellationToken);