When working with C#, managing exceptions and resources is critical for building robust applications. This article covers key concepts from expection handling to resource disposal, providing actionable guidance and code examples.

Understanding the Exception Handling Mechanism

C# offers a structured approach to error handling through try-catch-finally blocks. The try block contains code that might throw an exception. If an exception occurs, the appropriate catch block handles it. The finally block always executes, regardless of whether an exception was thrown, making it ideal for cleanup.

try
{
    int divisor = 0;
    int quotient = 100 / divisor;  // This line will cause DivideByZeroException
}
catch (DivideByZeroException ex)
{
    Console.WriteLine($"Arithmetic error: {ex.Message}");
}
finally
{
    Console.WriteLine("Cleanup executed.");
}

The throw statement allows you to manually raise an exception. Use it when a condition in your code indicates an unrecoverable error.

int age = -5;
if (age < 0)
{
    throw new ArgumentOutOfRangeException(nameof(age), "Age cannot be negative.");
}

Resource management is simplified with the using statement. It guarantees that an object implementing IDisposable is disposed of correctly when the block exits, even if an exception occurs.

using (FileStream fs = new FileStream("data.txt", FileMode.Open))
{
    byte[] buffer = new byte[fs.Length];
    fs.Read(buffer, 0, buffer.Length);
    string content = System.Text.Encoding.UTF8.GetString(buffer);
    Console.WriteLine(content);
}

Correct Exception Handling Practices

• Catch specific exception types instead of the generic Exception. This improves code clarity and ensures you handle only the errors you expect.
• Let exceptions propagate when you cannot handle them meaningfully. Use throw (not throw ex) to preserve the original stack trace.
• Avoid overusing catch blocks. Excessive try-catch makes code hard to maintain and can hide bugs. Consider alternatives like checking conditions with if statements or using the Try-pattern (e.g., int.TryParse).
• Implement custom exceptions by inheriting from Exception and providing constructors that pass meaningful messages.

public class InvalidInputException : Exception
{
    public InvalidInputException(string message) : base(message) { }
}

// Usage
if (!int.TryParse(userInput, out int value))
{
    throw new InvalidInputException("Provided input is not a valid integer.");
}

Managing Resources with IDisposable

If your class holds unmanaged resources (e.g., file handles, database connections), implement IDisposable. The Dispose method should free those resoruces. Always call Dispose (or use using) to avoid memory leaks.

public class DatabaseConnection : IDisposable
{
    private IntPtr _nativeHandle;

    public DatabaseConnection(string connectionString)
    {
        _nativeHandle = OpenConnection(connectionString);
    }

    public void Dispose()
    {
        CloseConnection(_nativeHandle);
        GC.SuppressFinalize(this);
    }

    // ... other methods
}

Common Interview Questions

How do you define a custom exception?

Inherit from Exception and add constructors as needed. Example:

public class DataProcessingException : Exception
{
    public DataProcessingException() { }
    public DataProcessingException(string message) : base(message) { }
    public DataProcessingException(string message, Exception inner) : base(message, inner) { }
}

What is the execution order of try-catch-finally when a return occurs in the try block?

The finally block executes before the return statement transfers control. So cleanup always happens.

static int TestMethod()
{
    try
    {
        return 42;
    }
    finally
    {
        Console.WriteLine("Finally runs before return.");
    }
}

How do you handle multiple exception types?

Use multiple catch blocks, ordered from most specific to most general. Example:

try
{
    // code that may throw various exceptions
}
catch (FileNotFoundException ex)
{
    Console.WriteLine($"File missing: {ex.FileName}");
}
catch (IOException ex)
{
    Console.WriteLine($"I/O error: {ex.Message}");
}
catch (Exception ex)
{
    Console.WriteLine($"Unhandled error: {ex.Message}");
    throw; // rethrow if not recoverable
}