How to catch multiple exceptions in C#

string[] inputs = ["42", "abc", "99999999999", "7"];

foreach (var text in inputs)
{
    try
    {
        int n = int.Parse(text);
        Console.WriteLine($"{text} -> {n}");
    }
    // One handler for two exception types (C# 6 filter, C# 9 'or' pattern)
    catch (Exception e) when (e is FormatException or OverflowException)
    {
        Console.WriteLine($"{text} -> {e.GetType().Name}: {e.Message}");
    }
}

// Anything the filter doesn't match keeps propagating
try
{
    try
    {
        int.Parse(null!);
    }
    catch (Exception e) when (e is FormatException or OverflowException)
    {
        Console.WriteLine("not reached");
    }
}
catch (ArgumentNullException e)
{
    Console.WriteLine($"outer handler: {e.GetType().Name}");
}

string[] inputs = ["abc", "99999999999", "12"];

foreach (var text in inputs)
{
    try
    {
        int n = int.Parse(text);
        Console.WriteLine($"{text} -> {100 / (n - 12)}");
    }
    // Separate blocks: the first matching one wins, top to bottom
    catch (FormatException e)
    {
        Report(text, e);
    }
    catch (OverflowException e)
    {
        Report(text, e);
    }
    // ArithmeticException is the base of OverflowException and
    // DivideByZeroException, so it must come after OverflowException
    catch (ArithmeticException e)
    {
        Console.WriteLine($"{text} -> other arithmetic error: {e.GetType().Name}");
    }
}

// Before C# 6: catch the base type, test it, and rethrow the rest
try
{
    int.Parse("1.5");
}
catch (Exception e)
{
    if (!(e is FormatException || e is OverflowException))
    {
        throw;
    }
    Console.WriteLine($"legacy pattern caught {e.GetType().Name}");
}

static void Report(string text, Exception e) =>
    Console.WriteLine($"{text} -> {e.GetType().Name}");

// Filter on data, not just the type: retry only the status codes worth retrying
foreach (int status in new[] { 503, 429, 404 })
{
    try
    {
        try
        {
            throw new ApiException(status);
        }
        catch (ApiException e) when (e.StatusCode is 429 or 503)
        {
            Console.WriteLine($"{e.StatusCode}: retrying later");
        }
    }
    catch (ApiException e)
    {
        Console.WriteLine($"{e.StatusCode}: not retryable, passed up to the caller");
    }
}

// A filter that returns false logs the exception without catching it.
// It runs before the stack unwinds, so it sees the exception first.
try
{
    try
    {
        Save();
    }
    catch (Exception e) when (LogAndContinue(e))
    {
        Console.WriteLine("never runs");
    }
}
catch (IOException e)
{
    Console.WriteLine($"handled further up: {e.Message}");
}

static void Save()
{
    try
    {
        throw new IOException("disk full");
    }
    finally
    {
        Console.WriteLine("Save's finally block");
    }
}

static bool LogAndContinue(Exception e)
{
    Console.WriteLine($"log: {e.GetType().Name}: {e.Message}");
    return false;
}

class ApiException(int statusCode) : Exception($"HTTP {statusCode}")
{
    public int StatusCode { get; } = statusCode;
}

try
{
    Orders.LoadWithThrow();
}
catch (FormatException e)
{
    Console.WriteLine("throw; keeps the original stack trace:");
    Console.WriteLine(e.StackTrace);
}

try
{
    Orders.LoadWithThrowEx();
}
catch (FormatException e)
{
    Console.WriteLine("throw ex; restarts it at the rethrow:");
    Console.WriteLine(e.StackTrace);
}

static class Orders
{
    static int ParseQuantity(string text) => int.Parse(text);

    public static void LoadWithThrow()
    {
        try
        {
            ParseQuantity("ten");
        }
        catch (FormatException)
        {
            Console.WriteLine("log: bad quantity");
            throw;      // rethrows the same exception, trace intact
        }
    }

    public static void LoadWithThrowEx()
    {
        try
        {
            ParseQuantity("ten");
        }
        catch (FormatException ex)
        {
            Console.WriteLine("log: bad quantity");
            throw ex;   // same exception object, but the trace now starts here
        }
    }
}

using System.Runtime.ExceptionServices;

string[] lines = ["3", "5", "ten", "2"];

// 1. Wrap: add context the low-level exception doesn't have, keep it as InnerException
try
{
    Console.WriteLine(Importer.Total(lines));
}
catch (InvalidDataException e)
{
    Console.WriteLine(e.Message);
    Console.WriteLine($"  caused by {e.InnerException!.GetType().Name}: {e.InnerException.Message}");
}

// 2. Rethrow later: capture now, throw after the loop with the original trace
ExceptionDispatchInfo? firstError = null;
int total = 0;
foreach (var line in lines)
{
    try
    {
        total += Importer.ParseQuantity(line);
    }
    catch (FormatException e)
    {
        firstError ??= ExceptionDispatchInfo.Capture(e);
    }
}
Console.WriteLine($"parsed total: {total}");

try
{
    firstError?.Throw();
}
catch (FormatException e)
{
    Console.WriteLine(e.StackTrace);
}

static class Importer
{
    public static int ParseQuantity(string text) => int.Parse(text);

    public static int Total(string[] lines)
    {
        int total = 0;
        for (int i = 0; i < lines.Length; i++)
        {
            try
            {
                total += ParseQuantity(lines[i]);
            }
            catch (FormatException e)
            {
                throw new InvalidDataException($"Line {i + 1}: '{lines[i]}' is not a quantity", e);
            }
        }
        return total;
    }
}