The try-catch
block in C# is used to capture and handle exceptions (errors) that may occur during the execution of a program.
An exception is an unexpected event that interrupts the normal flow of the program. The goal of the try-catch
block is to allow the program to respond to these events in a controlled manner, rather than terminating abruptly.
Basic Structure
The basic structure of the try-catch
block is as follows:
try
{
// Code that may throw an exception
}
catch (Exception exceptionType)
{
// Code to handle the exception
}
In this structure,
- The
try
block contains the code that you want to monitor for possible exceptions. - The
catch
block contains the code that will execute if an exception occurs.
Basic Example
Consider an example where we try to divide two numbers and handle a possible division by zero:
try
{
int divisor = 0;
int result = 10 / divisor;
}
catch (DivideByZeroException ex)
{
Console.WriteLine("Error: Division by zero is not allowed.");
Console.WriteLine($"Details: {ex.Message}");
}
In this example, the try
block attempts to divide 10 by 0, which causes a DivideByZeroException
. The catch
block captures this exception and provides an informative error message.
Capturing Multiple Exceptions
You can have multiple catch
blocks to handle different types of exceptions specifically:
try
{
// Code that may throw exceptions
}
catch (DivideByZeroException ex)
{
Console.WriteLine("Error: Division by zero.");
}
catch (NullReferenceException ex)
{
Console.WriteLine("Error: Null reference.");
}
catch (Exception ex)
{
Console.WriteLine("Error: A general error occurred.");
}
In this example, DivideByZeroException
, NullReferenceException
, and a generic Exception
are handled, capturing any other type of exception not specifically addressed.
Using the finally
Block
The finally
block can be used to execute code that must run regardless of whether an exception occurred or not. It is useful for releasing resources, closing files, or performing other cleanup tasks.
try
{
// Code that may throw an exception
}
catch (Exception ex)
{
Console.WriteLine($"Error: {ex.Message}");
}
finally
{
Console.WriteLine("This block always executes.");
}
In this example, the finally
block will always execute, whether an exception occurred or not.
Practical Examples
Exception Handling in I/O Operations
In this example, a try-catch
block is used to handle exceptions that may occur during the reading of a file. The catch
blocks handle two types of exceptions: FileNotFoundException
if the file does not exist, and IOException
for other input/output-related issues.
try
{
// We open the file 'file.txt' for reading using StreamReader.
using (StreamReader reader = new StreamReader("file.txt"))
{
// We read the entire content of the file.
string content = reader.ReadToEnd();
// We display the content in the console.
Console.WriteLine(content);
} // The 'using' block ensures that the StreamReader is closed and released properly.
}
catch (FileNotFoundException ex)
{
// Captures and handles the exception if the file is not found.
Console.WriteLine("Error: The file was not found.");
}
catch (IOException ex)
{
// Captures and handles other I/O errors, such as reading issues.
Console.WriteLine("I/O Error: Problem reading the file.");
}