Try/Catch in C# (How It Works For Developers)

What are Exceptions, and Why Handle Them?

In C#, an exception represents an occurrence that takes place while a program is running, which interferes with the program's standard progression of executing instructions. When an exception occurs, the program's flow is diverted, and if the exception isn't handled, the program will terminate abruptly.

Exception handling is a way to anticipate and manage these disruptive events, allowing your program to recover from unexpected issues and continue running as intended. By using try and catch blocks, you can ensure that your code gracefully handles errors and provides users with meaningful feedback.

The Try Block

A try block is a code segment that you expect might generate exceptions. When you wrap your code in a try block, you're telling the compiler that you want to handle potential exceptions that may arise within that block.

Here's a basic example of how to use a try block:

try
{
    // Code that may generate an exception
}
catch (Exception ex)
{
    // Handle the exception
}

try
{
    // Code that may generate an exception
}
catch (Exception ex)
{
    // Handle the exception
}

Catch Block Catching Exceptions

The catch statement is used in conjunction with a try block to handle exceptions. When an exception occurs within a try block, the program execution jumps to the appropriate catch block, where you can specify what the program should do in response to the exception.

To catch an exception, you need to create a catch block immediately after the try block. A catch block typically includes a parameter that represents the caught exception.

Here's an example of a catch statement in action:

try
{
    int result = 10 / 0;
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("An error occurred: " + ex.Message);
}

try
{
    int result = 10 / 0;
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("An error occurred: " + ex.Message);
}

In this example, the code inside the try block attempts to divide by zero, which will generate a DivideByZeroException. The catch block then handles the exception, displaying a message to the user.

Multiple Catch Blocks Handling Different Exceptions

Sometimes, your try block might generate different types of possible exceptions. In such cases, you can use multiple catch blocks to handle each exception type separately.

The following example demonstrates the use of multiple catch blocks:

try
{
    int[] numbers = new int[7];
    numbers[12] = 70; // This line will throw an exception
}
catch (IndexOutOfRangeException ex)
{
    Console.WriteLine("An index out of range error occurred: " + ex.Message);
}
catch (Exception e)
{
    Console.WriteLine("An unexpected error occurred: " + e.Message);
}

try
{
    int[] numbers = new int[7];
    numbers[12] = 70; // This line will throw an exception
}
catch (IndexOutOfRangeException ex)
{
    Console.WriteLine("An index out of range error occurred: " + ex.Message);
}
catch (Exception e)
{
    Console.WriteLine("An unexpected error occurred: " + e.Message);
}

In this example, the code inside the try block attempts to assign a value to an array index that doesn't exist, generating an IndexOutOfRangeException. The first catch block handles this specific exception, while the second catch block catches any other exception that might occur.

Remember, when using multiple catch blocks, always order them from the most specific to the most general exception types.

Exception Filters Adding Conditions to Catch Blocks

Exception filters allow you to add conditions to catch blocks, enabling you to catch exceptions only if a certain condition is met. To use an exception filter, add the when keyword followed by a condition in your catch statement.

The following example demonstrates the use of exception filters:

try
{
    int result = 10 / 0;
}
catch (DivideByZeroException ex) when (ex.Message.Contains("divide"))
{
    Console.WriteLine("An error occurred: " + ex.Message);
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("A different divide by zero error occurred: " + ex.Message);
}

try
{
    int result = 10 / 0;
}
catch (DivideByZeroException ex) when (ex.Message.Contains("divide"))
{
    Console.WriteLine("An error occurred: " + ex.Message);
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("A different divide by zero error occurred: " + ex.Message);
}

In the above example, the first catch block will handle the DivideByZeroException only if the exception message contains the word "divide". If the condition is not met, the second catch block will handle the exception.

The Finally Block Ensures Code Execution

In some cases, you might want to ensure that a particular piece of code is executed, whether an exception occurs or not. To achieve this, you can use a finally block.

A finally block is placed after the try and catch blocks and is always executed, regardless of whether an exception occurs.

Here's an example that demonstrates the use of a finally block:

try
{
    int result = 10 / 2;
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("An error occurred: " + ex.Message);
}
finally
{
    Console.WriteLine("This line will always be executed.");
}

try
{
    int result = 10 / 2;
}
catch (DivideByZeroException ex)
{
    Console.WriteLine("An error occurred: " + ex.Message);
}
finally
{
    Console.WriteLine("This line will always be executed.");
}

In the above example, even if the code within the try block doesn't generate an exception, the finally block will still be executed.

Custom Exceptions: Tailoring Exceptions to Your Needs

Sometimes, you might want to create your own custom exceptions to handle specific exceptions in your code. To do this, you can create a new class that inherits from the Exception class.

Here's an example of creating a custom exception:

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

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

Now, you can use this custom exception in your try and catch blocks, like this:

try
{
    throw new CustomException("This is a custom exception.");
}
catch (CustomException ex)
{
    Console.WriteLine("A custom exception occurred: " + ex.Message);
}

try
{
    throw new CustomException("This is a custom exception.");
}
catch (CustomException ex)
{
    Console.WriteLine("A custom exception occurred: " + ex.Message);
}

In this example, the try block throws a CustomException instance, which is then caught and handled by the catch block.

IronPDF: Integrating PDF Functionality with Exception Handling

Learn More About IronPDF is a popular library for creating, editing, and extracting content from PDF files in C#. In this section, we'll explore how you can integrate IronPDF with your try-catch exception handling approach to handle potential errors gracefully.

Install-Package IronPdf

using IronPdf;
using System;

try
{
    var renderer = new ChromePdfRenderer();
    string html = "Hello, World!";
    PdfDocument PDF = renderer.RenderHtmlAsPdf(html);
    PDF.SaveAs("output.PDF");
    Console.WriteLine("PDF created successfully.");
}
catch (Exception ex)
{
    Console.WriteLine("An unexpected error occurred: " + ex.Message);
}

using IronPdf;
using System;

try
{
    var renderer = new ChromePdfRenderer();
    string html = "Hello, World!";
    PdfDocument PDF = renderer.RenderHtmlAsPdf(html);
    PDF.SaveAs("output.PDF");
    Console.WriteLine("PDF created successfully.");
}
catch (Exception ex)
{
    Console.WriteLine("An unexpected error occurred: " + ex.Message);
}

using IronPdf;
using System;
using System.IO;

try
{
    string pdfPath = "input.PDF";
    if (File.Exists(pdfPath))
    {
        PdfDocument PDF = PdfDocument.FromFile(pdfPath);
        string extractedText = PDF.ExtractAllText();
        Console.WriteLine("Text extracted successfully: " + extractedText);
    }
    else
    {
        Console.WriteLine("The specified PDF file does not exist.");
    }
}
catch (Exception ex)
{
    Console.WriteLine("An unexpected error occurred: " + ex.Message);
}

using IronPdf;
using System;
using System.IO;

try
{
    string pdfPath = "input.PDF";
    if (File.Exists(pdfPath))
    {
        PdfDocument PDF = PdfDocument.FromFile(pdfPath);
        string extractedText = PDF.ExtractAllText();
        Console.WriteLine("Text extracted successfully: " + extractedText);
    }
    else
    {
        Console.WriteLine("The specified PDF file does not exist.");
    }
}
catch (Exception ex)
{
    Console.WriteLine("An unexpected error occurred: " + ex.Message);
}