.NET HILFE

C# Interlocked (Wie es für Entwickler funktioniert)

Aktualisiert:Juni 22, 2025

When working with multi-threaded applications, ensuring thread safety becomes a crucial factor in preventing race conditions and data corruption. In the world of PDF processing with IronPDF, this issue is no different. Whether you’re generating, manipulating, or combining PDFs, running these tasks concurrently can lead to unexpected results if proper synchronization is not maintained. This is where C#'s Interlocked class comes into play, providing a simple and efficient way to ensure thread-safe operations in a multi-threaded environment.

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

C# Interlocked (How it Works for Developers): Figure 1

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?

Thread Safety and Concurrency

In multi-threaded applications, multiple threads can attempt to access and modify shared data at the same time. Without proper synchronization, this could lead to issues like race conditions, where two threads try to update the same data simultaneously. This can cause unpredictable results and errors that are difficult to debug.

The Interlocked class ensures that these concurrent operations are handled atomically. In other words, when you use Interlocked to modify an object value, the change happens as a single, uninterruptible operation, which eliminates the risk of a race condition.

In the context of IronPDF, many PDF processing tasks—such as adding pages, editing content, or generating PDFs from multiple sources—are ideal candidates for parallel processing. Without synchronization, running these operations concurrently could result in corrupted PDF files or errors during processing. Using Interlocked ensures that these operations remain safe, even in a multi-threaded environment.

Using Interlocked with Different Data Types

When dealing with variables of different data types, Interlocked can be used to safely manage concurrent updates. Let’s explore some of the data types you might encounter:

Float Value: The Interlocked.CompareExchange method can be used with floating-point values when a reference type is required for the operation.
Original Value: When performing updates, it’s important to work with the original value before making changes to ensure consistency in thread operations.
Public Static Class: You can create a public static class to encapsulate your Interlocked operations, making your code more modular and easier to maintain.
Double Value: Interlocked does not directly support double values, because double is not an integral type and atomic operations are optimized for integers. If you need atomic operations on double values, you can work around it by using long values and manually converting between double and long values.

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);
    }
}

Public Module ThreadSafeOperations
	Private counter As Integer = 0
	Public Sub IncrementCounter()
		' Safely increment the counter using Interlocked
		Interlocked.Increment(counter)
	End Sub
End Module

$vbLabelText $csharpLabel

When to Use Interlocked with IronPDF

You should use Interlocked in any scenario where multiple threads are working with shared resources. Examples include:

Tracking page numbers in PDF generation.
Managing counters or lists that are accessed and modified by multiple threads.

By using Interlocked for these operations, you ensure that updates are thread-safe, preventing conflicts and ensuring data integrity.

Implementing Interlocked with IronPDF

Basic Usage of Interlocked in C#

The Interlocked class offers several methods to perform atomic operations on variables, such as:

Add: Adds two integers and stores the result in a variable.
CompareExchange: Compares two values for equality and, if they are equal, replaces one of the values.
Increment: Increases an int value by one and returns the new value.
Decrement: Decreases an int value by one and returns the new value.

For example, if you need to increment a shared counter safely in a multi-threaded environment, use Interlocked.Increment:

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

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

Dim counter As Integer = 0
Interlocked.Increment(counter)

$vbLabelText $csharpLabel

This guarantees that the counter is safely incremented, even when multiple threads are modifying it simultaneously.

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}");
    }
}

Imports IronPdf
Imports System
Imports System.Threading
Imports System.Collections.Generic

Friend Class Program
	Private Shared pageCount As Integer = 0
	Private Shared ReadOnly lockObject As New Object() ' Object for locking

	Shared Sub Main()
		Dim threads = New Thread(4){}
		Dim pdfList As New List(Of PdfDocument)()

		' Create threads for parallel PDF generation
		For i As Integer = 0 To threads.Length - 1
			threads(i) = New Thread(Sub() GeneratePdf(pdfList))
			threads(i).Start()
		Next i

		' Wait for all threads to complete
		For Each thread In threads
			thread.Join()
		Next thread

		' Merge all the generated PDFs
		Dim finalPdf As PdfDocument = pdfList(0) ' Start with the first document

		' Merge remaining PDFs into finalPdf
		For i As Integer = 1 To pdfList.Count - 1
			finalPdf = PdfDocument.Merge(finalPdf, pdfList(i))
		Next i

		' Save the merged PDF
		finalPdf.SaveAs("MergedGeneratedPDF.pdf")
		Console.WriteLine("All PDFs merged and saved successfully.")
	End Sub

	Private Shared Sub GeneratePdf(ByVal pdfList As List(Of PdfDocument))
		' Use ChromePdfRenderer instead of HtmlToPdf
		Dim renderer As New ChromePdfRenderer()

		' Use Interlocked to ensure unique page number per thread and using a "ref object" to reference the pageCount object 
		Dim pageNum As Integer = Interlocked.Increment(pageCount)

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

		' Add generated PDF page to the list (thread-safe)
		SyncLock lockObject ' Ensure thread-safety when adding to shared list
			pdfList.Add(pdfPage)
		End SyncLock

		Dim fileName As String = $"GeneratedPDF_{pageNum}.pdf"
		pdfPage.SaveAs(fileName)
		Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId} generated: {fileName}")
	End Sub
End Class

$vbLabelText $csharpLabel

Code Explanation

This C# program generates multiple PDFs in parallel using threads, then merges them into a single PDF using IronPDF.

Multithreading: 5 threads are created to generate PDFs concurrently. Each thread gets a unique page number using Interlocked.Increment.
Thread-Safety: Access to the shared pdfList is synchronized with a lock statement to prevent race conditions when adding PDFs to the list.
Merging PDFs: After all threads finish, the PDFs in pdfList are merged sequentially using PdfDocument.Merge, and the final PDF is saved.
Synchronization: The main thread waits for all threads to complete using thread.Join() before proceeding with the merge.

Console Output

C# Interlocked (How it Works for Developers): Figure 2 - Console output for thread-safe PDF generation with C# Interlocked

PDF Output

C# Interlocked (How it Works for Developers): Figure 3 - PDF output for thread-safe PDF generation with C# Interlocked

Why This is Thread-Safe

Thread-Safe List Modification: Using lock ensures that the modification of the shared pdfList is safe, preventing multiple threads from adding to the list simultaneously and causing race conditions.
No Need for Asynchronous Code: The code doesn't require async/await because the operations are sequential and don't involve long-running I/O or network calls. The main concern here is ensuring that access to shared data (the list) is properly synchronized.

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}");
}

Try
	finalPdf.SaveAs(fileName)
Catch ex As Exception
	Console.WriteLine($"Error generating PDF: {ex.Message}")
End Try

$vbLabelText $csharpLabel

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!

Häufig gestellte Fragen

Welche Rolle spielt die Interlocked-Klasse bei der PDF-Erzeugung in mehreren Threads?

Die Interlocked-Klasse ist entscheidend für die Gewährleistung der Thread-Sicherheit bei der PDF-Erzeugung in mehrteiligen Anwendungen. Sie bietet atomare Operationen, die helfen, gemeinsam genutzte Ressourcen wie Seitenzahlen oder Datei-Handles zu verwalten und sicherstellen, dass gleichzeitige Operationen sich nicht gegenseitig stören.

Wie kann ich C# verwenden, um HTML in PDF in einer threadsicheren Weise zu konvertieren?

Um HTML auf threadsichere Weise unter Verwendung von C# in PDF zu konvertieren, können Sie die Konvertierungsmethoden von IronPDF zusammen mit der Interlocked-Klasse verwenden, um gemeinsame Daten zu verwalten und sicherzustellen, dass gleichzeitige PDF-Erzeugungsaufgaben nicht in Konflikt geraten.

Was sind einige häufige Probleme bei der Erzeugung von PDFs in einer mehrteiligen Anwendung?

Häufige Probleme umfassen Wettlaufsituationen und Datenkorruption, wenn Threads gleichzeitig auf gemeinsam genutzte Ressourcen zugreifen. Durch die Verwendung der Interlocked-Klasse wird sichergestellt, dass Operationen wie die Seitenzahlvergabe oder der Dateizugriff atomar sind und dadurch diese Probleme verhindert werden.

Wie verbessert Interlocked die Bearbeitung und Manipulation von PDFs?

Interlocked verbessert die Bearbeitung und Manipulation von PDFs, indem sie atomare Operationen bereitstellt, die den threadsicheren Zugang zu gemeinsam genutzten Ressourcen gewährleisten, wie wenn mehrere Threads gleichzeitig PDFs aktualisieren oder zusammenführen.

Was sind die bewährten Praktiken für das Fehlerhandling bei mehrteiligen PDF-Operationen?

Bewährte Praktiken für das Fehlerhandling bei mehrteiligen PDF-Operationen umfassen die Nutzung von try-catch-Blöcken um Code, der PDF-Manipulationen durchführt, um Ausnahmen elegant zu handhaben und Fehler für die weitere Analyse zu protokollieren.

Kann die Interlocked-Klasse zum Verwalten von PDF-Formularen und Feldern verwendet werden?

Ja, die Interlocked-Klasse kann verwendet werden, um Operationen an PDF-Formularen und Feldern auf threadsichere Weise zu verwalten, wodurch sichergestellt wird, dass Aktualisierungen atomar sind und nicht zu Konflikten oder Datenkorruption zwischen mehreren Threads führen.

Was ist ein praktisches Beispiel für die Verwendung von Interlocked zum Zusammenführen von PDFs?

Ein praktisches Beispiel für die Verwendung von Interlocked beim Zusammenführen von PDFs ist die Verwaltung eines gemeinsamen Zählers für die Seitenzahlvergabe über mehrere Threads hinweg, um sicherzustellen, dass jede Seite während des Zusammenführungsprozesses eindeutig nummeriert ist.

Wie kann man Leistungsfähigkeit sicherstellen, wenn man Interlocked bei der PDF-Verarbeitung einsetzt?

Um Leistungsfähigkeit sicherzustellen, sollte die Synchronisierung auf kritische Codeabschnitte beschränkt werden, und Interlocked sollte nur für wesentliche atomare Operationen verwendet werden. Dies minimiert den Leistungsaufwand, der mit übermäßigem Sperren verbunden ist.

Was sind die wichtigsten Merkmale von IronPDF für Entwickler, die mit PDFs in .NET arbeiten?

Wichtige Merkmale von IronPDF umfassen die Konvertierung von HTML in PDF, PDF-Bearbeitung und -Manipulation, die Verwaltung von PDF-Formularen und -Feldern sowie das Bereitstellen digitaler Signaturen, die alle in mehrteiligen Umgebungen mithilfe der Interlocked-Klasse sicher verwaltet werden können.

Wie kann threadsichere PDF-Erzeugung mit C# erreicht werden?

Threadsichere PDF-Erzeugung in C# kann erreicht werden, indem die atomaren Operationen der Interlocked-Klasse mit den robusten PDF-Verarbeitungsfähigkeiten von IronPDF kombiniert werden, um sicherzustellen, dass parallele Prozesse ohne Konflikte arbeiten.

Curtis Chau

Jetzt mit dem Ingenieurteam chatten

Technischer Autor

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender ...

Kunden-Highlight:

Entwickler im Rampenlicht:

Webinare:

C# Interlocked (Wie es für Entwickler funktioniert)

What is the C# Interlocked Class?

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

Why Use Interlocked in IronPDF Processing?

Thread Safety and Concurrency

Using Interlocked with Different Data Types

When to Use Interlocked with IronPDF

Implementing Interlocked with IronPDF

Basic Usage of Interlocked in C#

Thread-Safe PDF Generation with IronPDF and C# Interlocked

Code Explanation

Console Output

PDF Output

Why This is Thread-Safe

Error Handling and Performance Considerations

Conclusion

Häufig gestellte Fragen

Welche Rolle spielt die Interlocked-Klasse bei der PDF-Erzeugung in mehreren Threads?

Wie kann ich C# verwenden, um HTML in PDF in einer threadsicheren Weise zu konvertieren?

Was sind einige häufige Probleme bei der Erzeugung von PDFs in einer mehrteiligen Anwendung?

Wie verbessert Interlocked die Bearbeitung und Manipulation von PDFs?

Was sind die bewährten Praktiken für das Fehlerhandling bei mehrteiligen PDF-Operationen?

Kann die Interlocked-Klasse zum Verwalten von PDF-Formularen und Feldern verwendet werden?

Was ist ein praktisches Beispiel für die Verwendung von Interlocked zum Zusammenführen von PDFs?

Wie kann man Leistungsfähigkeit sicherstellen, wenn man Interlocked bei der PDF-Verarbeitung einsetzt?

Was sind die wichtigsten Merkmale von IronPDF für Entwickler, die mit PDFs in .NET arbeiten?

Wie kann threadsichere PDF-Erzeugung mit C# erreicht werden?

C# Interlocked (Wie es für Entwickler funktioniert)

What is the C# Interlocked Class?

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

Why Use Interlocked in IronPDF Processing?

Thread Safety and Concurrency

Using Interlocked with Different Data Types

When to Use Interlocked with IronPDF

Implementing Interlocked with IronPDF

Basic Usage of Interlocked in C#

Thread-Safe PDF Generation with IronPDF and C# Interlocked

Code Explanation

Console Output

PDF Output

Why This is Thread-Safe

Error Handling and Performance Considerations

Conclusion

Häufig gestellte Fragen

Welche Rolle spielt die Interlocked-Klasse bei der PDF-Erzeugung in mehreren Threads?

Wie kann ich C# verwenden, um HTML in PDF in einer threadsicheren Weise zu konvertieren?

Was sind einige häufige Probleme bei der Erzeugung von PDFs in einer mehrteiligen Anwendung?

Wie verbessert Interlocked die Bearbeitung und Manipulation von PDFs?

Was sind die bewährten Praktiken für das Fehlerhandling bei mehrteiligen PDF-Operationen?

Kann die Interlocked-Klasse zum Verwalten von PDF-Formularen und Feldern verwendet werden?

Was ist ein praktisches Beispiel für die Verwendung von Interlocked zum Zusammenführen von PDFs?

Wie kann man Leistungsfähigkeit sicherstellen, wenn man Interlocked bei der PDF-Verarbeitung einsetzt?

Was sind die wichtigsten Merkmale von IronPDF für Entwickler, die mit PDFs in .NET arbeiten?

Wie kann threadsichere PDF-Erzeugung mit C# erreicht werden?

Verwandte Artikel

RandomNumberGenerator C#

C# String Equals (Wie es für Entwickler funktioniert)

C# Switch-Fallmuster (Wie es für Entwickler funktioniert)

Nächster Schritt: Kostenlosen 30-Tage-Test starten

Nächster Schritt: Kostenlosen 30-Tage-Test starten

Trusted by Over 2 Million Engineers Worldwide