Exception Handling

What is an Exception?

An exception is an error that occurs while a program is running — like dividing by zero, accessing an invalid array index, or converting text that isn't actually a number. Without handling, an exception propagates upward, unwinding the call stack, and if nothing catches it, crashes the entire program with an unhandled exception message.

try / catch

A try block wraps code that might throw an exception; a matching catch block runs if one actually occurs, letting your program recover instead of crashing.

try
{
    int result = 10 / int.Parse("0");
    Console.WriteLine(result);
}
catch (Exception ex)
{
    Console.WriteLine($"Something went wrong: {ex.Message}");
}

The Exception Hierarchy

Every exception type in .NET ultimately derives from the base System.Exception class — this is why catch (Exception ex) can catch literally anything, and why more specific exception types (like DivideByZeroException) can be caught individually when you want more targeted handling.

Catching Specific Exceptions

It's better practice to catch specific exception types rather than a generic `Exception`, so you handle each failure mode appropriately — a missing file and an invalid password should almost certainly be handled differently, not lumped into one generic message.

try
{
    int[] numbers = { 1, 2, 3 };
    Console.WriteLine(numbers[5]);
}
catch (IndexOutOfRangeException)
{
    Console.WriteLine("That index doesn't exist in the array.");
}
catch (Exception ex)
{
    Console.WriteLine($"Unexpected error: {ex.Message}");
}

finally

Code in a `finally` block always runs, whether or not an exception occurred, and even if the try or catch block returns early — commonly used to release resources like file handles, network connections, or database connections, guaranteeing cleanup regardless of how the block exits.

try
{
    Console.WriteLine("Trying...");
    throw new Exception("Oops");
}
catch (Exception ex)
{
    Console.WriteLine($"Caught: {ex.Message}");
}
finally
{
    Console.WriteLine("Cleanup always runs.");
}

The using Statement (Automatic Cleanup)

For objects that hold an unmanaged resource (like a file handle) and implement IDisposable, a using statement automatically calls Dispose() when the block ends — equivalent to, but far less error-prone than, manually writing a try/finally that calls Dispose() yourself.

using (var file = new StreamReader("data.txt"))
{
    string content = file.ReadToEnd();
    Console.WriteLine(content);
} // file.Dispose() is called automatically here, even if an exception occurred above

Modern C# (8.0+) also supports a using declaration, without braces, that disposes the resource at the end of the enclosing scope.

using var file = new StreamReader("data.txt");
string content = file.ReadToEnd();
Console.WriteLine(content);
// file is automatically disposed at the end of this method

Throwing Your Own Exceptions

The throw keyword raises an exception explicitly — useful for validating input and refusing to proceed when something is genuinely wrong.

static double Divide(double a, double b)
{
    if (b == 0)
    {
        throw new ArgumentException("Cannot divide by zero.");
    }
    return a / b;
}

try
{
    Divide(10, 0);
}
catch (ArgumentException ex)
{
    Console.WriteLine(ex.Message);
}

Rethrowing Correctly

Sometimes a catch block needs to do something (like logging) and then let the exception continue propagating upward. A bare throw; preserves the original exception's full stack trace, while throw ex; resets it — a subtle but important distinction for debugging.

catch (Exception ex)
{
    LogError(ex);
    throw; // rethrows the SAME exception, stack trace intact
}

catch (Exception ex)
{
    LogError(ex);
    throw ex; // technically works, but the ORIGINAL throw location is lost
}

Common Beginner Mistakes

FAQs

Key Takeaways

Summary

Exception handling — try/catch/finally, the using statement, and careful rethrowing — is how production C# code fails gracefully instead of crashing outright. Next, you'll begin the object-oriented programming section of this course with classes and objects.