C# try catch finally (How It Works For Developers)

In C#, the try-catch block allows you to handle exceptions that occur during the execution of your code. The try block section contains the code that might throw an exception, while the catch block handles the exception if it occurs. This structure is essential for preventing application crashes by gracefully handling exceptions, avoiding letting them propagate up the call stack.

The try block is where you place any code that might potentially throw an exception. This block serves as a safeguard, enabling you to specify a section of code that should be monitored for errors. If any parts of the try block throw exceptions, control is immediately transferred to the corresponding catch block.

The catch block follows the try block and is used to handle exceptions thrown by the try block code. You can have multiple catch blocks set up to handle different potential types of exceptions separately. Each catch block specifies the type of exception it handles and contains the code to process the exception, such as logging the error or displaying a user-friendly message about the error.

using IronPdf;
public static void Main(string[] args)
{
    try
    {
        // Create a PDF renderer using Chrome.
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        // Render an HTML file as a PDF.
        var pdf = renderer.RenderHtmlFileAsPdf("Example.html");
        // Save the PDF to the specified file path.
        pdf.SaveAs("output.pdf");
    }
    catch (FileNotFoundException ex)
    {
        // Handle file not found exception
        Console.WriteLine("File not found: " + ex.Message);
    }
    catch (UnauthorizedAccessException ex)
    {
        // Handle unauthorized access exception
        Console.WriteLine("Error: Access to the file is denied. " + ex.Message);
    }
    catch (Exception ex)
    {
        // Handle any other exceptions
        Console.WriteLine("An unexpected error occurred: " + ex.Message);
    }
}

using IronPdf;
public static void Main(string[] args)
{
    try
    {
        // Create a PDF renderer using Chrome.
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        // Render an HTML file as a PDF.
        var pdf = renderer.RenderHtmlFileAsPdf("Example.html");
        // Save the PDF to the specified file path.
        pdf.SaveAs("output.pdf");
    }
    catch (FileNotFoundException ex)
    {
        // Handle file not found exception
        Console.WriteLine("File not found: " + ex.Message);
    }
    catch (UnauthorizedAccessException ex)
    {
        // Handle unauthorized access exception
        Console.WriteLine("Error: Access to the file is denied. " + ex.Message);
    }
    catch (Exception ex)
    {
        // Handle any other exceptions
        Console.WriteLine("An unexpected error occurred: " + ex.Message);
    }
}

Example of a FileNotFoundException

When working with IronPDF to generate PDFs, it’s crucial to anticipate and handle various exceptions that might arise during the process. Proper implementation of exception handling code not only prevents your application from crashing but also provides a way to respond to errors gracefully, improving the overall robustness and user experience of your application. Some common exceptions that may be thrown include:

• FileNotFoundException: This exception occurs when you try to load a file with IronPDF that does not exist on the specified file path. One way of handling this could be using File.Exists(path) to verify the file's existence or wrapping the operation in an if statement block to check if the file exists.
• InvalidOperationException: This occurs when the state of the PDF document is invalid for the current operation. For example, if you try to perform operations on a PDF that is not fully loaded or rendered.
• UnauthorizedAccessException: This exception occurs when the application doesn't have permission to access the specified file or directory. This can happen due to restrictive file permissions or attempting to write to a read-only file. For example, if you were to try writing output PDF files to a directory where the application lacks writing permissions.

Some IronPDF-specific exception class types include:

• IronPdfAssemblyVersionMismatchException: This refers to errors that occur while loading assemblies during IronPDF deployment.
• IronPdfNativeException: This represents errors that can occur in the IronPDF native code.
• IronPdfProductException: This represents any errors that may occur during IronPDF execution.

using IronPdf;
using IronPdf.Exceptions;
public static void Main(string[] args)
{
    try
    {
        // Set the IronPDF license key
        IronPdf.License.LicenseKey = "license-key";
        // Create a PDF renderer
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        // Generate PDF from HTML
        var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1>");
        // Save the PDF
        pdf.SaveAs("output.pdf");
    }
    catch (IronPdfProductException ex)
    {
        // Handle PDF generation specific exceptions
        Console.WriteLine("Error During IronPDF execution: " + ex.Message);
    }
    catch (Exception ex)
    {
        // Handle general exceptions
        Console.WriteLine("An unexpected error occurred: " + ex.Message);
    }
}

using IronPdf;
using IronPdf.Exceptions;
public static void Main(string[] args)
{
    try
    {
        // Set the IronPDF license key
        IronPdf.License.LicenseKey = "license-key";
        // Create a PDF renderer
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        // Generate PDF from HTML
        var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1>");
        // Save the PDF
        pdf.SaveAs("output.pdf");
    }
    catch (IronPdfProductException ex)
    {
        // Handle PDF generation specific exceptions
        Console.WriteLine("Error During IronPDF execution: " + ex.Message);
    }
    catch (Exception ex)
    {
        // Handle general exceptions
        Console.WriteLine("An unexpected error occurred: " + ex.Message);
    }
}

Output

An example of exception handling with IronPDF could be that the license key is wrong or missing. In that case, IronPdfProductException, if being used as part of the exception handling process, would be used to show the matching error message.

In scenarios involving file operations or resource management, the finally block ensures that all resources are released appropriately, even if an error occurs during the process.

When working with files, it's common to open a file stream for reading or writing. If an exception occurs while processing the file, failing to close the stream could leave the file locked or cause other issues. The finally block ensures the file stream is always closed, thus releasing the resource.

public static void Main(string[] args)
{
    FileStream fileStream = null;
    try
    {
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        // Generate PDF from HTML
        var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1>");
        pdf.SaveAs("output.pdf");
        pdfGenerated = true;
    }
    catch (IronPdf.Exceptions.IronPdfProductException ex)
    {
        // Handle PDF generation specific exceptions
        Console.WriteLine("Error During IronPDF execution: " + ex.Message);
    }
    catch (Exception ex)
    {
        // Handle general exceptions to avoid any unhandled exception issues
        Console.WriteLine("An unexpected error occurred: " + ex.Message);
    }
    finally
    {
        // Cleanup resources if necessary
        if (fileStream != null)
        {
            fileStream.Close();
            fileStream.Dispose();
        }
    }
}

public static void Main(string[] args)
{
    FileStream fileStream = null;
    try
    {
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        // Generate PDF from HTML
        var pdf = renderer.RenderHtmlAsPdf("<h1>Hello, World!</h1>");
        pdf.SaveAs("output.pdf");
        pdfGenerated = true;
    }
    catch (IronPdf.Exceptions.IronPdfProductException ex)
    {
        // Handle PDF generation specific exceptions
        Console.WriteLine("Error During IronPDF execution: " + ex.Message);
    }
    catch (Exception ex)
    {
        // Handle general exceptions to avoid any unhandled exception issues
        Console.WriteLine("An unexpected error occurred: " + ex.Message);
    }
    finally
    {
        // Cleanup resources if necessary
        if (fileStream != null)
        {
            fileStream.Close();
            fileStream.Dispose();
        }
    }
}

Output of Finally Block Execution

When dealing with file operations in IronPDF, handling exceptions like FileNotFoundException and UnauthorizedAccessException is crucial. These exceptions often arise when files are missing or permissions are restricted. Properly handling these exceptions is essential for maintaining the robustness and reliability of your application, as they often arise when there are issues with file paths, availability, or access permissions.

using IronPdf;
using System.IO;
using IronPdf.Exceptions;
public static void Main(string[] args)
{
    try
    {
        // Generate PDF from an RTF file
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderRtfFileAsPdf("filePath");
        pdf.SaveAs("output.pdf");
    }
    catch (IronPdf.Exceptions.IronPdfProductException ex)
    {
        // Handle PDF generation specific exceptions
        Console.WriteLine("Error During IronPDF execution: " + ex.Message);
    }
    catch (IOException ex)
    {
        int retries = 5;
        int delay = 1000; // Delay in milliseconds
        Console.WriteLine("IO Exception: " + ex.Message);
        retries--;
        if (retries > 0)
        {
            Console.WriteLine("File is in use. Retrying in " + delay + "ms...");
            System.Threading.Thread.Sleep(delay);
        }
        else
        {
            Console.WriteLine("Failed to access the file after multiple attempts.");
        }
    }
    catch (Exception ex)
    {
        // Handle general exceptions
        Console.WriteLine("An unexpected error occurred: " + ex.Message);
    }
    finally
    {
        // Delete the temporary file
        if (File.Exists("temp.txt"))
        {
            File.Delete("temp.txt");
            Console.WriteLine("Cleanup Complete!");
        }
    }
}

using IronPdf;
using System.IO;
using IronPdf.Exceptions;
public static void Main(string[] args)
{
    try
    {
        // Generate PDF from an RTF file
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderRtfFileAsPdf("filePath");
        pdf.SaveAs("output.pdf");
    }
    catch (IronPdf.Exceptions.IronPdfProductException ex)
    {
        // Handle PDF generation specific exceptions
        Console.WriteLine("Error During IronPDF execution: " + ex.Message);
    }
    catch (IOException ex)
    {
        int retries = 5;
        int delay = 1000; // Delay in milliseconds
        Console.WriteLine("IO Exception: " + ex.Message);
        retries--;
        if (retries > 0)
        {
            Console.WriteLine("File is in use. Retrying in " + delay + "ms...");
            System.Threading.Thread.Sleep(delay);
        }
        else
        {
            Console.WriteLine("Failed to access the file after multiple attempts.");
        }
    }
    catch (Exception ex)
    {
        // Handle general exceptions
        Console.WriteLine("An unexpected error occurred: " + ex.Message);
    }
    finally
    {
        // Delete the temporary file
        if (File.Exists("temp.txt"))
        {
            File.Delete("temp.txt");
            Console.WriteLine("Cleanup Complete!");
        }
    }
}

Example Output: FileNotFound

Example Output: IOException

Example Output: Unexpected Error with IronPdfNativeException

Logging errors during PDF processing is essential for debugging and monitoring. It allows you to capture detailed information about issues that occur, which can be invaluable for diagnosing problems and improving the reliability of your application.

using IronPdf;
using IronPdf.Logging;
public static void Main(string[] args)
{
    IronPdf.Logging.Logger.LogFilePath = "Default.log";
    IronPdf.Logging.Logger.LoggingMode = IronPdf.Logging.Logger.LoggingModes.All;
    try
    {
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlFileAsPdf("report.html");
        pdf.SaveAs("output.pdf");
    }
    catch (Exception ex)
    {
        // Log the exception
        IronSoftware.Logger.Log("PDF processing failed: " + ex.Message);
    }
    finally
    {
        Console.WriteLine("PDF processing attempt finished.");
    }
}

using IronPdf;
using IronPdf.Logging;
public static void Main(string[] args)
{
    IronPdf.Logging.Logger.LogFilePath = "Default.log";
    IronPdf.Logging.Logger.LoggingMode = IronPdf.Logging.Logger.LoggingModes.All;
    try
    {
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlFileAsPdf("report.html");
        pdf.SaveAs("output.pdf");
    }
    catch (Exception ex)
    {
        // Log the exception
        IronSoftware.Logger.Log("PDF processing failed: " + ex.Message);
    }
    finally
    {
        Console.WriteLine("PDF processing attempt finished.");
    }
}

Console Output

Log Output

1. Backup Creation:

   • The PDF is initially saved to a backup location (backupPdfPath).

2. Successful Operation:

   • If the PDF generation is successful (pdfGenerated = true), the backup PDF is moved to the final output location.

3. Rollback on Failure:

   • If an exception occurs and pdfGenerated remains false, the backup PDF is deleted in the finally block to undo any partial changes.
4. Cleanup:
   • Regardless of success or failure, the temporary file is deleted in the finally block to ensure no leftover files.

By implementing this rollback mechanism, you ensure that the file system remains in a consistent state, even if an error occurs during the PDF generation process.

Output