Free-ebooks-library - Bahar Ali Khan

TaskCreationOptions atp = TaskCreationOptions.AttachedToParent;
var parent = Task.Factory.StartNew (() =>
{
Task.Factory.StartNew (() => // Child
{
Task.Factory.StartNew (() => { throw null; }, atp); // Grandchild
}, atp);
});
// The following call throws a NullReferenceException (wrapped
// in nested AggregateExceptions):
parent.Wait();
Interestingly, if you check a task’s Exception property after it
has thrown an exception, the act of reading that property will
prevent the exception from subsequently taking down your application.
The rationale is that PFX’s designers don’t want you
ignoring exceptions—as long as you acknowledge them in some
way, they won’t punish you by terminating your program.
An unhandled exception on a task doesn’t cause immediate application
termination: instead, it’s delayed until the garbage
collector catches up with the task and calls its finalizer. Termination
is delayed because it can’t be known for certain that you
don’t plan to call Wait or check its Result or Exception property
until the task is garbage-collected. This delay can sometimes
mislead you as to the original source of the error (although Visual
Studio’s debugger can assist if you enable breaking on firstchance
exceptions).
As we’ll see soon, an alternative strategy for dealing with exceptions is with
continuations.
Canceling Tasks
You can optionally pass in a cancellation token when starting a task. This lets you
cancel tasks via the cooperative cancellation pattern described in “Safe Cancellation”
on page 857 in Chapter 21:
var cancelSource = new CancellationTokenSource();
CancellationToken token = cancelSource.Token;
Task task = Task.Factory.StartNew (() =>
{
// Do some stuff...
token.ThrowIfCancellationRequested(); // Check for cancellation request
// Do some stuff...
}, token);
...
cancelSource.Cancel();
Task Parallelism | 903
Parallel
Programming