Throwing Exceptions In C# Complete Guide

Table of Contents

1. Understanding Exceptions
2. Basic Example of Throwing an Exception
3. Handling the Thrown Exception
4. Custom Exception Class
5. When to Throw Exceptions

1. Understanding Exceptions

An exception is an event that occurs during the execution of a program that disrupts the normal flow of the program's instructions. Exceptions are typically thrown (raised) when a specific error condition has been encountered, such as a null reference or an invalid argument.

C# provides several built-in exception classes under the System namespace, including:

• System.Exception
• System.ArgumentException
• System.InvalidOperationException
• System.NullReferenceException

You can also create custom exceptions by deriving from one of these base classes.

Steps:

• Identify Potential Error Conditions: Determine where in your code things might go wrong.
• Use throw Statement: Use the throw statement to indicate an error condition should be handled as an exception.
• Handle Exceptions: Use try, catch, and optionally finally blocks to manage and respond to exceptions.

2. Basic Example of Throwing an Exception

Let's start with a simple example where we check if a number is negative before taking its square root. If it is negative, we'll throw an ArgumentException.

Code Steps:

a. Create a Method to Check and Calculate Square Root:

using System;

class Program
{
    // Method to calculate the square root
    static double CalculateSquareRoot(double number)
    {
        // Check if the number is negative
        if (number < 0)
        {
            // Throw an ArgumentException with a message
            throw new ArgumentException("Number cannot be negative", nameof(number));
        }
        
        // Return the square root of the number
        return Math.Sqrt(number);
    }

    static void Main(string[] args)
    {
        try
        {
            double num = -4;
            double result = CalculateSquareRoot(num);
            Console.WriteLine($"The square root of {num} is {result}");
        }
        catch (ArgumentException ex)
        {
            // Handle the exception by displaying the message
            Console.WriteLine($"Error: {ex.Message}");
        }
    }
}

Explanation:

• CalculateSquareRoot Method: This method takes a double as input and calculates its square root using Math.Sqrt.

  • Check for Negative Number: Inside the method, we check if the input number is negative.
  • Throw Exception: If it is negative, we throw an ArgumentException. The nameof(number) expression generates the string "number", which serves as the name of the parameter that caused the exception.

• In the Main Method:

  • Variable Declaration: We declare a variable num and initialize it with -4.
  • Try Block: The try block contains code that might throw an exception.
    • Invoke Method: Inside the try block, we call CalculateSquareRoot(num).
  • Catch Block: We catch the ArgumentException and display a custom error message using ex.Message.

Output:

Error: Number cannot be negative

3. Handling the Thrown Exception

In the previous example, we used a single catch block to handle ArgumentException. However, you can have multiple catch blocks to handle different types of exceptions separately, and you can also use a finally block to execute code that must run regardless of whether an exception was thrown.

Code Steps:

1. Modify the Main Method to Include Multiple catch Blocks and a finally Block:

using System;

class Program
{
    static double CalculateSquareRoot(double number)
    {
        if (number < 0)
        {
            throw new ArgumentException("Number cannot be negative", nameof(number));
        }
        return Math.Sqrt(number);
    }

    static void Main(string[] args)
    {
        try
        {
            double num = Convert.ToDouble(Console.ReadLine());
            double result = CalculateSquareRoot(num);
            Console.WriteLine($"The square root of {num} is {result}");
        }
        catch (FormatException ex)
        {
            Console.WriteLine($"Input error: {ex.Message}");
        }
        catch (OverflowException ex)
        {
            Console.WriteLine($"Overflow error: {ex.Message}");
        }
        catch (ArgumentException ex)
        {
            Console.WriteLine($"Argument error: {ex.Message}");
        }
        finally
        {
            Console.WriteLine("Execution completed.");
        }
    }
}

Explanation:

• Reading Input from User: In the Main method, instead of hardcoding the number, we read user input using Console.ReadLine() and convert it to a double using Convert.ToDouble.

• Exception Handling:

  • FormatException: Catches exceptions thrown when converting an invalid string to a number.
  • OverflowException: Catches exceptions thrown when the value to be converted is outside the range of the target data type.
  • ArgumentException: Catches exceptions thrown specifically by our CalculateSquareRoot method.

• Finally Block: Executes after all catch blocks. It will always run, even if no exceptions are thrown, making it suitable for cleanup activities like closing file streams or database connections.

Potential Outputs:

• If user inputs an invalid number (e.g., "abc"):

  Input error: Input string was not in a correct format.
  Execution completed.
  

• If user inputs a number too large for conversion (not applicable in this exact scenario):

  Overflow error: Value is either too large or too small for a Double.
  Execution completed.
  

• If user inputs a negative number (e.g., "-4"):

  Argument error: Number cannot be negative
  Execution completed.
  

4. Custom Exception Class

Sometimes, the built-in exception classes do not fully meet your needs for error handling. You can create a custom exception class by deriving from any of the existing exception classes, usually System.Exception.

Let's create a custom exception called NegativeNumberException and use it in our CalculateSquareRoot method.

Code Steps:

1. Define the Custom Exception Class:

using System;

// Custom exception class derived from System.Exception
class NegativeNumberException : Exception
{
    public NegativeNumberException() : base("Negative numbers are not allowed.")
    {
    }

    public NegativeNumberException(string message) : base(message)
    {
    }

    public NegativeNumberException(string message, Exception innerException) 
        : base(message, innerException)
    {
    }
}

2. Modify the CalculateSquareRoot Method to Use the Custom Exception:

static double CalculateSquareRoot(double number)
{
    if (number < 0)
    {
        // Throw a custom NegativeNumberException
        throw new NegativeNumberException($"Cannot compute square root of a negative number: {number}");
    }
    return Math.Sqrt(number);
}

3. Update the Main Method to Catch the Custom Exception:

static void Main(string[] args)
{
    try
    {
        double num = Convert.ToDouble(Console.ReadLine());
        double result = CalculateSquareRoot(num);
        Console.WriteLine($"The square root of {num} is {result}");
    }
    catch (FormatException ex)
    {
        Console.WriteLine($"Input error: {ex.Message}");
    }
    catch (OverflowException ex)
    {
        Console.WriteLine($"Overflow error: {ex.Message}");
    }
    catch (NegativeNumberException ex)
    {
        // Handle the custom NegativeNumberException
        Console.WriteLine($"NegativeNumberException: {ex.Message}");
    }
    finally
    {
        Console.WriteLine("Execution completed.");
    }
}

Full Code With Custom Exception:

using System;

// Custom exception class derived from System.Exception
class NegativeNumberException : Exception
{
    public NegativeNumberException() : base("Negative numbers are not allowed.")
    {
    }

    public NegativeNumberException(string message) : base(message)
    {
    }

    public NegativeNumberException(string message, Exception innerException) 
        : base(message, innerException)
    {
    }
}

class Program
{
    // Method to calculate the square root
    static double CalculateSquareRoot(double number)
    {
        // Check if the number is negative
        if (number < 0)
        {
            // Throw a custom NegativeNumberException
            throw new NegativeNumberException($"Cannot compute square root of a negative number: {number}");
        }
        
        // Return the square root of the number
        return Math.Sqrt(number);
    }

    static void Main(string[] args)
    {
        try
        {
            Console.Write("Enter a number to calculate its square root: ");
            double num = Convert.ToDouble(Console.ReadLine());
            double result = CalculateSquareRoot(num);
            Console.WriteLine($"The square root of {num} is {result}");
        }
        catch (FormatException ex)
        {
            Console.WriteLine($"Input error: {ex.Message}");
        }
        catch (OverflowException ex)
        {
            Console.WriteLine($"Overflow error: {ex.Message}");
        }
        catch (NegativeNumberException ex)
        {
            // Handle the custom NegativeNumberException
            Console.WriteLine($"NegativeNumberException: {ex.Message}");
        }
        finally
        {
            Console.WriteLine("Execution completed.");
        }
    }
}

Explanation:

• NegativeNumberException Class: This class inherits from Exception. It has three constructors:

  • A default constructor with a generic error message.
  • A constructor that accepts a custom error message.
  • A constructor that accepts a custom error message and an inner exception.

• CalculateSquareRoot Method: Modified to throw NegativeNumberException instead of ArgumentException when encountering a negative number.

• Main Method: Updated to catch NegativeNumberException specifically, displaying a custom error message.

Output When a Negative Number is Entered:

Enter a number to calculate its square root: -4
NegativeNumberException: Cannot compute square root of a negative number: -4
Execution completed.

5. When to Throw Exceptions

Throwing exceptions is useful in certain scenarios, but it's equally important to know when and why to throw them. Here are some guidelines:

1. Invalid Arguments (Method Parameters):

   void PrintName(string name)
   {
       if (string.IsNullOrEmpty(name))
       {
           throw new ArgumentNullException(nameof(name), "Name cannot be null or empty");
       }
       Console.WriteLine($"Printing name: {name}");
   }
   

2. Unexpected State or Operation:

   void ProcessFile(string filePath)
   {
       if (!File.Exists(filePath))
       {
           throw new FileNotFoundException($"File '{filePath}' does not exist.");
       }
   
       // Continue processing the file
   }
   

3. Failed I/O Operations:

   void ReadConfigurationFile()
   {
       string configFilePath = @"C:\path\to\config.ini";
       try
       {
           string configData = File.ReadAllText(configFilePath);
           // Parse config data
       }
       catch (IOException ex)
       {
           throw new IOException($"Failed to read configuration file '{configFilePath}'.", ex);
       }
   }
   

4. Business Logic Errors:

   class Account
   {
       double balance = 0;
   
       public void Withdraw(double amount)
       {
           if (amount <= 0)
           {
               throw new InvalidOperationException("Withdrawal amount must be greater than zero.");
           }
   
           if (amount > balance)
           {
               throw new InvalidOperationException("Insufficient funds.");
           }
   
           balance -= amount;
       }
   }
   

Why Not Always Use Exceptions?

While exceptions provide a structured way to handle errors, they come with some overhead:

• Performance: Throwing and catching exceptions can be relatively slow compared to using if statements.
• Readability: Code with many exceptions can become harder to follow and understand.
• Flow Control: Exceptions are meant for handling exceptional conditions, not for controlling normal program flow.

Best Practices:

• Validate Input Early: Validate method parameters using if statements to prevent exceptions from being thrown.
• Provide Useful Messages: When throwing exceptions, include meaningful error messages to aid debugging.
• Derive from Appropriate Base Class: Choose the most appropriate base exception class for your error condition.
• Use Inner Exceptions: Wrap original exceptions when throwing new ones to preserve valuable error information.

Conclusion

Throwing exceptions is a crucial part of building robust applications in C#. By following the examples provided, you can understand how to identify error conditions, use the throw statement, create custom exceptions, and handle exceptions effectively. Remember, proper exception usage involves balancing clear error communication with performance considerations and maintaining code readability.