Exceptions and Error Handling

public static class TryCatchFinally
{
    public static int ReadCount(string? text)
    {
        try
        {
            return int.Parse(text!);
        }
        catch (ArgumentNullException)
        {
            // Most specific first -- the first matching clause wins.
            return 0;
        }
        catch (FormatException ex)
        {
            Console.WriteLine($"not a number: {ex.Message}");
            return -1;
        }
        catch (OverflowException)
        {
            return int.MaxValue;
        }
        finally
        {
            // Runs whether or not an exception was thrown, and on an early return.
            Console.WriteLine("parse attempt finished");
        }
    }
}

public sealed class HttpLikeException : Exception
{
    public HttpLikeException(int statusCode, string message) : base(message) => StatusCode = statusCode;

    public int StatusCode { get; }
}

public static class Filters
{
    public static string Fetch(Func<string> operation)
    {
        try
        {
            return operation();
        }
        catch (HttpLikeException ex) when (ex.StatusCode == 404)
        {
            return "not found";
        }
        catch (HttpLikeException ex) when (ex.StatusCode >= 500)
        {
            return "server error -- retry later";
        }
        // Anything else propagates: no catch clause claims it.
    }

    // A filter that never matches is the idiomatic "log without handling" trick:
    // the log runs while the stack is still intact, then the exception continues.
    public static void LoggingWithoutCatching(Action operation)
    {
        try
        {
            operation();
        }
        catch (Exception ex) when (Log(ex))
        {
            throw new UnreachableException();     // never reached: Log always returns false
        }
    }

    private static bool Log(Exception ex)
    {
        Console.WriteLine($"observed: {ex.GetType().Name}");
        return false;
    }
}

public static class Rethrowing
{
    public static void Correct(Action operation)
    {
        try
        {
            operation();
        }
        catch (InvalidOperationException)
        {
            Console.WriteLine("noting and rethrowing");
            throw;                       // preserves the ORIGINAL stack trace
        }
    }

    public static void Wrong(Action operation)
    {
        try
        {
            operation();
        }
        catch (InvalidOperationException ex)
        {
            throw ex;                    // RESETS the stack trace to this line -- almost always a bug
        }
    }

    public static void WrappingWithContext(Action operation, string resource)
    {
        try
        {
            operation();
        }
        catch (IOException ex)
        {
            // Wrapping is fine -- as long as the original goes in as the inner exception.
            throw new InvalidOperationException($"could not process '{resource}'", ex);
        }
    }
}

using System.Runtime.ExceptionServices;

public static class Dispatching
{
    public static void Run()
    {
        ExceptionDispatchInfo? captured = null;

        try
        {
            throw new InvalidOperationException("original failure");
        }
        catch (Exception ex)
        {
            captured = ExceptionDispatchInfo.Capture(ex);
        }

        // …later, possibly on another thread, with the original trace intact.
        try
        {
            captured?.Throw();
        }
        catch (InvalidOperationException ex)
        {
            Console.WriteLine(ex.Message);      // original failure
        }

        // ExceptionDispatchInfo.SetCurrentStackTrace attaches a trace to an
        // exception that has not been thrown yet.
        var prepared = ExceptionDispatchInfo.SetCurrentStackTrace(new TimeoutException("prepared"));
        Console.WriteLine(prepared.StackTrace is not null);
    }
}

public sealed class Account
{
    private readonly string _id;

    public Account(string? id) =>
        _id = id ?? throw new ArgumentNullException(nameof(id));

    public string Id => _id;

    public decimal Balance { get; private set; }

    public void Withdraw(decimal amount) => Balance = amount switch
    {
        <= 0m => throw new ArgumentOutOfRangeException(nameof(amount), amount, "must be positive"),
        _ when amount > Balance => throw new InvalidOperationException("insufficient funds"),
        _ => Balance - amount,
    };

    public override string ToString() => $"{_id}: {Balance:C}";
}

// Derive from Exception (not ApplicationException -- that guidance was withdrawn long ago).
public class OrderProcessingException : Exception
{
    // The three conventional constructors, so the type behaves like every BCL exception.
    public OrderProcessingException()
    {
    }

    public OrderProcessingException(string message) : base(message)
    {
    }

    public OrderProcessingException(string message, Exception innerException)
        : base(message, innerException)
    {
    }

    // Extra state gets its own constructor and a read-only property.
    public OrderProcessingException(string message, string orderId) : base(message) => OrderId = orderId;

    public string? OrderId { get; }
}

public sealed class Report
{
    private readonly string _title;
    private readonly int _pageCount;

    public Report(string title, int pageCount, string[] sections)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(title);
        ArgumentOutOfRangeException.ThrowIfNegativeOrZero(pageCount);
        ArgumentOutOfRangeException.ThrowIfGreaterThan(pageCount, 10_000);
        ArgumentNullException.ThrowIfNull(sections);

        _title = title;
        _pageCount = pageCount;
    }

    public override string ToString() => $"{_title} ({_pageCount} pages)";
}

public static class GuardHelpers
{
    public static void Demonstrate()
    {
        try
        {
            _ = new Report("  ", 1, []);
        }
        catch (ArgumentException ex)
        {
            // The parameter name is captured by [CallerArgumentExpression] -- no nameof needed.
            Console.WriteLine(ex.ParamName);        // title
        }

        // The full family, all following the same ThrowIf… shape:
        //   ArgumentNullException.ThrowIfNull
        //   ArgumentException.ThrowIfNullOrEmpty / ThrowIfNullOrWhiteSpace
        //   ArgumentOutOfRangeException.ThrowIfNegative / ThrowIfZero / ThrowIfEqual /
        //     ThrowIfLessThan / ThrowIfGreaterThanOrEqual …
        //   ObjectDisposedException.ThrowIf
    }
}

public static class CleanupWithUsing
{
    public static async Task<string> ReadAsync(string path, CancellationToken token)
    {
        // A `using` declaration disposes at the end of the enclosing scope.
        using var reader = new StringReader("contents");
        return await reader.ReadToEndAsync(token);
    }

    public static void Nested()
    {
        // Equivalent to try/finally { a.Dispose(); } nested around b.
        using var a = new MemoryStream();
        using var b = new MemoryStream();
        b.WriteByte(1);
        Console.WriteLine(a.Length + b.Length);
    }
}

public static class AggregateFailures
{
    public static async Task Run()
    {
        Task failing1 = Task.Run(() => throw new InvalidOperationException("first"));
        Task failing2 = Task.Run(() => throw new FormatException("second"));
        Task all = Task.WhenAll(failing1, failing2);

        try
        {
            await all;                     // `await` rethrows only the FIRST exception…
        }
        catch (Exception ex)
        {
            Console.WriteLine($"await surfaced: {ex.GetType().Name}");    // InvalidOperationException

            // …but the task itself still holds every one of them.
            foreach (Exception inner in all.Exception!.InnerExceptions)
            {
                Console.WriteLine($"  inner: {inner.GetType().Name}: {inner.Message}");
            }
        }

        // Flatten collapses nested AggregateExceptions into one level.
        try
        {
            Task.WhenAll(failing1, failing2).Wait();    // Wait() throws the AggregateException itself
        }
        catch (AggregateException ex)
        {
            Console.WriteLine(ex.Flatten().InnerExceptions.Count);        // 2
        }
    }
}

public static class Alternatives
{
    public static void TryPattern(string input)
    {
        // Try… returns false instead of throwing -- right when invalid input is routine.
        if (int.TryParse(input, out int value))
        {
            Console.WriteLine(value);
        }
        else
        {
            Console.WriteLine("not a number");
        }
    }

    // A result object makes both outcomes part of the signature.
    public readonly record struct Result<T>(bool Succeeded, T? Value, string? Error)
    {
        public static Result<T> Ok(T value) => new(true, value, null);
        public static Result<T> Fail(string error) => new(false, default, error);
    }

    public static Result<int> Divide(int numerator, int denominator) =>
        denominator == 0
            ? Result<int>.Fail("division by zero")
            : Result<int>.Ok(numerator / denominator);

    public static void Run()
    {
        TryPattern("x");

        Result<int> result = Divide(10, 0);
        Console.WriteLine(result.Succeeded ? result.Value.ToString() : result.Error);

        // Pattern matching reads well over result types.
        Console.WriteLine(Divide(10, 2) switch
        {
            { Succeeded: true, Value: var v } => $"= {v}",
            { Error: var e } => $"failed: {e}",
        });
    }
}

public static class LastResort
{
    public static void Install()
    {
        AppDomain.CurrentDomain.UnhandledException += (sender, e) =>
        {
            // Last chance to log. The process is going down regardless.
            Console.Error.WriteLine($"fatal: {(e.ExceptionObject as Exception)?.Message}");
        };

        // A task whose exception is never observed used to crash the process; today it
        // raises this event instead. Logging here catches forgotten awaits.
        TaskScheduler.UnobservedTaskException += (sender, e) =>
        {
            Console.Error.WriteLine($"unobserved: {e.Exception.Message}");
            e.SetObserved();
        };
    }
}