Exception Handling

In simple words#

Learning objectives#

• Catch exceptions with try and catch
• Catch specific exception types in the right order
• Run clean-up code with finally
• Throw your own and custom exceptions

Explanation#

Code that might fail goes in try { }. If an exception is thrown, C# jumps to the first matching catch block.

Catch specific types first (FormatException, ArgumentOutOfRangeException) and general ones (Exception) last. The first matching catch wins.

finally { } always runs — whether the try succeeded, failed or returned — so it is the place to close files or log the end of an operation. using does this automatically for IDisposable objects.

throw new ArgumentException("...") signals a problem. Create a custom exception by inheriting from Exception when callers need to handle a specific business error.

Exceptions are for unexpected situations. For expected failures, such as invalid user input, prefer the Try pattern: int.TryParse(text, out int value).

Syntax#

1try
2{
3    // risky code
4}
5catch (FormatException ex)   // specific first
6{
7}
8catch (Exception ex)         // general last
9{
10}
11finally
12{
13    // always runs
14}

Code example: Bad input and business errors#

1Console.WriteLine(ParseAge("25"));
2Console.WriteLine(ParseAge("abc"));
3Console.WriteLine(ParseAge("-3"));
4

5try
6{
7    Withdraw(balance: 100m, amount: 500m);
8}
9catch (InsufficientFundsException ex)
10{
11    Console.WriteLine(
quot;Error: {ex.Message} (short by {ex.Shortfall})");
12}
13finally
14{
15    Console.WriteLine("Transaction log closed");
16}
17

18Console.WriteLine(int.TryParse("42", out int n) ? 
quot;Parsed {n}" : "Not a number");
19

20static string ParseAge(string input)
21{
22    try
23    {
24        int age = int.Parse(input);
25        if (age < 0) throw new ArgumentOutOfRangeException(nameof(input), "Age cannot be negative");
26        return 
quot;Age: {age}";
27    }
28    catch (FormatException)
29    {
30        return 
quot;'{input}' is not a number";
31    }
32    catch (ArgumentOutOfRangeException ex)
33    {
34        return ex.Message;
35    }
36}
37

38static void Withdraw(decimal balance, decimal amount)
39{
40    if (amount > balance) throw new InsufficientFundsException(amount - balance);
41}
42

43class InsufficientFundsException(decimal shortfall) : Exception("Insufficient funds")
44{
45    public decimal Shortfall => shortfall;
46}

Age: 25
'abc' is not a number
Age cannot be negative (Parameter 'input')
Error: Insufficient funds (short by 400)
Transaction log closed
Parsed 42

This example is illustrative. Copy or download it and run it in your own environment; the expected output is shown above.

Step-by-step explanation#

1. int.Parse("abc") throws FormatException, which the first catch handles.
2. A negative age is valid number syntax, so the code throws ArgumentOutOfRangeException itself; .NET adds “(Parameter 'input')” to the message.
3. InsufficientFundsException is a custom exception carrying extra data (Shortfall).
4. finally runs after the catch, so the log is always closed.
5. int.TryParse avoids exceptions entirely when bad input is expected.

Real-world use case#

Common mistakes#

Best practices#

• Catch only exceptions you can actually handle
• Order catches from specific to general
• Use using / await using for anything IDisposable
• Handle unexpected exceptions in one global place in web apps

Remember this#

Practice exercise#

1Console.WriteLine(SafeDivide(10, 2));   // 5
2Console.WriteLine(SafeDivide(10, 0));   // Cannot divide by zero, then 0
3

4static int SafeDivide(int a, int b)
5{
6    try
7    {
8        return a / b;
9    }
10    catch (DivideByZeroException)
11    {
12        Console.WriteLine("Cannot divide by zero");
13        return 0;
14    }
15}

Mini quiz#

Want more? Practise all C# MCQs · C# interview questions

Related topics#

My notes#

Saved in this browser.