C# Exception Handling Explained — try, catch, finally and Real Patterns

using System;
using System.IO;

class FileReaderExample
{
    static void Main()
    {
        // The path we're going to try reading from
        string configFilePath = "appsettings.json";

        try
        {
            // This is the 'happy path' — what we want to happen
            string fileContents = File.ReadAllText(configFilePath);
            Console.WriteLine("Config loaded successfully:");
            Console.WriteLine(fileContents);
        }
        catch (FileNotFoundException notFoundEx)
        {
            // Fires ONLY when the specific file doesn't exist
            // notFoundEx.FileName gives us the exact path that was missing
            Console.WriteLine($"Config file missing: {notFoundEx.FileName}");
            Console.WriteLine("Loading default settings instead...");
        }
        catch (UnauthorizedAccessException accessEx)
        {
            // Fires when the file exists but we don't have permission to read it
            Console.WriteLine($"Permission denied reading config: {accessEx.Message}");
        }
        catch (IOException ioEx)
        {
            // Catches any other I/O problem (disk error, network drive gone, etc.)
            // This is broader than the two above, so it comes AFTER them
            Console.WriteLine($"Unexpected I/O error: {ioEx.Message}");
        }

        // This line runs regardless of whether an exception occurred
        Console.WriteLine("Application startup continues...");
    }
}

using System;
using System.Data.SqlClient;

class DatabaseQueryExample
{
    static void Main()
    {
        // In production this comes from config, not hardcoded
        string connectionString = "Server=localhost;Database=ShopDb;Trusted_Connection=True;";
        SqlConnection dbConnection = null;

        try
        {
            dbConnection = new SqlConnection(connectionString);
            dbConnection.Open(); // Could throw SqlException if server is unreachable

            Console.WriteLine("Connection opened. Running query...");

            // Simulate a query that might fail
            SqlCommand command = new SqlCommand("SELECT * FROM NonExistentTable", dbConnection);
            SqlDataReader reader = command.ExecuteReader(); // Throws SqlException here

            Console.WriteLine("Query complete.");
        }
        catch (SqlException sqlEx)
        {
            // sqlEx.Number gives the SQL Server error code — useful for logging
            Console.WriteLine($"Database error #{sqlEx.Number}: {sqlEx.Message}");
        }
        finally
        {
            // This block runs NO MATTER WHAT — success, failure, or return statement
            // Without this, a failed query would leave the connection open
            if (dbConnection != null && dbConnection.State == System.Data.ConnectionState.Open)
            {
                dbConnection.Close();
                Console.WriteLine("Database connection closed cleanly.");
            }
        }

        Console.WriteLine("Method finished.");
    }
}

using System;

// Custom exception that carries domain-specific diagnostic info
public class InvalidCouponException : Exception
{
    // The coupon code that caused the problem — type-safe, not buried in a message string
    public string AttemptedCouponCode { get; }
    public string CustomerId { get; }

    public InvalidCouponException(string couponCode, string customerId)
        : base($"Coupon '{couponCode}' is not valid for customer '{customerId}'")
    {
        AttemptedCouponCode = couponCode;
        CustomerId = customerId;
    }

    // Always provide this constructor — required for proper serialization across app domains
    public InvalidCouponException(string message, Exception innerException)
        : base(message, innerException) { }
}

class OrderProcessor
{
    static void ApplyDiscount(string customerId, string couponCode, decimal orderTotal)
    {
        // Simulate checking a database of valid coupons
        string[] validCoupons = { "SAVE10", "WELCOME20", "VIP50" };
        bool couponIsValid = Array.Exists(validCoupons, c => c == couponCode);

        if (!couponIsValid)
        {
            // Throw our custom exception with structured data the caller can use
            throw new InvalidCouponException(couponCode, customerId);
        }

        Console.WriteLine($"Discount applied! New total: {orderTotal * 0.9m:C}");
    }

    static void Main()
    {
        string customerId = "CUST-4821";
        string badCoupon = "FREESTUFF";

        try
        {
            ApplyDiscount(customerId, badCoupon, 150.00m);
        }
        catch (InvalidCouponException couponEx)
        {
            // We can access the structured properties — no string parsing needed
            Console.WriteLine($"[Order System] Coupon failed for customer {couponEx.CustomerId}");
            Console.WriteLine($"[Order System] Bad code attempted: '{couponEx.AttemptedCouponCode}'");
            Console.WriteLine("[Order System] Prompting user to re-enter coupon...");

            // Re-throw with 'throw' (not 'throw couponEx') to preserve the original stack trace
            // Uncomment the line below to see the difference in a real debugging session:
            // throw;
        }
        catch (Exception unexpectedEx)
        {
            // Wrapping an unexpected exception preserves the original as InnerException
            throw new Exception("Order processing failed unexpectedly", unexpectedEx);
        }
    }
}

using System;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;

class HttpRetryExample
{
    static readonly HttpClient httpClient = new HttpClient();

    static async Task FetchUserDataAsync(int userId)
    {
        string apiUrl = $"https://api.example.com/users/{userId}";
        int maxRetries = 3;

        for (int attempt = 1; attempt <= maxRetries; attempt++)
        {
            try
            {
                Console.WriteLine($"Attempt {attempt}: Calling {apiUrl}");
                HttpResponseMessage response = await httpClient.GetAsync(apiUrl);

                // Throws HttpRequestException with StatusCode property if not successful
                response.EnsureSuccessStatusCode();

                string userJson = await response.Content.ReadAsStringAsync();
                Console.WriteLine($"Success: {userJson}");
                return; // Got what we needed — exit the retry loop
            }
            catch (HttpRequestException rateLimitEx)
                when (rateLimitEx.StatusCode == HttpStatusCode.TooManyRequests)
            {
                // Exception filter: this catch ONLY activates for 429 responses
                // The 'when' condition is checked BEFORE the catch block runs
                // Other HttpRequestExceptions (404, 500) will NOT be caught here
                Console.WriteLine($"Rate limited. Waiting before retry {attempt}...");
                await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, attempt))); // Exponential backoff
            }
            catch (HttpRequestException nonRetryableEx)
                when (nonRetryableEx.StatusCode == HttpStatusCode.NotFound)
            {
                // 404 is NOT retryable — wrap it and throw immediately
                // Using 'throw new' here because we're adding context, but preserving inner
                throw new InvalidOperationException(
                    $"User {userId} does not exist in the remote system.",
                    nonRetryableEx);
            }
            // Note: HttpRequestExceptions for 500 errors are NOT caught here
            // They propagate up to the caller — which is correct, we can't fix server errors
        }

        Console.WriteLine("Max retries exhausted. Request failed.");
    }

    static async Task Main()
    {
        try
        {
            await FetchUserDataAsync(userId: 42);
        }
        catch (InvalidOperationException domainEx)
        {
            Console.WriteLine($"[App] Business logic error: {domainEx.Message}");
        }
        catch (Exception unexpectedEx)
        {
            // Top-level catch — log it fully and fail gracefully
            Console.WriteLine($"[App] Unhandled error: {unexpectedEx.GetType().Name}: {unexpectedEx.Message}");
        }
    }
}