Exception handling in async code in C Sharp (C#) - Step-by-Step Execution

Concept Flow - Exception handling in async code

Start async method

↓

Await async operation

↓

Exception thrown?

No→Continue execution

Yes↓

Catch exception

↓

Handle exception or rethrow

↓

End async method

This flow shows how an async method awaits an operation, checks for exceptions, catches them if any, and then handles or rethrows before finishing.

Execution Sample

C Sharp (C#)

async Task<int> GetNumberAsync()
{
    try
    {
        int result = await Task.Run<int>(() => throw new Exception("Fail"));
        return result;
    }
    catch (Exception ex)
    {
        return -1;
    }
}

This async method runs a task that throws an exception, catches it, and returns -1 instead.

Execution Table

Step	Action	Evaluation	Result
1	Start GetNumberAsync	No exception yet	Method started
2	Await Task.Run throwing Exception	Exception thrown inside Task	Exception propagates to await
3	Catch block triggered	Exception caught as ex	Catch block entered
4	Return -1 from catch	Return value set to -1	Method returns -1
5	Method completes	No further code	Execution ends

💡 Exception thrown inside awaited task is caught by catch block, so method returns -1 and completes normally.

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
result	undefined	exception thrown, no value	undefined	undefined
ex	null	null	Exception object	Exception object

Key Moments - 3 Insights

Why doesn't the exception crash the program immediately?

Because the exception happens inside the awaited Task, it is caught by the catch block in the async method (see Step 3 in execution_table), preventing a crash.

What happens if we don't catch the exception inside the async method?

If uncaught, the exception would propagate to the caller of the async method, potentially causing an unhandled exception error.

Why do we return -1 in the catch block?

Returning -1 is a way to signal failure gracefully instead of throwing, as shown in Step 4 of the execution_table.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'result' after Step 2?

A -1

B Undefined because exception was thrown

C 0

D Exception object

💡 Hint

Check Step 2 in execution_table where exception is thrown before 'result' can be assigned.

At which step does the catch block handle the exception?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

See execution_table Step 3 where catch block is triggered.

If the catch block was removed, what would happen after Step 2?

A Exception propagates to caller and method does not return normally

B Method returns -1 anyway

C Exception is ignored and method continues

D Method returns 0

💡 Hint

Without catch, exception is not handled inside method, so it propagates (see key_moments #2).

Concept Snapshot

async Task Method with try-catch:
- Await async operation inside try
- If exception thrown, catch block runs
- Handle exception or return fallback
- Prevents unhandled exceptions
- Keeps async flow safe and predictable

Full Transcript

This visual trace shows how exception handling works inside async code in C#. The async method starts and awaits a Task that throws an exception. Instead of crashing, the exception is caught by the catch block inside the async method. The catch block returns -1 to signal failure. Variables like 'result' remain undefined when the exception occurs, and the exception object is stored in 'ex'. This prevents the program from crashing and allows graceful error handling. If the catch block was missing, the exception would propagate to the caller and could cause an unhandled exception error. This pattern helps keep async code safe and predictable.