using System;

using System.Collections.Generic;

using System.Threading.Tasks;

public class Program

{

    public static async Task Main()

    {

        var tasks = new Task[]

        {

            Task.FromException(new Exception("Error 1")),

            Task.FromException(new Exception("Error 2")),

            Throw("Error 3", 5)

        };

        try

        {

            await Task.WhenAll(tasks);

            // Task.WhenAll(tasks).Wait();

            // Task.WaitAll(tasks);

            // await (Task.WhenAll(tasks).ContinueWith(t => Task.FromException(t.Exception), TaskContinuationOptions.OnlyOnFaulted).Unwrap());

        }

        catch (AggregateException e)

        {

            Unwrap(e);

        }

        catch (Exception e)

        {

            Print(e);

        }

    }

    public static void Unwrap(Exception e, int depth = 0)

    {

        var indent = Tabs(depth);

        if (e is AggregateException aggregate)

        {

            Console.WriteLine(indent + "Aggregate [Count = "+ aggregate.InnerExceptions.Count + "]");

            foreach (var inner in aggregate.InnerExceptions)

            {

                Unwrap(inner, depth + 1);

            }

        }

        else 

        {

            Print(e, depth);

        }

    }

    public static void Print(Exception e, int indent = 0)

    {

        Console.WriteLine(Tabs(indent) + e.GetType().Name + ": " + e.Message);

        Console.WriteLine(Tabs(indent + 1) + e.StackTrace);

    }

    public static string Tabs(int n) => 

        new string('\t', n);

    public static Task Throw(string message, int depth)

    {

        async Task Rec(int target, int current)

        {

            if (target == current) throw new Exception(message);

            else

            {

                await Rec(target, current + 1);

            }

        }

        return Task.Run(async () => await Rec(depth, 0));

    }

}