📝 Lesson 1.1: Exception Handling

What Is an Exception?

An exception is C#'s way of signaling that something went wrong at runtime — a problem the compiler couldn't catch, but that stops normal execution. You met one in the intro course: calling int.Parse("hello") throws a FormatException and crashes the program.

When an exception is thrown and nothing handles it, it travels up the call stack until it reaches the top and terminates the program with an error message. Exception handling lets you intercept that and decide what to do instead.

try and catch

You wrap risky code in a try block. If it throws, control jumps to the matching catch block instead of crashing:

try
{
    Console.Write("Enter a number: ");
    int number = int.Parse(Console.ReadLine());
    Console.WriteLine($"You entered {number}.");
}
catch (Exception ex)
{
    Console.WriteLine($"Something went wrong: {ex.Message}");
}

Console.WriteLine("The program continues normally.");

If the user types abc, int.Parse throws. Instead of crashing, the catch runs and the program keeps going:

Enter a number: abc
Something went wrong: The input string 'abc' was not in a correct format.
The program continues normally.

The catch (Exception ex) captures the exception object in ex. Its most useful member is ex.Message, a human-readable description of what happened.

Catching Specific Exceptions

Catching the broad Exception type works, but it treats every problem the same way. Usually you want to react differently to different failures. C# lets you write multiple catch blocks, each for a specific exception type:

try
{
    int[] numbers = { 1, 2, 3 };
    Console.Write("Enter an index: ");
    int i = int.Parse(Console.ReadLine());
    Console.WriteLine($"Value: {numbers[i]}");
}
catch (FormatException)
{
    Console.WriteLine("That wasn't a valid whole number.");
}
catch (IndexOutOfRangeException)
{
    Console.WriteLine("That index is outside the array.");
}
catch (Exception ex)
{
    Console.WriteLine($"Unexpected error: {ex.Message}");
}

C# checks the catch blocks top to bottom and runs the first one whose type matches the thrown exception.

Here are some exception types you'll meet often:

The finally Block

A finally block runs no matter what — whether the try succeeded, threw an exception, or the exception was caught. It's the place for cleanup that must always happen, like closing a file or releasing a resource:

try
{
    Console.WriteLine("Opening resource...");
    int result = 10 / int.Parse("0");   // throws DivideByZeroException
    Console.WriteLine(result);          // skipped
}
catch (DivideByZeroException)
{
    Console.WriteLine("Cannot divide by zero.");
}
finally
{
    Console.WriteLine("Cleaning up (always runs).");
}

Opening resource...
Cannot divide by zero.
Cleaning up (always runs).

Throwing Exceptions

You can raise exceptions yourself with the throw keyword. This is how a method signals that it was given something it can't work with — pushing the problem to the caller rather than silently continuing with bad data:

decimal Withdraw(decimal balance, decimal amount)
{
    if (amount <= 0)
    {
        throw new ArgumentException("Amount must be positive.");
    }
    if (amount > balance)
    {
        throw new InvalidOperationException("Insufficient funds.");
    }
    return balance - amount;
}

The caller decides how to respond by wrapping the call in try/catch:

try
{
    decimal newBalance = Withdraw(100m, 250m);
    Console.WriteLine($"New balance: {newBalance:C}");
}
catch (InvalidOperationException ex)
{
    Console.WriteLine($"Transaction declined: {ex.Message}");
}

Transaction declined: Insufficient funds.

Custom Exceptions

Sometimes the built-in exception types don't describe your problem well. You can define your own by creating a class that derives from Exception — a direct use of the inheritance you learned in the intro course:

class InsufficientFundsException : Exception
{
    public InsufficientFundsException(string message) : base(message)
    {
    }
}

Now you can throw and catch it by name, making your intent crystal clear:

decimal Withdraw(decimal balance, decimal amount)
{
    if (amount > balance)
    {
        throw new InsufficientFundsException(
            $"Tried to withdraw {amount:C} but only {balance:C} available.");
    }
    return balance - amount;
}

try
{
    Withdraw(100m, 250m);
}
catch (InsufficientFundsException ex)
{
    Console.WriteLine($"Declined: {ex.Message}");
}

Best Practices

💡 The mindset: Exception handling isn't about making errors disappear — it's about responding to them deliberately. A good handler either fixes the situation, informs the user, or logs the problem and re-raises it.

Exercise & Quiz

try
{
    Console.Write("Numerator: ");
    int a = int.Parse(Console.ReadLine());
    Console.Write("Denominator: ");
    int b = int.Parse(Console.ReadLine());

    Console.WriteLine($"Result: {a / b}");
}
// TODO: catch FormatException
// TODO: catch DivideByZeroException
// TODO: finally block

try
{
    Console.Write("Numerator: ");
    int a = int.Parse(Console.ReadLine());
    Console.Write("Denominator: ");
    int b = int.Parse(Console.ReadLine());

    Console.WriteLine($"Result: {Divide(a, b)}");
}
catch (FormatException)
{
    Console.WriteLine("Please enter valid whole numbers.");
}
catch (ArgumentException ex)
{
    Console.WriteLine($"Bad argument: {ex.Message}");
}
catch (DivideByZeroException)
{
    Console.WriteLine("You can't divide by zero.");
}
finally
{
    Console.WriteLine("Calculation attempt finished.");
}

int Divide(int a, int b)
{
    if (b == 0)
    {
        throw new ArgumentException("Denominator cannot be zero.");
    }
    return a / b;
}

Numerator: 10
Denominator: 0
Bad argument: Denominator cannot be zero.
Calculation attempt finished.

Summary

📚 Additional Resources

• Exceptions and exception handling — Microsoft Docs
• Best practices for exceptions
• try / catch / finally — reference

🚀 What's Next?

You can now keep programs running through errors. Next, we make code reusable and type-safe at the same time. In Lesson 1.2: Generics, you'll write classes and methods that work with any type — the technology behind List<T> itself.