Using ContinueWith with Multiple Tasks

Question

This is not behaving quite as I thought it would the need is simple, launch a number of tasks to do operations on an object. One unique object per task. The second part is a ContinueWith when each task reports the results. However, I am not getting a WhenAll type behavior. Hopefully someone can set me straight.

_tasks = new Task<AnalysisResultArgs>[_beansList.Count];
for (int loopCnt = 0; loopCnt < _beansList.Count; loopCnt++)
{
    _tasks[loopCnt] = Task<AnalysisResultArgs>.Factory.StartNew(() =>
    {
        return _beansList[loopCnt].Analyze(newBeanData);
    });
    await _tasks[loopCnt].ContinueWith(ReportResults, 
                  TaskContinuationOptions.RunContinuationsAsynchronously)  
    // do some housekeeping when all tasks are complete          
}

private void ReportResults(Task<AnalysisResultArgs> task)
{
     /* Do some serial operations
}

It was my understanding that _beansList.Count tasks would be launched and by using await on the ContinueWith the housekeeping work won't execute until all the Tasks have completed. I cannot block, as I need to be sure to be able to throttle the incoming data to prevent way too many tasks waiting to be executed.

Where did I goof, the await actually completes and the housekeeping gets run even though not ALL of the tasks have run to completion.

Please reduce to a minimal example that is complete and reproduces the problem. Side notes: If you use Task.Run instead of StartNew, and await instead of ContinueWith, then your code will be cleaner and behave better. — Stephen Cleary
– Stephen Cleary, Commented May 12, 2017 at 12:53
Stephen, I appreciate your comment and your recognized authority on this subject, however, that is a working minimal example, minus some of the additional classes. You statement about Task.Run rather than StartNew and using await (which I did) rather than ContinueWith, I will see if I can hunt the web for why that's better. I assumed that ContinueWith meant just that and await means just what it says. To paraphrase Start a new Task and when the task completes ContinueWith the second step. Await until all are frinish. — AeroClassics
– AeroClassics, Commented May 12, 2017 at 15:13
The example is not complete, though. I cannot paste it into a new project and observe its behavior in the debugger. I have blog posts on why StarNew is dangerous and why ContinueWith is dangerous. — Stephen Cleary
– Stephen Cleary, Commented May 12, 2017 at 15:25
@StephenCleary I have those blogs several times and they were a big help. No you cannot paste it into a project and step through. I apologize for that. Still your comments and thoers comments were a big help. — AeroClassics
– AeroClassics, Commented Nov 13, 2018 at 23:26

VMAtm · Accepted Answer · 2017-05-17 11:16:00Z

4

You do not await all the tasks, you're awaiting the continuation in loops. You should use the Task.WhenAll method for this. Also, why do you need the continuation, if you can run it inside task? Simplify your code like this:

private void ReportResults(AnalysisResultArgs results)
{
     /* Do some serial operations */
}

...
_tasks = new Task<AnalysisResultArgs>[_beansList.Count];
for (int loopCnt = 0; loopCnt < _beansList.Count; loopCnt++)
{
    var count = loopCnt;
    _tasks[count] = Task.Run(() =>
    {
        var results = _beansList[count].Analyze(newBeanData);
        ReportResults(results);
        return results;
    });
}

// do some housekeeping when all tasks are complete          
await Task.WhenAll(_tasks);

edited May 17, 2017 at 11:16

answered May 12, 2017 at 16:14

VMAtm

28.4k17 gold badges85 silver badges133 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

AeroClassics Over a year ago

dang! You are absolutely correct. So simple and right in front of my nose. Thank you! Much appreciated.

VMAtm Over a year ago

@AeroClassics Good luck with your projects :)

Mrinal Kamboj Over a year ago

there are two issues with the code,results need to be returned, else its a compilation error, since it is filled in the Task<AnalysisResultArgs>[] and loopCnt shall be assigned to a local variable else it will lead to index put of range Exception at run time

Mrinal Kamboj · Accepted Answer · 2017-05-17 06:53:05Z

As @Stephen has already mentioned, the code in the question is not minimum, complete and verifiable. I have taken some liberty to make some assumptions and that's how in my view your code shall look like:

public async Task<AnalysisResultArgs[]> MainMethod()
{
    var _beansList = new List<AnalysisResultArgs>();

    for(int i=0; i< 99; i++) // Considering 100 records
        _beansList.Add(new AnalysisResultArgs());

    var _tasks = new Task<AnalysisResultArgs>[_beansList.Count];

    for (int loopCnt = 0; loopCnt < _beansList.Count; loopCnt++)
    {
        var local = loopCnt;
        _tasks[local] = Task.Run(async() => await ReportResults(_beansList[local].Analyze(new AnalysisResultArgs())));
    }

    return await Task.WhenAll(_tasks);
}

private async Task<AnalysisResultArgs> ReportResults(Task<AnalysisResultArgs> task)
{
    await Task.Delay(1000);
    return await Task.FromResult(new AnalysisResultArgs());
}

public class AnalysisResultArgs
{   
    public async Task<AnalysisResultArgs> Analyze(AnalysisResultArgs newBeanData)
    {
        await Task.Delay(1000);
        return await Task.FromResult(new AnalysisResultArgs());
    }
}

Assumptions / Other details:

Task.Delay and Task.FromResult are the mere place holders of actual logic.
All methods in the call Analyze and ReportResults are Async

In the loop code could have been:

_tasks[local] = ReportResults(_beansList[local].Analyze(new 
         AnalysisResultArgs()));

but if we are using Task.Run to start a Task, then async, await helps in freeing up the calling thread pool thread / synchronization context. It helps in improving the system scalability.

Assumed _beansList is of type List<AnalysisResultArgs>, but that can be modified based on actual requirement
ReportResults could be modified to take a Func<Task<AnalysisResultArgs>> func, instead of simple dTask<AnalysisResultArgs>, thus doing await func() inside the method and then the calling code could have been truly async as follows:
```
  _tasks[local] = Task.Run(async() => await ReportResults(async() => await 
  _beansList[local].Analyze(new AnalysisResultArgs())));
```

Collectives™ on Stack Overflow

Using ContinueWith with Multiple Tasks

2 Answers 2

3 Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

3 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related