ValueTask 的 Task.WhenAll

Question

Is there an equivalent of Task.WhenAll accepting ValueTask ?

I can work around it using

Task.WhenAll(tasks.Select(t => t.AsTask()))

This will be fine if they're all wrapping a Task but it will force the useless allocation of a Task object for real ValueTask .

Answer 1

By design, no. From the docs :

Methods may return an instance of this value type when it's likely that the result of their operations will be available synchronously and when the method is expected to be invoked so frequently that the cost of allocating a new Task for each call will be prohibitive.

…

For example, consider a method that could return either a Task<TResult> with a cached task as a common result or a ValueTask<TResult> . If the consumer of the result wants to use it as a Task<TResult> , such as to use with in methods like Task.WhenAll and Task.WhenAny , the ValueTask<TResult> would first need to be converted into a Task<TResult> using AsTask , which leads to an allocation that would have been avoided if a cached Task<TResult> had been used in the first place.

Answer 2

As @stuartd pointed out, it is not supported by design, I had to implement this manually:

public static async Task<IReadOnlyCollection<T>> WhenAll<T>(this IEnumerable<ValueTask<T>> tasks)
{
    var results = new List<T>();
    var toAwait = new List<Task<T>>();

    foreach (var valueTask in tasks)
    {
        if (valueTask.IsCompletedSuccessfully)
            results.Add(valueTask.Result);
        else
            toAwait.Add(valueTask.AsTask());
    }

    results.AddRange(await Task.WhenAll(toAwait).ConfigureAwait(false));

    return results;
}

Of course this will help only in high throughput and high number of ValueTask as it adds some other overheads.

NOTE: As @StephenCleary pointed out, this does not keep the order as Task.WhenAll does, if it is required it can be easily changed to implement it.

Answer 3

Unless there is something I'm missing, we should be able to just await all the tasks in a loop:

public static async ValueTask<T[]> WhenAll<T>(params ValueTask<T>[] tasks)
{
    // Argument validations omitted

    var results = new T[tasks.Length];
    for (var i = 0; i < tasks.Length; i++)
        results[i] = await tasks[i].ConfigureAwait(false);

    return results;
}

Allocations
Awaiting a ValueTask that is completed synchronously shouldn't cause a Task to be allocated. So the only "extra" allocation happening here is of the array we use for returning the results.

Order
Order of the returned items are the same as the order of the given tasks that produce them.

Exceptions
When a task throws an exception, the above code would stop waiting for the rest of the exceptions and just throw. If this is undesirable, we could do:

public static async ValueTask<T[]> WhenAll<T>(params ValueTask<T>[] tasks)
{
    Exception? exception = null;

    var results = new T[tasks.Length];
    for (var i = 0; i < tasks.Length; i++)
        try
        {
            results[i] = await tasks[i].ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            // Remember the first exception, swallow the rest
            exception ??= ex;
        }

    return exception is null
        ? results
        : throw exception;
}

We throw the first exception directly as wrapping it with an AggregateException is not a ValueTask thing.

Task<T>.Result remarks :

...if an exception occurred during the operation of the task, or if the task has been cancelled, the Result property does not return a value. Instead, attempting to access the property value throws an AggregateException exception .

ValueTask<T>.Result remarks :

If this ValueTask has faulted, this property raises an exception. The thrown exception is not wrapped in an AggregateException .

But if we did want our WhenAll method to throw an AggregateException containing all the exceptions thrown, we could do:

public static async ValueTask<T[]> WhenAll<T>(params ValueTask<T>[] tasks)
{
    // We don't allocate the list if no task throws
    List<Exception>? exceptions = null;

    var results = new T[tasks.Length];
    for (var i = 0; i < tasks.Length; i++)
        try
        {
            results[i] = await tasks[i].ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            exceptions ??= new List<Exception>(tasks.Length);
            exceptions.Add(ex);
        }

    return exceptions is null
        ? results
        : throw new AggregateException(exceptions);
}

Answer 4

Here is a variant of the WhenAll extension method that attempts to improve upon Stefano d'Antonio's answer , by restoring the order of the results according to the original order of the ValueTask 's.

---

Update: I discarded the previous implementation for a new one that removes the need of sorting the results.

public static async Task<TResult[]> WhenAll<TResult>(
    this IEnumerable<ValueTask<TResult>> tasks)
{
    // The volatile property IsCompleted must be accessed only once
    var tasksArray = tasks.Select(t => t.IsCompleted ?
        (
            HasResult : true,
            Result: t.Result,
            Task: (Task<TResult>)null
        ) : (
            HasResult : false,
            Result: default(TResult),
            Task: t.AsTask()
        ))
        .ToArray();

    var pendingTasks = tasksArray
        .Where(t => !t.HasResult)
        .Select(t => t.Task);

    await Task.WhenAll(pendingTasks).ConfigureAwait(false);

    return tasksArray
        .Select(t => t.HasResult ? t.Result : t.Task.Result)
        .ToArray();
}

Answer 5

    public static class TaskExtensions
    {
        /// <summary>
        /// Wait for all ValueTasks to complete in a IEnumerable<ValueTask>
        /// </summary>
        public static async Task WhenAllValueTasks(this IEnumerable<ValueTask> tasks)
        {
            foreach (var taskToAWait in tasks)
            {
                await taskToAWait;
            }
        }
    }

Answer 6

Tried to do some optimization, result returned in correct order and correct exception handling.

public static ValueTask<T[]> WhenAll<T>(IEnumerable<ValueTask<T>> tasks)
    {
        var list = tasks.ToList();
        var length = list.Count;
        var result = new T[length];
        var i = 0;

        for (; i < length; i ++)
        {
            if (list[i].IsCompletedSuccessfully)
            {
                result[i] = list[i].Result;
            }
            else
            {
                return WhenAllAsync();
            }
        }

        return new ValueTask<T[]>(result);

        async ValueTask<T[]> WhenAllAsync()
        {
            for (; i < length; i ++)
            {
                try
                {
                    result[i] = await list[i];
                }
                catch
                {
                    for (i ++; i < length; i ++)
                    {
                        try
                        {
                            await list[i];
                        }
                        catch
                        {
                            // ignored
                        }
                    }

                    throw;
                }
            }

            return result;
        }
    }

Answer 7

I'm using this extension method:

internal static class ValueTaskExtensions
{
    public static Task WhenAll(this IEnumerable<ValueTask> tasks)
    {
        return Task.WhenAll(tasks.Select(v => v.AsTask()));
    }
}