2

I noticed I was not getting logging messages in my app when some new async code was throwing an error. I have an app that kicks off a small number of indefinitely-running async tasks. Each of them runs their own while(true) loop.

I have some error logging in a couple places, but I noticed that the exception propagation stops when it gets to the bounds of the infinite while loop within the Task. Originally, my logging was only outside that loop, and while that particular Task stopped running, the error was not getting logged.

Here is a sample program that shows the same behavior - if I remove the while(true) so that the Track() method only runs once through, then the exception bubbles up to the RunAsync() method, and the app crashes (which is what I would want). But with the while loop in there, it continues to run the loop for number 2, and number 1 dies a silent death.

I understand that unawaited Tasks can get their exceptions swallowed, but I believe I am awaiting everything that needs awaiting - please correct me if I'm wrong.

static void Main(string[] args)
{
    Console.WriteLine("Starting up");
    RunAsync().GetAwaiter().GetResult();
    Console.WriteLine("Shutting down");
}


private static async Task RunAsync()
{
    try
    {
        Console.WriteLine("In RunAsync");
        List<int> trackers = new List<int> { 1, 2 };

        await Task.WhenAll(trackers.Select(tracker => Track(tracker)));
    }
    catch (Exception e)
    {
        Console.WriteLine($"{DateTime.Now:HH:mm:ss.fff} => Error in RunAsync\n{e.StackTrace}");
        throw;
    }

}


private static async Task Track(int number)
{
    Console.WriteLine($"Starting tracker for {number}");

    while (true)    // This causes the exception to not propagate up
    {
        Console.WriteLine($"In here for number {number}");

        if (number == 1)
        {
            throw new Exception("Oops! Number 1 does not work");
        }

        await Task.Delay(1000);

    }

}

Is there something I should be doing differently to handle the exceptions that may occur within that loop?

Here is the output with the loop in place

Starting up
In RunAsync
Starting tracker for 1
In here for number 1
Starting tracker for 2
In here for number 2
In here for number 2
In here for number 2

and here it is without the while loop

Starting up
In RunAsync
Starting tracker for 1
In here for number 1
Starting tracker for 2
In here for number 2
16:58:34.916 => Error in RunAsync
   at Program.<Track>d__2.MoveNext() in Program.cs:line 48
--- End of stack trace from previous location where exception was thrown ---
Danny
  • 1,740
  • 3
  • 22
  • 32
  • This? https://stackoverflow.com/questions/12007781/why-doesnt-await-on-task-whenall-throw-an-aggregateexception – Rand Random Jul 11 '22 at 22:08
  • Mmm...don't think so - I don't appear to be getting _any_ exception. I think that question is wanting a set of all the exceptions that happened, rather than just the first one – Danny Jul 11 '22 at 22:12
  • Related: [How can I await an array of tasks and stop waiting on first exception?](https://stackoverflow.com/questions/57313252/how-can-i-await-an-array-of-tasks-and-stop-waiting-on-first-exception) – Theodor Zoulias Jul 12 '22 at 06:03

1 Answers1

6

Task.WhenAll will (asynchronously) wait for all tasks to complete. If one of them completes with an exception, then it will still wait for the other tasks to complete before (re)throwing the exception.

With the while (true) in place, one of the tasks has completed with an exception and the other task executes indefinitely; since one of the tasks never completes, the WhenAll also doesn't complete and doesn't (re)throw the exception. Without the while (true), both tasks complete quickly, one of them with an exception, and so the WhenAll completes and (re)throws the exception.

If you want a WhenAll that has fail-fast behavior, there is nothing built-in with that behavior, but there are a few solutions on Stack Overflow and elsewhere. Some of them get fancy with triggering a CancellationToken in the fail-fast handling.

Stephen Cleary
  • 437,863
  • 77
  • 675
  • 810
  • `WhenAny` with retry is likely what OP would have to use... – Alexei Levenkov Jul 11 '22 at 23:44
  • I figured there was some nuance that I didn't know about - I was naively expecting the exception would get thrown immediately. I think `WhenAny` will actually serve my purposes since I never actually expect _any_ of the Tasks to resolve. There might be a more appropriate paradigm entirely that I should be using, but this at least explains the behavior that I didn't understand - thanks – Danny Jul 12 '22 at 13:35
  • @Danny - why even bother to await when that task should run indefinitely? – Rand Random Jul 12 '22 at 15:36
  • @RandRandom - if I don't await it then the app just ends immediately. It doesn't really take any other action other than kicking off those tasks – Danny Jul 12 '22 at 15:59