Question: I need help with a simple Task.WhenAll C# code. I have upto 50 different tasks being fired at the same time, however, some of these calls could return an error message.

I am trying to write the exception handling code, so that I can process the ones that worked (which it does), but capture the ones that errored, so I can perform additional code against them.

There is AggregateException, but is there a way to see which call/inputs that created that exception?

I'm unable to share the actual code due to strict company policy, but an example is as follows:

```
List<ListDetails> libs = getListDetails();
var tasks = new Task<List<ItemDetails>>[libs.Count];
for (int i = 0; i < libs.Count; i++)
{
    tasks[i] = getListItems(libs[i].ServerRelativeUrl, libs[i].ListId);
}

try
{
    await Task.WhenAll(tasks);
}
catch(AggregateException aex)
{
    //Capture which Server RelativeUrls and ListIDs that failed.    
}

```

Answer: 
You should check the `InnerExceptions` property, or you can use [`AggregateException.Flatten`](https://learn.microsoft.com/en-us/dotnet/api/system.aggregateexception.flatten?view=netframework-4.7.2) method as shown in the docs:

```
try {
     task1.Wait();
  }
  catch (AggregateException ae) {
     foreach (var e in ae.Flatten().InnerExceptions) {
        if (e is CustomException) {
           Console.WriteLine(e.Message);
        }
        else {
           throw;
        }
     }
  }

```

This will give you all the exceptions that are thrown by the child tasks but unfortunately there is no way to know which task threw a particular exception. You will need to investigate the stack traces.
You should make a array of async tasks then when you are going to add each task to array you should place a anonymous function with lambda expression in ContinueWith(){}. Here is an example :

```
var tasks = new List<Task>(); 
tasks.add(t.ContinueWith(o =>
{
    if(o.IsFaulted){
        Console.WriteLine(o.Exception?.InnerException);
        return;
        }

        Console.WriteLine(o.Result);
  }));

 tasks.WhenAll().ContinueWith(o=>{

Console.WriteLine("All Done!")
});

```