Exception handling in async code in C Sharp (C#) - Mini Project: Build & Apply

Exception handling in async code

📖 Scenario: You are building a simple program that fetches data asynchronously. Sometimes, the fetch might fail, and you want to handle those errors gracefully.

🎯 Goal: Learn how to handle exceptions in asynchronous methods using try-catch blocks in C#.

📋 What You'll Learn

Create an async method that simulates data fetching

Add a boolean variable to control if the fetch should fail

Use a try-catch block to handle exceptions in the async method call

Print the result or error message

💡 Why This Matters

🌍 Real World

Handling errors in asynchronous operations is important in real-world apps like web requests, file access, or database calls to keep the app stable.

💼 Career

Knowing how to catch and handle exceptions in async code is a key skill for C# developers working on modern applications that use asynchronous programming.

1

Create an async method to fetch data

Write an async method called FetchDataAsync that returns a Task<string>. Inside, use await Task.Delay(500) to simulate waiting, then return the string "Data fetched successfully".

C Sharp (C#)

// Your code here

Hint

Use async Task<string> as the method signature and await Task.Delay(500) to simulate delay.

2

Add a boolean to control failure

Add a public static boolean variable called shouldFail in the Program class and set it to false. Modify FetchDataAsync to throw an Exception with message "Fetch failed" if shouldFail is true.

C Sharp (C#)

using System.Threading.Tasks;

class Program
{
    // Add the boolean variable here

    public static async Task FetchDataAsync()
    {
        await Task.Delay(500);
        // Throw exception if shouldFail is true
        return "Data fetched successfully";
    }
}

Hint

Use if (shouldFail) to check the boolean and throw new Exception("Fetch failed") to raise an error.

3

Use try-catch to handle exceptions

In the Main method, call FetchDataAsync inside a try block and await its result. Use a catch (Exception ex) block to catch exceptions. Store the result or the exception message in a string variable called output.

C Sharp (C#)

using System;
using System.Threading.Tasks;

class Program
{
    public static bool shouldFail = false;

    public static async Task FetchDataAsync()
    {
        await Task.Delay(500);
        if (shouldFail)
        {
            throw new Exception("Fetch failed");
        }
        return "Data fetched successfully";
    }

    public static async Task Main()
    {
        // Use try-catch and call FetchDataAsync
    }
}

Hint

Use try and catch (Exception ex) to handle errors. Assign the awaited call result or exception message to output.

4

Print the output

Add a line in the Main method to print the output variable using Console.WriteLine(output).

C Sharp (C#)

using System;
using System.Threading.Tasks;

class Program
{
    public static bool shouldFail = false;

    public static async Task FetchDataAsync()
    {
        await Task.Delay(500);
        if (shouldFail)
        {
            throw new Exception("Fetch failed");
        }
        return "Data fetched successfully";
    }

    public static async Task Main()
    {
        string output;
        try
        {
            output = await FetchDataAsync();
        }
        catch (Exception ex)
        {
            output = ex.Message;
        }
        // Print the output
    }
}

Hint

Use Console.WriteLine(output) to show the result or error message.

Practice

1. What is the main purpose of using try and catch blocks around await calls in C# async code?

easy

A. To catch exceptions thrown during asynchronous operations and prevent program crashes.

B. To make the async method run faster.

C. To convert async methods into synchronous methods.

D. To automatically retry the async operation if it fails.

Solution

1. Step 1: Understand async exception behavior

   Exceptions in async methods are thrown when awaited, so they must be caught around await.

2. Step 2: Purpose of try-catch

   Using try and catch around await lets you handle errors gracefully and avoid crashes.

3. Final Answer:

   To catch exceptions thrown during asynchronous operations and prevent program crashes. -> Option A

4. Quick Check:

   try-catch around await = catch exceptions [OK]

Hint: Always put await inside try to catch errors [OK]

Common Mistakes:

• Assuming async methods never throw exceptions
• Catching exceptions outside async calls
• Using try-catch without await inside

2. Which of the following is the correct syntax to catch exceptions from an async method DoWorkAsync()?

easy

A. await try { DoWorkAsync(); } catch (Exception ex) { Console.WriteLine(ex.Message); }

B. try { await DoWorkAsync(); } catch (Exception ex) { Console.WriteLine(ex.Message); }

C. try { DoWorkAsync(); } catch (Exception ex) { Console.WriteLine(ex.Message); }

D. DoWorkAsync().catch(ex => Console.WriteLine(ex.Message));

Solution

1. Step 1: Identify correct try-catch with await

   The await keyword must be inside the try block to catch exceptions properly.

2. Step 2: Check syntax correctness

   try { await DoWorkAsync(); } catch (Exception ex) { Console.WriteLine(ex.Message); } correctly places await DoWorkAsync() inside try and catches exceptions.

3. Final Answer:

   try { await DoWorkAsync(); } catch (Exception ex) { Console.WriteLine(ex.Message); } -> Option B

4. Quick Check:

   await inside try = correct syntax [OK]

Hint: Put await inside try, not outside [OK]

Common Mistakes:

• Placing await outside try block
• Missing await keyword
• Using incorrect catch syntax

3. What will be the output of the following code?

async Task TestAsync()
{
    try
    {
        await Task.Run(() => throw new InvalidOperationException("Error occurred"));
    }
    catch (InvalidOperationException ex)
    {
        Console.WriteLine("Caught: " + ex.Message);
    }
}

await TestAsync();

medium

A. Unhandled exception crash

B. No output, program runs silently

C. Caught: Error occurred

D. Compilation error

Solution

1. Step 1: Analyze async exception throwing

   The Task.Run throws an InvalidOperationException inside the task.

2. Step 2: Exception caught in catch block

   The await inside try catches the exception, printing the message.

3. Final Answer:

   Caught: Error occurred -> Option C

4. Quick Check:

   Exception caught and message printed [OK]

Hint: Exceptions in awaited tasks are caught by surrounding try [OK]

Common Mistakes:

• Expecting no output
• Thinking exception crashes program
• Missing await causes unhandled exceptions

4. Identify the error in this async exception handling code:

async Task RunAsync()
{
    try
    {
        Task.Delay(1000);
    }
    catch (Exception ex)
    {
        Console.WriteLine("Error: " + ex.Message);
    }
}

await RunAsync();

medium

A. Missing await before Task.Delay, so exceptions won't be caught.

B. Try-catch cannot be used with async methods.

C. Task.Delay does not throw exceptions, so catch is useless.

D. Catch block syntax is incorrect.

Solution

1. Step 1: Check await usage

   The Task.Delay(1000) is called without await, so exceptions won't be observed here.

2. Step 2: Effect on exception handling

   Without await, the try-catch does not catch exceptions from the async call.

3. Final Answer:

   Missing await before Task.Delay, so exceptions won't be caught. -> Option A

4. Quick Check:

   Await missing = exceptions not caught [OK]

Hint: Always await async calls inside try to catch exceptions [OK]

Common Mistakes:

• Forgetting await before async calls
• Assuming try-catch works without await
• Believing Task.Delay throws exceptions here

5. You have two async methods:

async Task MethodA()
{
    await Task.Delay(500);
    throw new Exception("Error in A");
}

async Task MethodB()
{
    try
    {
        await MethodA();
    }
    catch (Exception ex)
    {
        Console.WriteLine("Caught in B: " + ex.Message);
        throw;
    }
}

try
{
    await MethodB();
}
catch (Exception ex)
{
    Console.WriteLine("Caught in main: " + ex.Message);
}

What will be the output when this code runs?

hard

A. No output, exception swallowed

B. Caught in B: Error in A

C. Caught in main: Error in A

D. Caught in B: Error in A
Caught in main: Error in A

Solution

1. Step 1: Exception thrown in MethodA

   MethodA throws an exception after delay.

2. Step 2: Exception caught and rethrown in MethodB

   MethodB catches the exception, prints message, then rethrows it.

3. Step 3: Exception caught again in main

   Main try-catch catches the rethrown exception and prints its message.

4. Final Answer:

   Caught in B: Error in A Caught in main: Error in A -> Option D

5. Quick Check:

   Exception caught twice due to rethrow [OK]

Hint: Rethrow exceptions to propagate them up the call stack [OK]

Common Mistakes:

• Assuming exception is swallowed after first catch
• Missing that rethrow sends exception to caller
• Expecting only one catch message printed