CODEWITHSUNDEEP
c#multithreadingasynchronousasync-awaitc#-5.0
Hoppe
Hoppe

Reputation: 6815

How to convert WaitAll() to async and await

Is it possible to rewrite the code below using the async await syntax?

private void PullTablePages()
{
    var taskList = new List<Task>();
    var faultedList = new List<Task>();

    foreach (var featureItem in featuresWithDataName)
    {
        var task = Task.Run(() => PullTablePage();
        taskList.Add(task);

        if(taskList.Count == Constants.THREADS)
        {
            var index = Task.WaitAny(taskList.ToArray());
            taskList.Remove(taskList[index]);
        }
    }

    if (taskList.Any())
    {
        Task.WaitAll(taskList.ToArray());
    }

    //todo: do something with faulted list
}

When I rewrote it as below, the code doesn't block and the console application finishes before most of the threads complete.

It seems like the await syntax doesn't block as I expected.

private async void PullTablePagesAsync()
{
    var taskList = new List<Task>();
    var faultedList = new List<Task>();

    foreach (var featureItem in featuresWithDataName)
    {
        var task = Task.Run(() => PullTablePage();

        taskList.Add(task);

        if(taskList.Count == Constants.THREADS)
        {
            var anyFinished = await Task.WhenAny(taskList.ToArray());

            await anyFinished;

            for (var index = taskList.Count - 1; index >= 0; index--)
            {
               if (taskList[index].IsCompleted)
               {
                  taskList.Remove(taskList[index]);
               }
            }        
        }
    }

    if (taskList.Any())
    {
       await Task.WhenAll(taskList);
    }

    //todo: what to do with faulted list?
}

Is it possible to do so?

WaitAll doesn't seem to wait for all tasks to complete. How do I get it to do so? The return type says that it returns a task, but can't seem to figure out the syntax.## Heading ##

New to multithreading, please excuse ignorance.

Upvotes: 1

Views: 1027

Answers (2)

Ivan Stoev
Ivan Stoev

Reputation: 205819

Is it possible to rewrite the code below using the async await syntax?

Yes and no. Yes, because you already did it. No, because while being equivalent from the function implementation standpoint, it's not equivalent from the function caller perspective (as you already experienced with your console application). Contrary to many other C# keywords, await is not a syntax sugar. There is a reason why the compiler forces you to mark your function with async in order to enable await construct, and the reason is that now your function is no more blocking and that puts additional responsibility to the callers - either put themselves to be non blocking (async) or use a blocking calls to your function. Every async method in fact is and should return Task or Task<TResult> and then the compiler will warn the callers that ignore that fact. The only exception is async void which is supposed to be used only for event handlers, which by nature should not care what the object being notified is doing.

Shortly, async/await is not for rewriting synchronous (blocking code), but for easy turning it to asynchronous (non blocking). If your function is supposed to be synchronous, then just keep it the way it is (and your original implementation is perfectly doing that). But if you need asynchronous version, then you should change the signature to 

private async Task PullTablePagesAsync()

with the await rewritten body (which you already did correctly). And for backward compatibility provide the old synchronous version using the new implementation like this 

private void PullTablePages() { PullTablePagesAsync().Wait(); }

Upvotes: 1

Linky
Linky

Reputation: 604

It seems like the await syntax doesn't block as I expected.

You're expecting the wrong thing.

The await syntax should never block - it's just that the execution flow should not continue until the task is finished.

Usually you are using async/await in methods that return a task. In your case you're using it in a method with a return type void. It takes times to get your head around async void methods, that's why their use is usually discouraged. Async void methods run synchronously (block) to the calling method until the first (not completed) task is awaited. What happens after depends on the execution context (usually you're running on the pool). What's important: The calling method (the one that calls PullTablePAgesAsync) does not know of continuations and can't know when all code in PullTablePagesAsync is done.

Maybe take a look on the async/await best practices on MSDN

Upvotes: 1

Related Questions