Is there a proper pattern for multiple ContinueWith methods

Question

In the docs for TPL I found this line:

Invoke multiple continuations from the same antecedent

But this isn't explained any further. I naively assumed you could chain ContinueWiths in a pattern matching like manner until you hit the right TaskContinuationOptions.

TaskThatReturnsString()
    .ContinueWith((s) => Console.Out.WriteLine(s.Result), TaskContinuationOptions.OnlyOnRanToCompletion)
    .ContinueWith((f) => Console.Out.WriteLine(f.Exception.Message), TaskContinuationOptions.OnlyOnFaulted)
    .ContinueWith((f) => Console.Out.WriteLine("Cancelled"), TaskContinuationOptions.OnlyOnCanceled)
    .Wait();

But this doesn't work like I hoped for at least two reasons.

• The continuations are properly chained so the 2nd ContinueWith gets the result form the 1st, that is implemented as new Task, basically the ContinueWith task itself. I realize that the String could be returned onwards, but won't that be a new task with other info lost?
• Since the first option is not met, the Task is just cancelled. Meaning that the second set will never be met and the exceptions are lost.

So what do they mean in the docs when they say multiple continuations from the same antecedent? Is there a proper patter for this or do we just have to wrap the calls in try catch blocks?

---

EDIT

So I guess this was what I was hoping I could do, note this is a simplified example.

    public void ProccessAllTheThings()
    {
        var theThings = util.GetAllTheThings();
        var tasks = new List<Task>();
        foreach (var thing in theThings)
        {
            var task = util.Process(thing)
                        .ContinueWith((t) => Console.Out.WriteLine($"Finished processing {thing.ThingId} with result {t.Result}"), TaskContinuationOptions.OnlyOnRanToCompletion)
                        .ContinueWith((t) => Console.Out.WriteLine($"Error on processing {thing.ThingId} with error {t.Exception.Message}"), TaskContinuationOptions.OnlyOnFaulted);
            tasks.Add(task);
        }
        Task.WaitAll(tasks.ToArray());
    }

Since this wasn't possible I was thinking I would have to wrap each task call in a try catch inside the loop so I wouldn't stop the process but not wait on it there. I wasn't sure what the correct way.

Sometimes a solution is just staring you in the face, this would work wouldn't it?

    public void ProccessAllTheThings()
    {
        var theThings = util.GetAllTheThings();
        var tasks = new List<Task>();
        foreach (var thing in theThings)
        {
            var task = util.Process(thing)
                .ContinueWith((t) =>
                {
                    if (t.Status == TaskStatus.RanToCompletion)
                    {
                        Console.Out.WriteLine($"Finished processing {thing.ThingId} with result {t.Result}");
                    }
                    else
                    {
                        Console.Out.WriteLine($"Error on processing {thing.ThingId} - {t.Exception.Message}");
                    }
                });
            tasks.Add(task);
        }
        Task.WaitAll(tasks.ToArray());
    }

Answer 1

What you did is to create a sequential chain of multiple tasks.

What you need to do is attach all your continuation tasks to the first one:

var firstTask = TaskThatReturnsString();
var t1 = firstTask.ContinueWith (…);
var t2 = firstTask.ContinueWith (…);
var t3 = firstTask.ContinueWith (…);

Then you need to wait for all the continuation tasks:

Task.WaitAll (t1, t2, t3);