C# — Exceptions

Basic try-catch

using System;

class Program
{
    static void Main()
    {
        try
        {
            int result = 10 / 0;
        }
        catch (DivideByZeroException e)
        {
            Console.WriteLine($"Error: {e.Message}");
        }
    }
}

Multiple catch blocks

using System;

class Program
{
    static void Main()
    {
        try
        {
            string? input = Console.ReadLine();
            int number = int.Parse(input!);
            int result = 100 / number;
            Console.WriteLine($"Result: {result}");
        }
        catch (FormatException e)
        {
            Console.WriteLine($"Invalid format: {e.Message}");
        }
        catch (DivideByZeroException e)
        {
            Console.WriteLine($"Cannot divide by zero: {e.Message}");
        }
        catch (Exception e)
        {
            Console.WriteLine($"Unexpected error: {e.Message}");
        }
    }
}

finally block

using System;
using System.IO;

class Program
{
    static void Main()
    {
        StreamReader? reader = null;
        try
        {
            reader = new StreamReader("file.txt");
            string content = reader.ReadToEnd();
            Console.WriteLine(content);
        }
        catch (FileNotFoundException)
        {
            Console.WriteLine("File not found");
        }
        finally
        {
            reader?.Close();
            Console.WriteLine("Cleanup complete");
        }
    }
}

Using statement

using System;
using System.IO;

class Program
{
    static void Main()
    {
        // Automatically calls Dispose
        using (var reader = new StreamReader("file.txt"))
        {
            Console.WriteLine(reader.ReadToEnd());
        }

        // C# 8 using declaration
        using var writer = new StreamWriter("output.txt");
        writer.WriteLine("Hello, file!");
    }
}

Custom exceptions

using System;

public class InsufficientFundsException : Exception
{
    public decimal Balance { get; }
    public decimal Amount { get; }

    public InsufficientFundsException(decimal balance, decimal amount)
        : base($"Cannot withdraw {amount:C}. Balance: {balance:C}")
    {
        Balance = balance;
        Amount = amount;
    }
}

public class BankAccount
{
    public decimal Balance { get; private set; }

    public BankAccount(decimal initial) => Balance = initial;

    public void Withdraw(decimal amount)
    {
        if (amount > Balance)
            throw new InsufficientFundsException(Balance, amount);
        Balance -= amount;
    }
}

class Program
{
    static void Main()
    {
        var account = new BankAccount(100);
        try
        {
            account.Withdraw(150);
        }
        catch (InsufficientFundsException e)
        {
            Console.WriteLine(e.Message);
            Console.WriteLine($"Tried to withdraw: {e.Amount}");
        }
    }
}

Exception filters

using System;
using System.Net.Http;

class Program
{
    static async Task Main()
    {
        try
        {
            using var client = new HttpClient();
            var response = await client.GetAsync("https://invalid.example.com");
        }
        catch (HttpRequestException e) when (e.StatusCode == System.Net.HttpStatusCode.NotFound)
        {
            Console.WriteLine("Page not found");
        }
        catch (HttpRequestException e)
        {
            Console.WriteLine($"HTTP error: {e.Message}");
        }
    }
}

throw vs throw ex

using System;

class Program
{
    static void Process()
    {
        try
        {
            DoWork();
        }
        catch (Exception e)
        {
            // Good: preserves stack trace
            throw;

            // Bad: loses stack trace
            // throw e;
        }
    }

    static void DoWork()
    {
        throw new InvalidOperationException("Something went wrong");
    }
}

Common exceptions

Exception	When
ArgumentNullException	Null argument
ArgumentException	Invalid argument
InvalidOperationException	Invalid state
NotSupportedException	Operation not supported
KeyNotFoundException	Dictionary key not found
IndexOutOfRangeException	Array index out of bounds
FormatException	Invalid format
IOException	I/O error
NullReferenceException	Null dereference

Best practices

• Catch specific exceptions, not generic Exception
• Use finally or using for cleanup
• Don't catch exceptions you can't handle
• Use custom exceptions for domain-specific errors
• Always use throw (not throw ex) to preserve stack traces

Mini Practice

Write C# code that:

1. Creates a custom exception class
2. Uses try-catch-finally with file operations
3. Demonstrates exception filters with when
4. Shows the difference between throw and throw ex

Up Next

Congratulations! You've completed the C# fundamentals. Continue exploring advanced topics like LINQ, async/await, and design patterns.