C# Exceptions and IDisposable: try, catch, finally and using

try
{
    int result = int.Parse("abc");
    Console.WriteLine(result);
}
catch (FormatException ex)
{
    Console.WriteLine($"Bad number: {ex.Message}");
}
catch (Exception ex)    // the general handler goes last
{
    Console.WriteLine($"Unexpected: {ex.Message}");
}
finally                 // cleanup: runs whether or not an exception was thrown
{
    Console.WriteLine("always runs");
}

try { WithRethrow(); }
catch (Exception ex) { Console.WriteLine(ex.StackTrace!.Contains("Thrower")); }    // True

try { WithThrowEx(); }
catch (Exception ex) { Console.WriteLine(ex.StackTrace!.Contains("Thrower")); }    // False

static void Thrower() => throw new InvalidOperationException("boom");
static void WithRethrow() { try { Thrower(); } catch { throw; } }
static void WithThrowEx() { try { Thrower(); } catch (Exception ex) { throw ex; } }

try
{
    throw new InsufficientFundsException(30m);
}
catch (InsufficientFundsException ex)
{
    Console.WriteLine($"{ex.Message} (short by {ex.Shortfall})");   // Not enough money. (short by 30)
}

public class InsufficientFundsException : Exception
{
    public decimal Shortfall { get; }

    public InsufficientFundsException(decimal shortfall) : base("Not enough money.")
    {
        Shortfall = shortfall;
    }
}

using (var connection = new FakeConnection("A"))
{
    Console.WriteLine("working");
}                                          // Dispose() runs here, then the output continues

using var second = new FakeConnection("B");    // using declaration: disposed at the end of the enclosing scope
Console.WriteLine("done");

public sealed class FakeConnection : IDisposable
{
    private readonly string _name;
    public FakeConnection(string name) => _name = name;
    public void Dispose() => Console.WriteLine($"closed {_name}");
}

public class NativeResourceOwner : IDisposable
{
    private bool _disposed;

    public void Dispose()
    {
        Dispose(disposing: true);
        GC.SuppressFinalize(this);          // no need to run the finalizer now
    }

    protected virtual void Dispose(bool disposing)
    {
        if (_disposed) return;
        if (disposing)
        {
            // dispose managed objects here
        }
        // release unmanaged resources here
        _disposed = true;
    }

    ~NativeResourceOwner() => Dispose(disposing: false);   // safety net if Dispose was never called
}