Question

Guys, I used to use a method like Task.Factory.StartNew(new Action(()=>{}), cancellationToken);

I have a question about the second argument cancellationToken. Because cancellationToken is a variable in my method, in the lambda expression, I can cancel my task using the field just like the msdn does; I’m not sure it’s recommend. In this case, is the second argument necessary here? It is passed in the StartNew method, but not actually used. Is there a scenario we need use this argument?

Answer 1

You need this argument if you want to cancel the Task. If you’re application doesn’t support or require cancellation then you could just say

Task.Factory.StartNew(() => { ... });

Note that cancellation is cooperative so your code must poll for cancellation and respond accordingly.

For example:

CancellationTokenSource cts = new CancellationTokenSource();
CancellationToken token = cts.Token;

Task myTask = Task.Factory.StartNew(() =>
    {
        for (...)
        {
            token.ThrowIfCancellationRequested();

            // Body of for loop.
        }
    }, token);

    // ... elsewhere ...
    cts.Cancel();

You have to pass the cancellation token to the method otherwise it’s not attached to the task. The code within method is only using the token to respond to cancelation, either throwing or using the IsCancellationRequested to shut down. Although a task could cancel itself from within the lambda I guess. The task itself needs the token too.

here’s some further clarification:

Passing a token into StartNew
associates the token with the Task.
This has two primary benefits: 1) If
the token has cancellation requested
prior to the Task starting to execute,
the Task won’t execute. Rather than
transitioning to Running, it’ll
immediately transition to Canceled.
This avoids the costs of running the
task if it would just be canceled
while running anyway. 2) If the body
of the task is also monitoring the
cancellation token and throws an
OperationCanceledException containing
that token (which is what
ThrowIfCancellationRequested does),
then when the task sees that OCE, it
checks whether the OCE’s token matches
the Task’s token. If it does, that
exception is viewed as an
acknowledgement of cooperative
cancellation and the Task transitions
to the Canceled state (rather than the
Faulted state).

From http://social.msdn.microsoft.com/Forums/en/parallelextensions/thread/c2f614f6-c96c-4821-84cc-050b21aaee45

See general discussion of cancellation here:

http://msdn.microsoft.com/en-us/library/ff963549.aspx for further discussion.