How to properly catch exceptions in multiple async method calls?

Question

I have some async method:

public async Task<Object> MethodAsync()
{
    return await MakeHttpRequestAsync();
}

I need to make multiple calls of this method. One of them can throw an exception. But I need to keep all possible returned Objects from other method calls that succeeded.

Option 1:

Task t1 = MethodAsync();
Task t2 = MethodAsync();
try
{
    Task.WaitAll(new Task[]{t1,t2});
}
catch(Exception e)
{
   ...
}
//are t1 and t2 finished execution here with success or exception?

Option 2:

Task t1 = MethodAsync();
Task t2 = MethodAsync();
try
{
    t1.Wait()
}
catch(Exception e)
{
   ...
}

try
{
    t2.Wait()
}
catch(Exception e)
{
   ...
}
//what happens if t2 throws exception before t1 finished?

Any other options?

edit: Thought about third option:

    public async Task<Tuple<Object, Object>> MultipleAsyncCallsAsync(some arguments)
    {
            Object result1 = null, result2 = null;
            try
            {
                result1 = await MethodAsync();
            }
            catch(Exception e)
            {

            }
            try
            {
                result2 = await MethodAsync();
            }
            catch (Exception e)
            {

            }
            return Tuple.Create(result1, result2);
    }

edit #2:

Looks like third option is not working, but it's working this way:

public async Task<Tuple<object, object>> MultipleAsyncCallsAsync(some arguments)
    {
            object result1 = null, result2 = null;
            Task<object> t1 = null, t2 = null;
            t1 = Task.Run(()=> MethodAsync());
            t2 = Task.Run(()=> MethodAsync());
            try
            {
                result1 = await t1;
            }
            catch(Exception e)
            {

            }
            try
            {
                result2 = await t2;
            }
            catch (Exception e)
            {

            }
            return Tuple.Create(result1, result2);
    }

What doesn't work about edit #1 – Charlieface Apr 04 '21 at 22:38 — Charlieface, Apr 04 '21 at 22:38

Peter Bons · Accepted Answer · 2021-04-04T23:06:41.877

Put the tasks in an array and inspect their status like this:

    var t1 = MethodAsync();
    var t2 = MethodAsync();
    
    var tasks = new[] {t1, t2};
    
    try
    {
        await Task.WhenAll(tasks);
    }
    catch
    {
        var failedTasks = tasks.Where(t => t.IsFaulted);
        var allExceptions = failedTasks.Select(t => t.Exception?.Flatten());
    }
    
    var results = tasks.Where(t => t.IsCompletedSuccessfully).Select(t => t.Result);

What is does is it awaits all tasks and then uses the task status (using IsCompletedSuccessfully ect.) to get the results of all the tasks that did complete succesfully.

You can determine the failed tasks using IsFaulted and get their exception using the tasks Exception property.

If you want to catch/inspect the exception before the call to Task.WhenAll(..) is completed wrap the code inside MethodAsync in a try/catch:

public async Task<Object> MethodAsync()
{
    try
    {
        ..
    }
    catch(Exception ex)
    {
        //handle or throw
        return null;
    }
}

Or, if you cannot modify MethodAsync for some reason, you can wrap the method in a try/catch using this:

Func<Task<Object>, Task<Object>> TryExecute = new Func<Task<Object>, Task<object>>(async t =>
{
    try
    {
        return await t;
    }
    catch (Exception ex)
    {
        //handle exception
        return null;
    }
});

and use it like this:

    var t1 = TryExecute(MethodAsync());
    var t2 = TryExecute(MethodAsyncF());

    var tasks = new[] {t1, t2};

    await Task.WhenAll(tasks);

Thanks! It's working (though I had to change t.IsCompletedSuccessfully to !t.IsFaulted). Also it's hard to wrap my head around the fact that exceptions are thrown after the last task is finished, but it's happening this way. Therefore I will not know about exceptions untill all tasks are completed. — John, Apr 04 '21 at 21:03
What do you mean with: *Also it's hard to wrap my head around the fact that exceptions are thrown after the last task is finished* , do you see exceptions being raised after the call to ` await Task.WhenAll(tasks);`? That would be odd unless fo example you add tasks to the array after the call to WhenAll — Peter Bons, Apr 04 '21 at 21:05
I mean that I get into the catch block after the last task is completed. So technically I don't know about exceptions until at least one task still being executed — John, Apr 04 '21 at 21:15
@John correct, why is that a problem? I've updated my answer. — Peter Bons, Apr 04 '21 at 22:56

score 2 · Answer 2 · answered Apr 05 '21 at 14:33

Whenever there's a question about this kind of procedure ("call n methods, (a)wait for them all to complete, and then retrieve the results for each method and do something with them"), a better solution is almost always to create a higher-order method.

For example, if you want to do some kind of logging or something but otherwise ignore exceptions, then you can create a higher-order method like this:

public async Task<T> LogAndIgnoreExceptions(Task<T> task) where T : class
{
  try
  {
    return await task;
  }
  catch (Exception ex)
  {
    Log(ex);
    return null;
  }
}

Then you can use Task.WhenAll in a very natural way:

var results = await Task.WhenAll(
    LogAndIgnoreExceptions(MethodAsync()),
    LogAndIgnoreExceptions(MethodAsync())
);
if (results[0] is not null)
{
  T result = results[0];
}
else
{
  // First call had an error.
}

Or, if you want to preserve the exception details and results, what you want is a little helper type like Try to enable railway programming:

var results = await Task.WhenAll(
    Try.Create(MethodAsync()),
    Try.Create(MethodAsync())
);
if (results[0].IsValue)
{
  T result = results[0].Value;
}
else
{
  Exception exception = results[0].Exception;
}

Ima bit confused as you are returning null for a Task but here https://stackoverflow.com/questions/45347160/is-it-better-to-return-an-empty-task-or-null-c-sharp you indicate in bold "never return a null Task". So who is right? — Everts, Aug 16 '22 at 12:23
@Everts: both. The returned `Task` should never be `null`. The code above does not return a null task; it returns a task whose *result* is null. — Stephen Cleary, Aug 16 '22 at 15:45

How to properly catch exceptions in multiple async method calls?

2 Answers2