C# handles errors with exceptions caught via try/catch/finally. Proper exception handling means catching specific exception types, cleaning up resources (often with using), creating meaningful custom exceptions, and not swallowing errors silently.
try
{
var data = RiskyOperation();
}
catch (FileNotFoundException ex) // catch SPECIFIC types (most specific first)
{
Console.WriteLine($"File missing: {ex.Message}");
}
catch (IOException ex)
{
Log(ex);
throw; // re-throw, PRESERVING the stack trace (not `throw ex`)
}
catch (Exception ex) // catch-all (last) — base of all exceptions
{
Log(ex);
}
finally
{
Cleanup(); // ALWAYS runs (success, exception, or return)
}
Catch specific exception types first, use Exception as a final catch-all, and finally for cleanup that must always run. Important: use throw; (not throw ex;) to re-throw — it preserves the original stack trace.
if (amount < 0)
throw new ArgumentException("Amount must be positive", nameof(amount));
// a custom exception for your domain
public class InsufficientFundsException : Exception
{
public InsufficientFundsException(string message) : base(message) { }
}
throw new InsufficientFundsException("Balance too low");
// `using` guarantees Dispose() is called (close files/connections) even on exception
using (var file = new StreamReader("data.txt"))
{
var content = file.ReadToEnd();
} // file.Dispose() called automatically here
using var conn = new SqlConnection(...); // C# 8 simplified form
The using statement ensures IDisposable resources (files, connections) are properly disposed — the preferred way to handle resource cleanup, more reliable than manual finally.
catch (Exception ex) when (ex.Message.Contains("timeout")) // exception filter (when)
{ ... }
✓ Catch SPECIFIC exceptions, not just Exception
✓ Use `using` for IDisposable resources (reliable cleanup)
✓ Don't swallow exceptions silently (empty catch) — log or re-throw
✓ Use `throw;` (not `throw ex;`) to preserve the stack trace
✓ Create meaningful custom exceptions; don't use exceptions for normal control flow
Proper exception handling is essential for building robust, reliable C# applications, so understanding it thoroughly is important.
The try/catch/finally structure, catching specific exception types (for targeted handling) with Exception as a final catch-all, and finally for guaranteed cleanup are fundamental.
Several C#-specific best practices are particularly important: using throw; rather than throw ex; when re-throwing (a subtle but crucial detail — throw ex; resets the stack trace, losing valuable debugging information), using the using statement for IDisposable resources (the preferred, reliable way to ensure files, connections, and other resources are properly cleaned up even when exceptions occur — more robust than manual finally blocks, and central to C#'s resource-management model), and not swallowing exceptions silently.
Understanding exception handling — the structure, specific catches, custom exceptions, the stack-trace-preserving re-throw, and especially using for resource cleanup — is important for writing reliable C# that handles errors gracefully and manages resources correctly.
Since unhandled exceptions and resource leaks cause real reliability problems, and since C# has specific idioms (the using pattern, throw; preservation) that distinguish robust code from fragile code, mastering exception handling is important, frequently-applied knowledge for professional C# development.