How can I guarantee continuations run in task completion order?

Question

If I have code that abstracts a staged sequence of asynchronous operations by returning a Task representing each stage, how can I ensure that continuations execute in stage order (i.e. the order in which the Tasks are completed)?

Note that this is a different requirement from simply 'not wasting time waiting for slower tasks'. The order needs to be guaranteed without race conditions in the scheduling. This looser requirement could addressed by parts of the answers to the following questions:

1. Sort Tasks into order of completition
2. Is there default way to get first task that finished successfully?

I think the logical solution would be to attach the continuations using a custom TaskScheduler (such as one based on a SynchronizationContext). However, I can't find any assurance that the scheduling of continuations is performed synchronously upon task completion.

In code this could be something like

class StagedOperationSource
{
    public TaskCompletionSource Connect = new TaskCompletionSource();
    public TaskCompletionSource Accept = new TaskCompletionSource();
    public TaskCompletionSource Complete = new TaskCompletionSource();
}
class StagedOperation
{
    public Task Connect, Accept, Complete;
    public StagedOperation(StagedOperationSource source)
    {
        Connect = source.Connect.Task;
        Accept = source.Accept.Task;
        Complete = source.Complete.Task;
    }
}
...
private StagedOperation InitiateStagedOperation(int opId)
{
    var source = new StagedOperationSource();
    Task.Run(GetRunnerFromOpId(opId, source));
    return new StagedOperation(source);
}
...
public RunOperations()
{
    for (int i=0; i<3; i++)
    {
        var op = InitiateStagedOperation(i);
        op.Connect.ContinueWith(t => Console.WriteLine("{0}: Connected", i));
        op.Accept.ContinueWith(t => Console.WriteLine("{0}: Accepted", i));
        op.Complete.ContinueWith(t => Console.WriteLine("{0}: Completed", i));
    }
}

which should produce output similar to

0: Connected
1: Connected
0: Accepted
2: Connected
0: Completed
1: Accepted
2: Accepted
2: Completed
1: Completed

Obviously the example is missing details like forwarding exceptions to (or cancelling) later stages if an earlier stage fails, but its just an example.

Answer 1

Just await each stage before going onto the next...

public static async Task ProcessStagedOperation(StagedOperation operation, int i)
{
    await operation.Connect;
    Console.WriteLine("{0}: Connected", i);
    await operation.Accept;
    Console.WriteLine("{0}: Accepted", i);
    await operation.Complete;
    Console.WriteLine("{0}: Completed", i);
}

You can then call that method in your for loop.

Answer 2

If you use TAP (Task Asynchronous Programming), i.e. async and await, you can make the flow of processing a lot more apparent. In this case I would create a new method to encapsulate the order of operations:

public async Task ProcessStagedOperation(StagedOperation op, int i)
{
    await op.Connect;
    Console.WriteLine("{0}: Connected", i);

    await op.Accept;
    Console.WriteLine("{0}: Accepted", i)

    await op.Complete;
    Console.WriteLine("{0}: Completed", i)
}

Now your processing loop gets simplified a bit:

public async Task RunOperations()
{
    List<Task> pendingOperations = new List<Task>();

    for (int i=0; i<3; i++)
    {
        var op = InitiateStagedOperation(i);
        pendingOperations.Add(ProcessStagedOperation(op, i));
    }

    await Task.WhenAll(pendingOperations); // finish
}

You now have a reference to a task object you can explicitly wait or simply await from another context. (or you can simply ignore it). The way I modified the RunOperations() method allows you to create a large queue of pending tasks but not block while you wait for them all to finish.