Exceptions: try, catch, finally and custom exceptions

What is an exception?

Things go wrong in real programs: the internet drops, a user types letters into an amount box, a file is missing. When .NET meets a problem it cannot handle in the normal flow, it creates an exception object and throws it. Throwing means: stop here and hand the problem upwards to whoever called this code, then their caller, and so on, until some code catches it.

try and catch

Console.Write("Amount: ");
try
{
    decimal amount = decimal.Parse(Console.ReadLine() ?? "");
    Console.WriteLine($"You entered {amount}");
}
catch (FormatException)
{
    Console.WriteLine("That is not a number.");
}

Several catch blocks and the Exception object

try
{
    string text = File.ReadAllText("prices.txt");
    int first = int.Parse(text.Split(',')[0]);
    Console.WriteLine(100 / first);
}
catch (FileNotFoundException ex)
{
    Console.WriteLine($"Missing file: {ex.FileName}");
}
catch (DivideByZeroException)
{
    Console.WriteLine("The first price is zero.");
}
catch (Exception ex)
{
    Console.WriteLine($"Unexpected error: {ex.Message}");
    throw;   // let it continue upwards after logging
}

Every exception has a Message (a human description), a StackTrace (the chain of method calls that led to it) and sometimes an InnerException (an earlier error that caused this one). Log all three when something unexpected happens.

finally: always runs

Console.WriteLine("Start");
try
{
    Console.WriteLine("Working");
    throw new InvalidOperationException("Printer jammed");
}
catch (InvalidOperationException ex)
{
    Console.WriteLine($"Caught: {ex.Message}");
}
finally
{
    Console.WriteLine("Cleanup");
}
Console.WriteLine("End");

For objects that implement IDisposable (files, connections), a using statement is the easy form of try/finally: it calls Dispose for you.

Throwing your own exceptions

static void Withdraw(decimal balance, decimal amount)
{
    ArgumentOutOfRangeException.ThrowIfNegativeOrZero(amount);
    if (amount > balance)
        throw new InsufficientFundsException(balance, amount);
}

public class InsufficientFundsException : Exception
{
    public decimal Balance { get; }
    public decimal Requested { get; }
    public InsufficientFundsException(decimal balance, decimal requested)
        : base($"Cannot withdraw {requested}; balance is only {balance}")
    {
        Balance = balance;
        Requested = requested;
    }
}

throw; versus throw ex;

Inside a catch block, throw; rethrows the same exception and keeps its original stack trace, so you can still see the line where it really started. throw ex; resets the stack trace to the catch block, hiding where the error came from. Always use throw; to rethrow. To add context, wrap it: throw new OrderException("Could not save order 1001", ex); which keeps the original as InnerException.

Exception filters

try { await client.GetStringAsync(url); }
catch (HttpRequestException ex) when (ex.StatusCode == System.Net.HttpStatusCode.NotFound)
{
    Console.WriteLine("Page not found");
}

Good habits and common mistakes

• Empty catch blocks (catch { }) hide bugs. At least log the error.
• Catching Exception everywhere: catch only what you can handle; let the rest reach a top-level handler that logs it.
• Using exceptions for normal decisions: checking input with TryParse is clearer and much faster than catching FormatException.
• throw ex; loses the stack trace: use throw;.
• Showing ex.StackTrace to end users: it can leak internal details. Show a friendly message and log the details.