C# Exceptions and Resource Cleanup

A file operation may fail because the file disappeared, permission was denied, or storage became unavailable. Returning an empty string would confuse a failure with a successfully read empty file. An exception separates the failed control path and carries diagnostic information.

Expected alternatives do not automatically need exceptions. A search that finds no match can return null, and invalid user text can make TryParse return false. Reserve exceptions for operations that cannot fulfill their contract normally.

A try block contains work that may fail. catch selects an exception type and handles it. Put more specific catches before broader ones. Catching Exception at every method, printing ‘something went wrong,’ and continuing can hide corruption and erase the evidence needed to fix the cause.

At a user-facing boundary, a catch can translate a technical failure into an actionable message and log the full exception for diagnosis. Deeper code often should let an unexpected exception propagate. If you rethrow the same exception, use throw; rather than throw ex; so the original stack information is preserved.

A method can use throw when its contract cannot be fulfilled. Prefer standard exception types such as ArgumentNullException, ArgumentOutOfRangeException, and InvalidOperationException when they accurately describe the problem. Include the parameter name and a message that states the requirement.

Custom exception types are useful when callers need to distinguish a domain failure programmatically and standard types do not express it. Do not create a new exception class merely to restate a message.

static decimal Percentage(decimal part, decimal whole)
{
  if (whole == 0m)
      throw new ArgumentOutOfRangeException(
          "whole",
          "Whole must be greater than zero.");

  return part / whole * 100m;
}

Files, network streams, and some other objects own resources outside managed memory. They implement IDisposable so code can release those resources promptly. A finally block runs whether the try succeeds or fails, but a using statement is the usual clearer tool for a local disposable lifetime.

using translates into cleanup logic that calls Dispose even when an exception interrupts the body. It does not catch the exception; responsibility for cleanup and responsibility for recovery remain separate.

using (StreamReader reader = File.OpenText("notes.txt"))
{
  string firstLine = reader.ReadLine();
  Console.WriteLine(firstLine);
} // reader is disposed here, including on an exception