How to use multiple catch clause in C#
In this article, you will learn how to use multiple catch clause in C#. But before going to its implementation, you must know about catch block with its syntax.
Handling the exception that was raised in the try block is the primary goal of the catch block. This block will begin to run only when the program raises an exception. The try block in C# allows you to use multiple catch blocks. Different types of exceptions are typically handled by multiple catch blocks, which means that each catch block handles a different exception type. There will be a compile-time error if you use multiple catch blocks for the same kind of an exception because C# does not permit this behavior. Usually, the try block comes before the catch block. The catch blocks are typically checked in the program's chronological order of occurrence. The first catch block gets to work, and the other catch blocks are ignored if the exception type matches the first catch block. In the event that the catch block at the beginning is not appropriate for the type of exception, the compiler will look for the next catch block.
Syntax:
It has the following syntax:
try
{
// Code that may throw exceptions
}
catch (ExceptionType1 ex)
{
// Handle ExceptionType1
// ex contains information about the exception
}
catch (ExceptionType2 ex)
{
// Handle ExceptionType2
// ex contains information about the exception
}
catch (Exception ex)
{
// Handle any other exceptions that are not caught by previous catch blocks
// ex contains information about the exception
}
finally
{
// Optional: Code that will always execute, regardless of whether an exception occurred or not
}
Example:
Let us take an example to illustrate how to use multiple catch clause in C#.
using System;
class Program
{
static void Main(string[] args)
{
try
{
// Code that may throw exceptions
int[] numbers = { 1, 2, 3 };
Console.WriteLine("Dividing by zero...");
int result = numbers[0] / (numbers[1] - numbers[1]);
Console.WriteLine("Result: " + result);
}
catch (DivideByZeroException ex)
{
// Handle DivideByZeroException
Console.WriteLine("Error: Attempted to divide by zero.");
}
catch (IndexOutOfRangeException ex)
{
// Handle IndexOutOfRangeException
Console.WriteLine("Error: Index out of range.");
}
catch (Exception ex)
{
// Handle any other exceptions that are not caught by previous catch blocks
Console.WriteLine("An error occurred: " + ex.Message);
}
finally
{
// Optional: Code that will always execute, regardless of whether an exception occurred or not
Console.WriteLine("Finally block executed.");
}
}
}
Output:
Dividing by zero...
ERROR!
Error: Attempted to divide by zero.
Finally block executed.
Explanation:
- The code in our try block has the potential to throw exceptions. We are attempting to access an index that is outside of an array's range by dividing by zero in this instance.
- DivideByZeroException and IndexOutOfRangeException are two of the catch blocks we have to handle various exception types. For the corresponding exception type, each catch block offers particular handling.
- The catch (Exception ex) block is a catch-all block that deals with any additional exceptions that the preceding catch blocks failed to catch. Together with the exception's message, a generic error message is printed.
- Whether or not an exception occurred, the finally block prints a message indicating that it has been executed. It is an optional block.
Example 2:
Let us take another example to illustrate how to use multiple catch clause in C#.
using System;
class Program
{
static void Main(string[] args)
{
try
{
// Code that may throw exceptions
WithdrawMoney(200); // Try withdrawing more money than available
}
catch (InsufficientFundsException ex)
{
// Handle InsufficientFundsException
Console.WriteLine("Error: " + ex.Message);
}
catch (InvalidWithdrawalAmountException ex)
{
// Handle InvalidWithdrawalAmountException
Console.WriteLine("Error: " + ex.Message);
}
catch (Exception ex)
{
// Handle any other exceptions that are not caught by previous catch blocks
Console.WriteLine("An error occurred: " + ex.Message);
}
finally
{
// Optional: Code that will always execute, regardless of whether an exception occurred or not
Console.WriteLine("Finally block executed.");
}
}
static void WithdrawMoney(double amount)
{
double balance = 100;
if (amount > balance)
{
throw new InsufficientFundsException("Insufficient funds to withdraw.");
}
else if (amount <= 0)
{
throw new InvalidWithdrawalAmountException("Invalid withdrawal amount.");
}
else
{
balance -= amount;
Console.WriteLine($"Withdrawal successful. Remaining balance: {balance}");
}
}
}
// Custom exception classes
class InsufficientFundsException : Exception
{
public InsufficientFundsException(string message) : base(message)
{
}
}
class InvalidWithdrawalAmountException : Exception
{
public InvalidWithdrawalAmountException(string message) : base(message)
{
}
}
Output:
ERROR!
Error: Insufficient funds to withdraw.
Finally block executed.
Conclusion:
In conclusion, C# offers a strong mechanism for gracefully handling a variety of exception types within a program with multiple catch clauses. Developers can modify their error-handling logic to tackle various exceptional scenarios with ease by categorizing catch blocks according to distinct exception types. By ensuring that exceptions are appropriately caught and handled, this approach improves the overall reliability, maintainability, and readability of code. The final block also permits the execution of cleanup code even without an exception to help with resource management and guarantee consistent program behaviour. Developers can thoughtfully use exception types and try-catch constructs to create resilient applications that handle errors gracefully and improve user experience.