ValueTaskExtensions.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading.Tasks;
 
namespace Tgstation.Server.Common.Extensions
{
    public static class ValueTaskExtensions
    {
        public static async ValueTask<T[]> WhenAll<T>(IEnumerable<ValueTask<T>> tasks, int totalTasks)
        {
            if (tasks == null)
                throw new ArgumentNullException(nameof(tasks));
 
            // We don't allocate the list if no task throws
            Exception? exception = null;
            int i = 0;
            var results = new T[totalTasks];
            foreach (var task in tasks)
            {
                try
                {
                    results[i] = await task.ConfigureAwait(false);
                }
                catch (Exception ex)
                {
                    exception ??= ex;
                }
 
                ++i;
            }
 
            Debug.Assert(i == totalTasks, "Incorrect totalTasks specified!");
 
            if (exception != null)
                throw exception;
 
            return results;
        }
 
        public static async ValueTask<T[]> WhenAll<T>(IReadOnlyList<ValueTask<T>> tasks)
        {
            if (tasks == null)
                throw new ArgumentNullException(nameof(tasks));
 
            var totalTasks = tasks.Count;
            if (totalTasks == 0)
                return Array.Empty<T>();
 
            // We don't allocate the list if no task throws
            Exception? exception = null;
            var results = new T[totalTasks];
            for (var i = 0; i < totalTasks; i++)
                try
                {
                    results[i] = await tasks[i].ConfigureAwait(false);
                }
                catch (Exception ex)
                {
                    exception ??= ex;
                }
 
            if (exception != null)
                throw exception;
 
            return results;
        }
 
        public static ValueTask<T[]> WhenAll<T>(params ValueTask<T>[] tasks) => WhenAll((IReadOnlyList<ValueTask<T>>)tasks);
 
        public static async ValueTask WhenAll(IEnumerable<ValueTask> tasks)
        {
            if (tasks == null)
                throw new ArgumentNullException(nameof(tasks));
 
            // We don't allocate the list if no task throws
            Exception? exception = null;
            foreach (var task in tasks)
                try
                {
                    await task.ConfigureAwait(false);
                }
                catch (Exception ex)
                {
                    exception ??= ex;
                }
 
            if (exception != null)
                throw exception;
        }
 
        public static async ValueTask WhenAll(IReadOnlyList<ValueTask> tasks)
        {
            if (tasks == null)
                throw new ArgumentNullException(nameof(tasks));
 
            // We don't allocate the list if no task throws
            List<Exception>? exceptions = null;
            for (var i = 0; i < tasks.Count; ++i)
                try
                {
                    var task = tasks[i];
                    await task.ConfigureAwait(false);
                }
                catch (Exception ex)
                {
                    exceptions ??= new(tasks.Count - i);
                    exceptions.Add(ex);
                }
 
            if (exceptions != null)
                throw new AggregateException(exceptions);
        }
 
        public static ValueTask WhenAll(params ValueTask[] tasks) => WhenAll((IReadOnlyList<ValueTask>)tasks);
    }
}