取消时，连续链中的哪个任务正在运行？

Question

I have a continuation chain of Task s that may be cancelled, say, after a timeout occurs. I want to identify which task was running when the cancellation happened. Here's what I'm talking about:

CancellationTokenSource cts = new CancellationTokenSource();

Task timeoutTask = Task.Delay(5000).ContinueWith((t) => cts.Cancel());

Task workChain = Task.Factory.StartNew((t) =>
{
    Console.WriteLine("Running task " + Task.CurrentId);
    Thread.Sleep(1000);
}, -1, cts.Token);

Task parent = workChain;
for (int i = 0; i < 10; i++)
{
    parent = parent.ContinueWith((t, o) =>
        {
            Console.WriteLine("Running task " + Task.CurrentId);
            Console.WriteLine("Last Task.AsyncState = " + t.AsyncState);
            Thread.Sleep(1000);
        }, i, cts.Token, TaskContinuationOptions.OnlyOnRanToCompletion, TaskScheduler.Current);
}
parent.ContinueWith((t) =>
{
    Console.WriteLine("Cancel task " + Task.CurrentId);
    Console.WriteLine("Last running Task.AsyncState = " + t.AsyncState);
}, TaskContinuationOptions.OnlyOnCanceled);

When I run the above, the antecedent passed into the OnlyOnCanceled one isn't the task that was running when things were cancelled. I know why: the OnlyOnCanceled task is parented by the last task created in the loop, and when the timeout occurs, all tasks that aren't completed are marked as canceled without being started.

Having each task check the state of the token and store something elsewhere works most of the time, but there's a small chance that the cancellation happens after one task completes before the next task begins. In that case, I don't find out anything about the first canceled task. I could always store something when a task starts and something else if it is canceled, but this starts to feel kludgy pretty quickly.

Answer 1

Make each task that might be running record that it started or stopped executing. The TPL does not record which tasks were running when.

Answer 2

What I found works for me, but still doesn't feel as clean as it should:

• Each task in the main chain doesn't take the CancellationToken , but gets a second continuation (not part of the main chain) that runs OnlyOnFaulted .
• Each of those tasks does its work in a child task, then waits on the child task with by calling .Wait(CancellationToken) . When the token is canceled, the Wait call throws an exception, which faults the task that was running. This allows reporting of the error without waiting on the child task to complete.
• Every task in the main chain runs OnlyOnRanToCompletion .
• One task at the end of the main chain that runs OnlyOnRanToCompletion reports success of the entire chain (ie no timeout).

When the token is canceled, the currently-running task stops waiting for its child task with an OperationCanceledException . The side branch for that task handles the exception (or any other exception) by special-casing the presence of OperationCanceledException in the antecedent's AggregateException.InnerExceptions . Since the task in the main chain faulted, no other task in the main chain will run.

CancellationTokenSource cts = new CancellationTokenSource(25000);

Task workChain = Task.Factory.StartNew((o) =>
{
    Console.WriteLine("Running task {0} with state {1}", Task.CurrentId, o);
    Thread.Sleep(1000);
}, -1);

Task parent = workChain;
for (int i = 0; i < 10; i++)
{
    parent = parent.ContinueWith((ante, o) =>
        {
            Console.WriteLine("Running task {0} with state {1}", Task.CurrentId, o);
            Task subTask = Task.Factory.StartNew(() =>
            {
                Thread.Sleep(10000);
                Console.WriteLine("Subtask completed");
            });
            subTask.Wait(cts.Token);
        }, i, TaskContinuationOptions.OnlyOnRanToCompletion);
    parent.ContinueWith((ante) =>
        {
            foreach (Exception e in ante.Exception.InnerExceptions)
            {
                if (e is OperationCanceledException)
                {
                    //report timeout
                    Console.WriteLine("Timed out while running task id {0}", ante.Id);
                    return;
                }
            }
            //report other exception
            Console.WriteLine("Something bad happened: {0}", ante.Exception.GetBaseException());
        }, TaskContinuationOptions.OnlyOnFaulted);
}
Task lastTask = parent.ContinueWith((ante) =>
    {
        //report success
        Console.WriteLine("Success");
    }, TaskContinuationOptions.OnlyOnRanToCompletion);