Async and Await with For Loop [duplicate]

Question

I have a Windows Service that runs various jobs based on a schedule. After determining which jobs to run, a list of schedule objects is sent to a method that iterates through list and runs each job. The problem is that some jobs can take up to 10 minutes to run because of external database calls.

My goal is to not have one job block others in queue, basically have more than one run at a time. I thought that using async and await could be to solve this, but I've never used these before.

Current Code:

public static bool Load(List<Schedule> scheduleList) { foreach (Schedule schedule in scheduleList) { Load(schedule.ScheduleId); } return true; } public static bool Load(int scheduleId) { // make database and other external resource calls // some jobs run for up to 10 minutes return true; }

I tried updating to this code:

public async static Task<bool> LoadAsync(List<Schedule> scheduleList) { foreach (Schedule schedule in scheduleList) { bool result = await LoadAsync((int)schedule.JobId, schedule.ScheduleId); } return true; } public async static Task<bool> LoadAsync(int scheduleId) { // make database and other external resource calls // some jobs run for up to 10 minutes return true; }

The issue is that the first LoadAsync waits for the job to finish before giving control back to the loop instead of allowing all the jobs to start.

I have two questions:

High Level - Are aysnc/await the best choice, or should I use a different approach?
What needs to be updated to allow the loop to kick off all the jobs without blocking, but not allow the function to return until all jobs are completed?

Yuval Itzchakov · Accepted Answer · 2016-10-06 23:10:55Z

High Level - Are async/await the best choice, or should I use a different approach?

async-await is perfect for what you're attempting to do, which is concurrently offloading multiple IO bound tasks.

What needs to be updated to allow the loop to kick off all the jobs without blocking, but not allow the function to return until all jobs are completed?

Your loop currently waits because you await each call to LoadAsync. What you want is to execute them all concurrently, than wait for all of them to finish using Task.WhenAll:

public async static Task<bool> LoadAsync(List<Schedule> scheduleList) { var scheduleTaskList = scheduleList.Select(schedule => LoadAsync((int)schedule.JobId, schedule.ScheduleId)).ToList(); await Task.WhenAll(scheduleTaskList); return true; }

Looks like a good solution. When I call LoadAsync from a non-async method, if I wrap that call in a try/catch block, will the exceptions be trapped from each individual job that was run?
@Josh If you call from a non-async method you will not get the exceptions until you await the call of the WhenAll.
Any advantage to your approach opposed to @IUnknown's approach using Parallel.ForEach?
My approach uses no extra threads other than the one you executed await Task.WhenAll on. Also, Parallel.ForEach and async-await dont play along nicely. your lambda will end up being translated into async void, which should be avoided.
hello i want need you r help i am new for the asyn and await and i have used in the for loop but its' correct or not idk can you please help me

Jorgen Thelin · Accepted Answer · 2014-09-27 00:08:13Z

For fan-out parallel async calls, you want to fire off the Task's to start them running, but then handle them as async future or promise values. You can just synchronize / await them at the end when all are finished.

Simplest way to do this is to turn your for-loop into something like this:

List<Task<bool>> jobs = new List<Task<bool>>(); foreach (var schedule in scheduleList) { Task<bool> job = LoadAsync((int) schedule.JobId, schedule.ScheduleId); // Start each job jobs.Add(job); } bool[] finishedJobStatuses = await Task.WhenAll(jobs); // Wait for all jobs to finish running bool allOk = Array.TrueForAll(finishedJobStatuses, p => p);

IUnknown · Accepted Answer · 2014-09-27 12:10:21Z

I would recommend using Parallel.ForEach. It is not asynchronous and runs each iteration in parallel. Exactly what you need.

public static bool Load(IEnumerable<Schedule> scheduleList) { // set the number of threads you need // you can also set CancellationToken in the options var options = new ParallelOptions { MaxDegreeOfParallelism = 5 }; Parallel.ForEach(scheduleList, options, async schedule => { await Load(schedule.ScheduleId); }); return true; }

This produces a compile error -- "Cannot await a bool", so I still need to call an async version of Load that returns Task<bool> instead of bool. Is the primary advantage to this approach that I don't need make the calling method that contains the Parallel.ForEach async? I assume error handling is same with this or using an async caller.
The problem with this approach is that it doesn't wait to exit until all the jobs are finished. Using await Task.WhenAll forces the function to wait.

Collectives™ on Stack Overflow

Async and Await with For Loop [duplicate]

3 Answers 3

7 Comments

Comments

2 Comments

Linked

Hot Network Questions