C# Error Handling and Custom Exceptions

Error handling in the C# programming language involves handling errors that may occur during runtime and responding appropriately. Error handling helps make applications more reliable and robust.

Types of Errors

In C#, there are two main types of errors: compile-time errors and runtime errors. Compile-time errors occur during code writing, and if not resolved, the compilation process fails. Runtime errors, on the other hand, occur when the application is executed.

Error Handling Methods

The fundamental methods used for error handling in C# programs are:

Try-Catch Blocks

We use the try block to specify code that might cause a potential error, and if an error occurs, the catch block is executed. This prevents the program from crashing and allows us to handle the error.

try
{
    // Code that might cause an error
}
catch (Exception ex)
{
    // Actions to be taken in case of an error
    Console.WriteLine("Error Occurred: " + ex.Message);
}
finally
{
    // Code that will run in any case
}

Throw Statement

The throw statement allows us to throw an exception under a specific condition. This is used to identify special conditions and respond appropriately.

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

Custom Exception Classes

In C#, we can create our own custom exception classes. This allows us to tailor exceptions to better fit the needs of our application and define errors more specifically.

public class NegativeAgeException : Exception
{
    public NegativeAgeException() : base("Age cannot be negative.") { }
}

The above example defines a custom exception class that will be thrown if a negative age value is detected.

Examples

1. Using Try-Catch Blocks

try
{
    int numerator = 10;
    int denominator = 0;
    int result = numerator / denominator; // Error will occur
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("Error: " + ex.Message);
}

2. Using Custom Exception

int age = -5;
try
{
    if (age < 0)
    {
        throw new NegativeAgeException();
    }
}
catch (NegativeAgeException ex)
{
    Console.WriteLine("Error: " + ex.Message);
}

Error handling in C# is essential for making programs more reliable and robust. By using try-catch blocks and custom exception classes, you can handle errors effectively and make your programs more resilient.