等待异步动作

Question

I've got a static generic method that is intended to perform an action on a collection in parallel (don't worry about throttling; I've got that covered; code here is the dumbed-down version):

public static IEnumerable<Task> RunAllAsync<T>(this IEnumerable<T> enumerable, Action<T> action)
{
    var tasks = new List<Task>();
    foreach (var t in enumerable)
    {
        tasks.Add(Task.Run(() => action(t)));
    }
    return tasks;
}

Here's an example of how the usage might be:

public async Task UsageSync()
{
    var numbers = Enumerable.Range(1, 5);
    var random = new Random();
    var tasks = numbers.RunAllAsync(i =>
                                    {
                                        Console.WriteLine($"A {i}");
                                        Thread.Sleep(random.Next(1000));
                                        Console.WriteLine($"B {i}");
                                    });
    Console.WriteLine("Awaiting end");
    await Task.WhenAll(tasks.ToArray());
    Console.WriteLine("awaited");
    Thread.Sleep(2000);
    Console.WriteLine("Finished");
}

Output:

Awaiting end
A 4
A 5
A 1
A 2
A 3
B 3
B 2
B 1
B 5
B 4
awaited
Finished

All as expected. But now we make that action itself an async delegate:

public async Task UsageAsync()
{
    var numbers = Enumerable.Range(1, 5);
    var random = new Random();
    var tasks = numbers.RunAllAsync(async i =>
                                    {
                                        Console.WriteLine($"A {i}");
                                        await Task.Run(() =>
                                                       {
                                                           Console.WriteLine($"B {i}");
                                                           Thread.Sleep(random.Next(1000));
                                                           Console.WriteLine($"C {i}");
                                                       });
                                    });
    Console.WriteLine("Awaiting end");
    await Task.WhenAll(tasks.ToArray());
    Console.WriteLine("awaited");
    Thread.Sleep(2000);
    Console.WriteLine("Finished");
}

Output:

Awaiting end
A 4
B 4
A 1
A 5
A 3
A 2
B 2
awaited
B 5
B 1
B 3
C 3
C 2
C 1
C 5
C 4
Finished

See that? The method reached "awaited" before the threads finished!

What should I be doing to ensure that the asynchronous action is awaited?

Answer 1

Since you're dealing with an Action<T> , async i => { ... } gets translated into an async void method. async void by design makes it impossible to wait for it to finish. Change your parameter to Func<T, Task> func and changing the call action(t) to await func(t) .