C# - Handling Exception

Exceptions in C#

When executing C# code, different errors can occur: coding errors made by the programmer, errors due to wrong input, or other unforeseeable things.

When an error occurs, C# will normally stop and generate an error message. The technical term for this is: C# will throw an exception (throw an error).

There are two types of exceptions 

a. System generated Exceptions

b. Custom Exception

Common System Exceptions

Here are some common system exceptions:

1. SystemException: Base class for exceptions that occur during the execution of a program.
2. ArgumentException: Thrown when a method receives an argument that is not valid.
3. ArgumentNullException: Thrown when a null reference is passed to a method that does not accept it as a valid argument.
4. ArgumentOutOfRangeException: Thrown when the value of an argument is outside the allowable range.
5. InvalidOperationException: Thrown when a method call is invalid for the object's current state.
6. NullReferenceException: Thrown when there is an attempt to dereference a null object reference.
7. IndexOutOfRangeException: Thrown when an array index is out of bounds.
8. DivideByZeroException: Thrown when an attempt is made to divide an integer value by zero.
9. FileNotFoundException: Thrown when an attempt to access a file that does not exist on disk fails.
10. NotImplementedException: Thrown when a requested method or operation is not implemented.

Key Concepts of Exception Handling

• Exception: An object that encapsulates an error condition and relevant information about the error.
• Try Block: Contains code that might throw an exception.
• Catch Block: Contains code to handle the exception.
• Finally Block: Contains code that is always executed, regardless of whether an exception was thrown or caught.
• Throw Statement: Used to explicitly throw an exception.

Syntax

try
{
    // Code that might throw an exception
}
catch (ExceptionType1 ex)
{
    // Code to handle ExceptionType1
}
catch (ExceptionType2 ex)
{
    // Code to handle ExceptionType2
}
finally
{
    // Code that always executes
}

Examples

Example 1: Handling a Specific Exception

using System;

public class Example
{
    public static void Main()
    {
        try
        {
            int[] numbers = { 1, 2, 3 };
            Console.WriteLine(numbers[5]);
        }
        catch (IndexOutOfRangeException ex)
        {
            Console.WriteLine("Index was outside the bounds of the array.");
            Console.WriteLine($"Exception Message: {ex.Message}");
        }
        finally
        {
            Console.WriteLine("Execution of the try-catch block is complete.");
        }
    }
}

Example 2: Catching Multiple Exceptions

using System;
using System.IO;

public class Example
{
    public static void Main()
    {
        try
        {
            int result = 10 / int.Parse("0"); // Will cause DivideByZeroException
            string content = File.ReadAllText("nonexistentfile.txt"); // Will cause FileNotFoundException
        }
        catch (DivideByZeroException ex)
        {
            Console.WriteLine("Cannot divide by zero.");
            Console.WriteLine($"Exception Message: {ex.Message}");
        }
        catch (FileNotFoundException ex)
        {
            Console.WriteLine("File not found.");
            Console.WriteLine($"Exception Message: {ex.Message}");
        }
        catch (Exception ex)
        {
            // General catch block for any other exceptions
            Console.WriteLine("An error occurred.");
            Console.WriteLine($"Exception Message: {ex.Message}");
        }
        finally
        {
            Console.WriteLine("Execution of the try-catch block is complete.");
        }
    }
}

Example 3: Throwing Exceptions

You can explicitly throw exceptions using the throw keyword.

using System;

public class Example
{
    public static void Main()
    {
        try
        {
            ValidateNumber(-1);
        }
        catch (ArgumentException ex)
        {
            Console.WriteLine($"Exception: {ex.Message}");
        }
    }

    static void ValidateNumber(int number)
    {
        if (number < 0)
        {
            throw new ArgumentException("Number cannot be negative.");
        }
    }
}

Custom Exceptions

You can create your own custom exception classes by inheriting from the Exception class.

using System;

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

public class Example
{
    public static void Main()
    {
        try
        {
            throw new CustomException("This is a custom exception.");
        }
        catch (CustomException ex)
        {
            Console.WriteLine($"Caught a custom exception: {ex.Message}");
        }
    }
}

Best Practices

Catch Specific Exceptions: Always catch specific exceptions rather than using a general catch block. This helps in understanding the exact issue and handling it accordingly.

Use Finally for Cleanup: Use the finally block to release resources or perform cleanup activities.

Avoid Silent Catch Blocks: Do not catch exceptions without handling them. At least log the exception details.

Custom Exceptions for Domain-Specific Errors: Use custom exceptions to represent domain-specific errors, which makes the code more readable and maintainable.