I have a WinForm async GUI app in which I've set up some "global" exception handling in program.cs. I also have a GUI thread that's doing an "await Task.WhenAll()" and catching its exception and throwing the awaited Task.Exception property, so that the AggregateException gets all the way to the exception handler in program.cs (I want to iterate over the inner exceptions and log them).

I can see that the exception being thrown out of my try/catch of the WhenAll() is indeed throwing an AggreateException, but when I debug the handler in program.cs, it's not an AggregateException anymore - it's just the first Exception of the AggregateException. I can't figure out what code is doing this "unwrapping" for me? 

Program.cs:

```
static void Main() {
    Application.ThreadException += new System.Threading.ThreadExceptionEventHandler(Application_ThreadException);
    Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException);
    ...
    }

static void Application_ThreadException(object sender, System.Threading.ThreadExceptionEventArgs e) {
            if (e.Exception is AggregateException) {
                // expect to log the contents of (e.Exception as AggregateException).Flatten().InnerExceptions, but exception coming 
                // in is not AggregateException but instead is
                // ApplicationException("message 1")
                }
            else {
                // handling for non aggregate exceptions
                }

```

In Form1.cs

```
private async void button1_Click(object sender, EventArgs e) {

            Task overall = Task.WhenAll(
                Task.Run(()=>  { throw new ApplicationException("message 1"); }),
                Task.Run(() => { throw new ApplicationException("message 2"); })
                );

            try {
                await overall;
                }
            catch {
                throw overall.Exception; // this is AggregateException
                }
            }
        }

```