Practice Now
C#
Async Programming
Exception Handling
Task Parallel Library
Software Development

C Async Exception Wrapping

Interview Questions practice on Codemia

Over 8,000 real interview questions from top companies, searchable by company and role.

Browse interview questions
ConcurrencyC# & .NETDebugging & Errors

Introduction

In C#, exceptions thrown inside async methods are captured and wrapped in the returned Task rather than thrown immediately. When you await that task, the runtime unwraps the exception and rethrows the original exception. However, if you access Task.Result or Task.Wait() instead, the exception is wrapped in an AggregateException. Understanding this wrapping behavior is essential for writing correct error handling in async code.

How Async Exceptions Work

csharp
1async Task DoWorkAsync()
2{
3    throw new InvalidOperationException("Something went wrong");
4}

When DoWorkAsync() is called, the exception does not propagate immediately. Instead, it is stored in the returned Task object. How you observe the task determines what exception you see.

await Unwraps the Exception

csharp
1try
2{
3    await DoWorkAsync();
4}
5catch (InvalidOperationException ex)
6{
7    // Catches the original exception directly
8    Console.WriteLine(ex.Message); // "Something went wrong"
9}

await unwraps the first exception from the Task and rethrows it as-is. This is the recommended pattern — it behaves like synchronous exception handling.

Task.Wait() and Task.Result Wrap in AggregateException

csharp
1try
2{
3    DoWorkAsync().Wait(); // Synchronous blocking — avoid this
4}
5catch (AggregateException ex)
6{
7    // The original exception is nested inside AggregateException
8    Console.WriteLine(ex.InnerException?.Message); // "Something went wrong"
9}
10
11try
12{
13    var result = SomeAsyncMethod().Result; // Also wraps in AggregateException
14}
15catch (AggregateException ex)
16{
17    foreach (var inner in ex.InnerExceptions)
18    {
19        Console.WriteLine(inner.GetType().Name + ": " + inner.Message);
20    }
21}

Task.Wait() and Task.Result throw AggregateException because a Task can represent multiple operations (e.g., Task.WhenAll), each of which might fail independently.

Multiple Exceptions with Task.WhenAll

csharp
1async Task FailOne() => throw new InvalidOperationException("Fail 1");
2async Task FailTwo() => throw new ArgumentException("Fail 2");
3
4try
5{
6    await Task.WhenAll(FailOne(), FailTwo());
7}
8catch (InvalidOperationException ex)
9{
10    // await only rethrows the FIRST exception
11    Console.WriteLine(ex.Message); // "Fail 1"
12}
13
14// To see ALL exceptions, capture the task first
15var task = Task.WhenAll(FailOne(), FailTwo());
16try
17{
18    await task;
19}
20catch
21{
22    // task.Exception is an AggregateException with both failures
23    foreach (var ex in task.Exception!.InnerExceptions)
24    {
25        Console.WriteLine($"{ex.GetType().Name}: {ex.Message}");
26    }
27    // InvalidOperationException: Fail 1
28    // ArgumentException: Fail 2
29}

Exception Filters

Use exception filters to catch specific async exceptions:

csharp
1try
2{
3    await CallExternalApiAsync();
4}
5catch (HttpRequestException ex) when (ex.StatusCode == HttpStatusCode.NotFound)
6{
7    Console.WriteLine("Resource not found");
8}
9catch (HttpRequestException ex) when (ex.StatusCode == HttpStatusCode.Unauthorized)
10{
11    Console.WriteLine("Authentication required");
12}
13catch (Exception ex)
14{
15    Console.WriteLine($"Unexpected error: {ex.Message}");
16}

Exception filters (when) do not unwind the stack, preserving the original call stack for debugging.

Preserving Stack Traces

csharp
1try
2{
3    await DoWorkAsync();
4}
5catch (Exception ex)
6{
7    // WRONG — rethrow loses the original stack trace
8    // throw ex;
9
10    // CORRECT — preserves the original stack trace
11    throw;
12}
13
14// Or use ExceptionDispatchInfo for manual rethrowing
15using System.Runtime.ExceptionServices;
16
17ExceptionDispatchInfo? capturedException = null;
18try
19{
20    await DoWorkAsync();
21}
22catch (Exception ex)
23{
24    capturedException = ExceptionDispatchInfo.Capture(ex);
25}
26
27// Later, rethrow with original stack trace
28capturedException?.Throw();

async void Exception Behavior

csharp
1// DANGEROUS — exceptions crash the process
2async void FireAndForget()
3{
4    throw new Exception("This crashes the app!");
5    // Exception goes to SynchronizationContext, not the caller
6}
7
8// SAFE — return Task so the caller can handle exceptions
9async Task FireAndForgetSafe()
10{
11    throw new Exception("This can be caught by the caller");
12}
13
14// If you must use async void (event handlers), catch internally
15async void Button_Click(object sender, EventArgs e)
16{
17    try
18    {
19        await DoWorkAsync();
20    }
21    catch (Exception ex)
22    {
23        MessageBox.Show(ex.Message);
24    }
25}

async void methods cannot be awaited, so their exceptions propagate to the SynchronizationContext and typically crash the application.

ConfigureAwait and Exceptions

csharp
1try
2{
3    // ConfigureAwait(false) does not change exception behavior
4    var result = await DoWorkAsync().ConfigureAwait(false);
5}
6catch (InvalidOperationException ex)
7{
8    // Still catches the original exception
9    // But the catch block runs on a thread pool thread, not the UI thread
10    Console.WriteLine(ex.Message);
11}

Common Pitfalls

  • Using .Result or .Wait(): These wrap exceptions in AggregateException and can cause deadlocks in UI or ASP.NET contexts. Always use await instead.
  • async void methods: Exceptions in async void cannot be caught by the caller. They crash the process unless caught inside the method. Only use async void for event handlers.
  • Swallowing exceptions with Task.WhenAll: await Task.WhenAll(...) only rethrows the first exception. Capture the task and inspect task.Exception.InnerExceptions to see all failures.
  • throw ex instead of throw: throw ex resets the stack trace, making it impossible to find where the exception originally occurred. Always use bare throw to rethrow.
  • Catching AggregateException when using await: With await, you never see AggregateException — the original exception is unwrapped. Only catch AggregateException when using .Wait() or .Result.

Summary

  • await unwraps exceptions from tasks and rethrows the original — use this pattern
  • Task.Wait() and Task.Result wrap exceptions in AggregateException — avoid these
  • Task.WhenAll captures multiple exceptions but await only rethrows the first
  • async void methods cannot propagate exceptions to callers — only use for event handlers
  • Use throw (not throw ex) to preserve stack traces when rethrowing
  • Use ExceptionDispatchInfo.Capture() when you need to store and rethrow later
Related reading
Course
Intermediate
27 lessons
14 hours
OOD Fundamentals

Master object-oriented design from first principles, SOLID, design patterns, and classic interview problems with hands-on coding.

View the course
Track what you have practised

A free account saves your progress, solutions and study plan across every problem on Codemia.

Interview Questions practice on Codemia

Over 8,000 real interview questions from top companies, searchable by company and role.

Browse interview questions
Codemia
© 2026 Codemia
Resources
Legal
Social
All Rights Reserved.