using System;

using System.Threading;

using System.Threading.Tasks;

using System.Collections.Concurrent;

using System.Collections.Generic;

using System.Linq;

public class Program

{

    public static async Task Main()

    {

        var program = new Program();

        var start = DateTime.UtcNow;

        try

        {

            await ParallelInvoker.Run(

                TimeSpan.FromMilliseconds(2500),

                CancellationToken.None,

                program.Do01,

                program.Do02,

                program.Do03);

        }

        catch (ParallelInvocationException ex)

        {

            Console.WriteLine("Exceptions:");

            foreach (var item in ex.InvocationData)

            {

                Console.WriteLine("Name: {0} Exception: {1}", item.Callee.Method.Name, item.Exception.GetType().Name);

            }

        }

        var end = DateTime.UtcNow;

        Console.WriteLine("Duration: {0}", (end - start).TotalMilliseconds);

    }

    public async Task Do01(CancellationToken cancellationToken)

    {

        await Task.Delay(5000, cancellationToken);      

    }

    public async Task Do02(CancellationToken cancellationToken)

    {

        await Task.Delay(1000, cancellationToken);      

    }

    public Task Do03(CancellationToken cancellationToken)

    {

        throw new InvalidOperationException(nameof(Do03));

    }

}

​

public static class ParallelInvoker

{

    public static async Task Run(TimeSpan timeout, CancellationToken cancellationToken, params Func<CancellationToken, Task>[] callees)

    {

        _ = callees ?? throw new ArgumentNullException(nameof(callees));

        using var timeoutCts = new CancellationTokenSource(timeout);

        using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeoutCts.Token);

        cancellationToken = cts.Token;

        var failed = new ConcurrentQueue<(Func<CancellationToken, Task> Callee, Exception Exception)>();

        try

        {

            await Task.WhenAll(callees.Select(item => Task.Run(() => Invoke(item))));

        }

        catch

        {

            throw new ParallelInvocationException(failed);

        }

        async Task Invoke(Func<CancellationToken, Task> callee)

        {

            try

            {           

                await callee(cancellationToken).CanceledAsTimeout(timeoutCts.Token);

            }

            catch (Exception ex)

            {

                failed.Enqueue((callee, ex));

                throw;

            }                   

        }

    }

    public static async Task CanceledAsTimeout(this Task self, CancellationToken timeoutCancellationToken)

    {

        try

        {

            await self;

        }

        catch (OperationCanceledException) when (timeoutCancellationToken.IsCancellationRequested)

        {

            throw new TimeoutException();

        }

    }

}

​

public class ParallelInvocationException : Exception

{

    public ParallelInvocationException(IEnumerable<(Func<CancellationToken, Task> Callee, Exception Exception)> invocationData)

    {

        _ = invocationData ?? throw new ArgumentNullException(nameof(invocationData));

        this.InvocationData = invocationData;

    }

    public IEnumerable<(Func<CancellationToken, Task> Callee, Exception Exception)> InvocationData { get; }

}