C# Interlocked (How it Works for Developers)

What is the C# Interlocked Class?

In C#, the Interlocked class provides atomic operations for variables shared by multiple threads. This ensures that one thread’s actions won’t be interfered with by another, which is essential when you need to guarantee that operations are performed in a controlled and consistent manner. On the other hand, IronPDF is a powerful library that allows .NET developers to create, edit, and manipulate PDFs.

When you combine the two—Interlocked for thread safety and IronPDF for PDF operations—you get a potent solution for handling PDF tasks in concurrent programming. But how does this work, and why should you care? Let’s dive deeper into the role of Interlocked in IronPDF processing.

IronPDF: The All-In-One C# PDF Library

IronPDF is a versatile and feature-rich library designed to work seamlessly with C# and .NET applications for PDF generation and manipulation. Its simplicity and performance make it a popular choice for developers who need to automate PDF tasks. Below are some key features of IronPDF:

• HTML to PDF Conversion: IronPDF allows you to convert HTML content into high-quality PDFs. This is particularly useful for creating reports, invoices, and any content that is rendered in HTML.
• PDF Editing and Manipulation: You can manipulate existing PDF documents by merging, splitting, or extracting pages. Additionally, IronPDF allows you to modify content within PDFs, such as adding text, images, or annotations.
• PDF Forms and Fields: IronPDF supports working with PDF forms, including filling form fields programmatically. This is ideal for automating the process of generating documents like surveys, applications, and contracts.
• Digital Signatures: It provides features to sign PDFs digitally with a secure signature, which is a vital feature for industries requiring secure document transactions, such as legal and financial sectors.

By leveraging these features, IronPDF helps developers create, manage, and automate PDF workflows efficiently, all while ensuring high-quality results. Whether you're working with dynamic HTML content or manipulating existing documents, IronPDF provides the tools needed to streamline your PDF-related tasks.

Why Use Interlocked in IronPDF Processing?

public static class ThreadSafeOperations
{
    private static int counter = 0;
    public static void IncrementCounter()
    {
        // Safely increment the counter using Interlocked
        Interlocked.Increment(ref counter);
    }
}

public static class ThreadSafeOperations
{
    private static int counter = 0;
    public static void IncrementCounter()
    {
        // Safely increment the counter using Interlocked
        Interlocked.Increment(ref counter);
    }
}

Implementing Interlocked with IronPDF

int counter = 0;
Interlocked.Increment(ref counter);

int counter = 0;
Interlocked.Increment(ref counter);

Thread-Safe PDF Generation with IronPDF and C# Interlocked

Let’s take a look at a practical example of using Interlocked with IronPDF in a multi-threaded context. Suppose you are generating PDF files in parallel threads and need each thread to have a unique identifier or page number.

Here’s how you can implement this:

using IronPdf;
using System;
using System.Threading;
using System.Collections.Generic;

class Program
{
    static int pageCount = 0;
    static readonly object lockObject = new object(); // Object for locking

    static void Main()
    {
        var threads = new Thread[5];
        List<PdfDocument> pdfList = new List<PdfDocument>();

        // Create threads for parallel PDF generation
        for (int i = 0; i < threads.Length; i++)
        {
            threads[i] = new Thread(() => GeneratePdf(pdfList));
            threads[i].Start();
        }

        // Wait for all threads to complete
        foreach (var thread in threads)
        {
            thread.Join();
        }

        // Merge all the generated PDFs
        PdfDocument finalPdf = pdfList[0]; // Start with the first document

        // Merge remaining PDFs into finalPdf
        for (int i = 1; i < pdfList.Count; i++)
        {
            finalPdf = PdfDocument.Merge(finalPdf, pdfList[i]);
        }

        // Save the merged PDF
        finalPdf.SaveAs("MergedGeneratedPDF.pdf");
        Console.WriteLine("All PDFs merged and saved successfully.");
    }

    static void GeneratePdf(List<PdfDocument> pdfList)
    {
        // Use ChromePdfRenderer instead of HtmlToPdf
        ChromePdfRenderer renderer = new ChromePdfRenderer();

        // Use Interlocked to ensure unique page number per thread and using a "ref object" to reference the pageCount object 
        int pageNum = Interlocked.Increment(ref pageCount);

        // Generate a PDF page using ChromePdfRenderer
        var pdfPage = renderer.RenderHtmlAsPdf($"Page {pageNum} generated by thread {Thread.CurrentThread.ManagedThreadId}");

        // Add generated PDF page to the list (thread-safe)
        lock (lockObject) // Ensure thread-safety when adding to shared list
        {
            pdfList.Add(pdfPage);
        }

        string fileName = $"GeneratedPDF_{pageNum}.pdf";
        pdfPage.SaveAs(fileName);
        Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId} generated: {fileName}");
    }
}

using IronPdf;
using System;
using System.Threading;
using System.Collections.Generic;

class Program
{
    static int pageCount = 0;
    static readonly object lockObject = new object(); // Object for locking

    static void Main()
    {
        var threads = new Thread[5];
        List<PdfDocument> pdfList = new List<PdfDocument>();

        // Create threads for parallel PDF generation
        for (int i = 0; i < threads.Length; i++)
        {
            threads[i] = new Thread(() => GeneratePdf(pdfList));
            threads[i].Start();
        }

        // Wait for all threads to complete
        foreach (var thread in threads)
        {
            thread.Join();
        }

        // Merge all the generated PDFs
        PdfDocument finalPdf = pdfList[0]; // Start with the first document

        // Merge remaining PDFs into finalPdf
        for (int i = 1; i < pdfList.Count; i++)
        {
            finalPdf = PdfDocument.Merge(finalPdf, pdfList[i]);
        }

        // Save the merged PDF
        finalPdf.SaveAs("MergedGeneratedPDF.pdf");
        Console.WriteLine("All PDFs merged and saved successfully.");
    }

    static void GeneratePdf(List<PdfDocument> pdfList)
    {
        // Use ChromePdfRenderer instead of HtmlToPdf
        ChromePdfRenderer renderer = new ChromePdfRenderer();

        // Use Interlocked to ensure unique page number per thread and using a "ref object" to reference the pageCount object 
        int pageNum = Interlocked.Increment(ref pageCount);

        // Generate a PDF page using ChromePdfRenderer
        var pdfPage = renderer.RenderHtmlAsPdf($"Page {pageNum} generated by thread {Thread.CurrentThread.ManagedThreadId}");

        // Add generated PDF page to the list (thread-safe)
        lock (lockObject) // Ensure thread-safety when adding to shared list
        {
            pdfList.Add(pdfPage);
        }

        string fileName = $"GeneratedPDF_{pageNum}.pdf";
        pdfPage.SaveAs(fileName);
        Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId} generated: {fileName}");
    }
}

Error Handling and Performance Considerations

When working with multi-threaded code, error handling and performance optimization are essential.

• Error Handling: Although Interlocked ensures thread safety, you still need to manage potential errors in your PDF generation logic. You can use try-catch blocks to handle exceptions gracefully:

try
{
    finalPdf.SaveAs(fileName);
}
catch (Exception ex)
{
    Console.WriteLine($"Error generating PDF: {ex.Message}");
}

try
{
    finalPdf.SaveAs(fileName);
}
catch (Exception ex)
{
    Console.WriteLine($"Error generating PDF: {ex.Message}");
}

• Performance Considerations: While Interlocked is optimized for atomic operations, excessive synchronization can introduce overhead. If you are handling a high volume of concurrent operations, you should minimize synchronization to the most critical shared variables to reduce contention.

Conclusion

Thread safety is crucial in multi-threaded applications, especially when dealing with shared resources like counters or lists. When using IronPDF for PDF creation or manipulation, integrating Interlocked ensures that operations remain thread-safe and reliable.

By using Interlocked in conjunction with IronPDF, .NET developers can efficiently scale their PDF processing workflows while maintaining the integrity of the data. Whether you’re generating reports, merging documents, or performing complex PDF manipulations in parallel, Interlocked helps maintain consistency and avoid race conditions.

With these best practices, you can take full advantage of IronPDF’s capabilities and ensure that your multi-threaded PDF workflows are efficient and robust. Ready to start integrating IronPDF today and experience its powerful PDF creation and manipulation features firsthand!