Understanding Exception Handling

Welcome to the next lesson! In this lesson, you’ll learn about exception handling in C#, its importance, and how to handle errors effectively in your applications. Let’s get started!

What is Exception Handling?

Exception handling is a mechanism for responding to runtime errors in a controlled way. It ensures that your program can recover gracefully from unexpected conditions.

Key Point: Use exception handling to prevent your application from crashing and provide meaningful feedback to users.

The Try-Catch Block

The try-catch block is used to handle exceptions. Code that might throw an exception is placed inside the try block, and the catch block handles the exception. Example:

Key Point: Use specific exception types in the catch block to handle different errors.

using System;

class Program {
    static void Main() {
        try {
            int result = 10 / 0; // This will throw a DivideByZeroException
        } catch (DivideByZeroException ex) {
            Console.WriteLine("Error: " + ex.Message);
        }
    }
}

The Finally Block

The finally block is used to execute code that must run regardless of whether an exception occurs. Example:

Tip: Use the finally block for cleanup operations like closing files or database connections.

using System;

class Program {
    static void Main() {
        try {
            int[] numbers = { 1, 2, 3 };
            Console.WriteLine(numbers[5]); // This will throw an IndexOutOfRangeException
        } catch (IndexOutOfRangeException ex) {
            Console.WriteLine("Error: " + ex.Message);
        } finally {
            Console.WriteLine("This will always execute.");
        }
    }
}

Throwing Exceptions

You can use the throw keyword to manually raise exceptions. Example:

Key Point: Throw exceptions to enforce rules or handle invalid conditions in your application.

using System;

class Program {
    static void Main() {
        try {
            ValidateAge(15);
        } catch (Exception ex) {
            Console.WriteLine("Error: " + ex.Message);
        }
    }

    static void ValidateAge(int age) {
        if (age < 18) {
            throw new ArgumentException("Age must be 18 or older.");
        }
    }
}

Custom Exceptions

You can define custom exception classes to handle specific application errors. Example:

Tip: Use custom exceptions to provide meaningful error messages specific to your application logic.

using System;

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

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

Practice Challenge

Create a program that takes user input for a number and throws an exception if the number is negative. Use a try-catch block to handle the exception. Example:

using System;

class Program {
    static void Main() {
        try {
            Console.WriteLine("Enter a number:");
            int number = int.Parse(Console.ReadLine());
            if (number < 0) {
                throw new ArgumentException("Number cannot be negative.");
            }
            Console.WriteLine("You entered: " + number);
        } catch (Exception ex) {
            Console.WriteLine("Error: " + ex.Message);
        }
    }
}

Best Practices for Exception Handling

Here are some best practices:

• Catch only specific exceptions to avoid masking other errors.
• Use the finally block for resource cleanup.
• Throw exceptions for exceptional scenarios, not for control flow.
• Log exceptions to track issues in production environments.

Tip: Proper exception handling makes your application more robust and user-friendly.

Great Job!

Congratulations! You’ve learned how to handle exceptions effectively to build error-resistant applications. In the next lesson, we’ll explore working with databases to manage and query data. Let’s keep coding!