Exceptions in C# - ItTechGenie

What are Exceptions in C#?

An Exception in C# is an error that occurs during program execution, disrupting the normal flow of the application. C# provides a structured way to handle exceptions using try, catch, finally, and throw statements.

Key Features of Exception Handling

Prevents abrupt program termination by handling runtime errors.
Uses try and catch blocks to catch exceptions.
The finally block executes cleanup code regardless of an exception.
Custom exceptions can be created using the Exception class.

Example: Basic Exception Handling

The following example demonstrates how to handle an exception using try and catch.

Example: Handling Division by Zero Exception

using System;

class Program
{
    static void Main()
    {
        try
        {
            int num1 = 10, num2 = 0;
            int result = num1 / num2; // This will cause a divide by zero exception
            Console.WriteLine($"Result: {result}");
        }
        catch (DivideByZeroException ex)
        {
            Console.WriteLine($"Exception Caught: {ex.Message}");
        }
    }
}

// Output:
// Exception Caught: Attempted to divide by zero.

The try block contains the code that might throw an exception, and the catch block handles it gracefully.

Common Exception Types in C#

C# provides several built-in exceptions for handling different types of runtime errors.

Exception Type	Description	Example Scenario
`DivideByZeroException`	Thrown when dividing by zero.	`int x = 5 / 0;`
`NullReferenceException`	Thrown when accessing a member of a null object.	`string str = null; str.Length;`
`IndexOutOfRangeException`	Thrown when accessing an array with an invalid index.	`int[] arr = new int[5]; arr[10] = 100;`
`InvalidOperationException`	Thrown when an operation is invalid in the current state.	`var obj = new List().First();`
`FormatException`	Thrown when data is in an incorrect format.	`int.Parse("abc");`

Handling Multiple Exceptions

C# allows multiple catch blocks to handle different types of exceptions.

Example: Handling Multiple Exception Types

using System;

class Program
{
    static void Main()
    {
        try
        {
            string input = "abc";
            int num = int.Parse(input); // This will throw FormatException
        }
        catch (FormatException ex)
        {
            Console.WriteLine($"Format Error: {ex.Message}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"General Error: {ex.Message}");
        }
    }
}

// Output:
// Format Error: Input string was not in a correct format.

The program first catches a FormatException. If another type of exception occurs, the general Exception block will handle it.

Using the Finally Block

The finally block executes regardless of whether an exception occurs, making it ideal for cleanup tasks.

Example: Using Finally Block

using System;

class Program
{
    static void Main()
    {
        try
        {
            int[] numbers = { 1, 2, 3 };
            Console.WriteLine(numbers[5]); // Will throw IndexOutOfRangeException
        }
        catch (IndexOutOfRangeException ex)
        {
            Console.WriteLine($"Exception: {ex.Message}");
        }
        finally
        {
            Console.WriteLine("This block always executes.");
        }
    }
}

// Output:
// Exception: Index was outside the bounds of the array.
// This block always executes.

The finally block ensures the cleanup code always runs, even if an exception occurs.

When to Use Exception Handling?

To gracefully handle unexpected errors.
For validating input and preventing crashes.
To ensure resource cleanup (e.g., closing files, releasing memory).
To maintain application stability in production environments.