Question

I have a class that returns an IEnumerable. I then execute these tasks in order. Let’s say the class is TaskProvider.

public class TaskProvider {
  public IEnumerable<Task> SomeThingsToDo() { return work; }
}

I am executing these with the following:

public void ExecuteTasks(IEnumerable<Task> tasks)
{
    var enumerator = tasks.GetEnumerator();
    ExecuteNextTask(enumerator);
}

static void ExecuteNextTask(IEnumerator<Task> enumerator)
{
    bool moveNextSucceeded = enumerator.MoveNext();

    if (!moveNextSucceeded) return;

    enumerator
        .Current
        .ContinueWith(x => ExecuteNextTask(enumerator));
}

Now I have a situation where I might have multiple instances of TaskProvider, each generating a list of tasks. I want each list of tasks to be executed in order, meaning that all the tasks from one provider finish before the next one starts.

Then, most importantly, I need to know when all the tasks are completed.

What’s the TPL way of accomplishing this?

(FWIW, I’m using the Async CTP for Silverlight.)

Answer 1

Here’s the approach I took, and so far all my tests are passing.

First, I created a unioned enumerable of all the tasks from the various providers:

var tasks = from provider in providers
            from task in provider.SomeThingsToDo()
            select task;

I believe that part of my original problem was that I did a ToList (more or less) and thus began the execution of the tasks prematurely.

Next, I added a callback to ExecuteTasks and ExecuteNextTask. Admittedly, not as clean as I’d hoped. Here’s the revised implementation:

public void ExecuteTasks(IEnumerable<Task> tasks, Action callback)
{
    var enumerator = tasks.GetEnumerator();
    ExecuteNextTask(enumerator, callback);
}

static void ExecuteNextTask(IEnumerator<Task> enumerator, Action callback)
{
    bool moveNextSucceeded = enumerator.MoveNext();

    if (!moveNextSucceeded)
    {
        if (callback != null) callback();
        return;
    }

    enumerator
        .Current
        .ContinueWith(x => ExecuteNextTask(enumerator, callback));
}

I didn’t need a thread-safe structure for storing the list of tasks, because the list is generated only once.