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

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

Exception handling and resource cleanup appear in nearly every C# interview. The key ideas are small, but the details matter.

try, catch and finally

Put specific handlers first and the general handler last. The first matching wins.
runs whether or not an exception happened. Use it for cleanup.
An exception filter () handles an exception only when a condition holds, without unwinding the stack.
Catch only what you can handle. Do not use exceptions for normal control flow: prefer to catching .

throw versus throw ex

Both re-throw an exception you caught, but they treat the stack trace differently:

re-throws the same exception and keeps the original stack trace, so you can still see where the failure began.
resets the stack trace to the line of the , hiding the real origin. The compiler's code analysis even warns about it.

If you want to add context, wrap the original: .

Do not swallow exceptions

An empty hides real failures and makes bugs very hard to find. At minimum, log the exception. If you cannot handle it, let it propagate.

Custom exceptions

Derive from (not ), end the name with , and add properties for the data a caller needs.

IDisposable and the using statement

The garbage collector frees memory, but it does not promptly release unmanaged resources: file handles, database connections, sockets, native memory. A type that owns such resources implements , and you call when you are done. The statement does that for you, even if an exception occurs:

The output is , , , . A statement is compiled into a / that calls . For asynchronous cleanup, use with .

Implementing IDisposable

For a class that only owns other disposable objects, simply disposes them. The full pattern is needed only when the class directly owns unmanaged resources:

Most application code never needs a finalizer. Use for native handles instead, and keep it simple.

Practise

Write a method that parses a number with instead of /, and compare the two.
Prove for yourself that loses the stack trace by printing both ways.
Take the Exceptions, Memory and Async quiz.

Exception

catch

finally

catch (IOException ex) when (ex.HResult == 5)

int.TryParse

FormatException

throw;

throw ex;

throw ex

throw new DataException("Could not load orders", ex);

catch { }

Exception

ApplicationException

Exception

IDisposable

Dispose()

using

working

closed A

done

closed B

using

try

finally

Dispose()

IAsyncDisposable

await using

Dispose()

SafeHandle

int.TryParse

try

catch

throw ex;

ex.StackTrace

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
}