Wenn Sie mit multithreaded Anwendungen in C# arbeiten, ist die Aufrechterhaltung der Datenintegrität entscheidend, insbesondere wenn Sie PDF-Dokumente mit einer Bibliothek wie IronPDF dynamisch generieren. Die Klasse ConcurrentDictionary<tkey, tvalue> bietet eine threadsichere Sammlung zur effizienten Verwaltung von Schlüssel-Wert-Paaren, selbst wenn mehrere Threads gleichzeitig Operationen wie Einfügungen, Aktualisierungen oder Suchvorgänge durchführen.
In diesem Leitfaden werden wir untersuchen, wie ConcurrentDictionary funktioniert, wie es sich in IronPDF für parallele PDF-Verarbeitung integrieren lässt und was jeder .NET-Entwickler über Schlüsseltypen, Threadsicherheit und häufige Fallstricke wie die Behandlung eines vorhandenen Schlüssels oder die Sicherstellung von Datenkonsistenz wissen muss.
Die Klasse ConcurrentDictionary<tkey, tvalue>, Teil des System.Collections.Concurrent-Namespace, ist eine generische Sammlung, die für hochleistungsfähige, threadsichere Operationen entwickelt wurde. Im Gegensatz zu einem regulären Wörterbuch können mehrere Threads die Sammlung sicher zugreifen und ändern, ohne die gesamte Struktur zu sperren.
Eine neue Instanz von ConcurrentDictionary<string, string> könnte folgendermaßen aussehen:
var dictionary = new ConcurrentDictionary<string, string>();Dim dictionary = New ConcurrentDictionary(Of String, String)()Sie können Ihre eigenen TKey- und TValue-Typen basierend auf Ihrem spezifischen Anwendungsfall definieren, z. B. zum Zwischenspeichern gerenderter PDF-Dateipfade oder zum Verfolgen gleichzeitiger PDF-Generierungsaufgaben.
Stellen Sie sich vor, Sie erstellen ein Programm, das personalisierte Rechnungen mit IronPDF für Tausende von Benutzern generiert. Wenn jeder Thread ein Dokument rendern und dessen Ergebnis speichern muss, würde ein reguläres Wörterbuch zu Wettlaufsituationen führen oder Ausnahmen auslösen, wenn ein Schlüssel bereits existiert.
Die Verwendung von ConcurrentDictionary stellt sicher:
Lassen Sie uns die wichtigsten Methoden anhand von IronPDF-Rendering-Szenarien aufschlüsseln.
Diese Methode prüft, ob ein bestimmter Schlüssel vorhanden ist. Falls nicht, wird der neue Wert hinzugefügt.
var filePath = pdfCache.GetOrAdd(userId, id => GeneratePdfForUser(id));Dim filePath = pdfCache.GetOrAdd(userId, Function(id) GeneratePdfForUser(id))Diese Methode ermöglicht es Ihnen, den Wert zu aktualisieren, wenn der Schlüssel vorhanden ist, oder ein neues Schlüssel-Wert-Paar hinzuzufügen.
pdfCache.AddOrUpdate(userId,
id => GeneratePdfForUser(id),
(id, existingValue) => UpdatePdfForUser(id, existingValue));pdfCache.AddOrUpdate(userId, Function(id) GeneratePdfForUser(id), Function(id, existingValue) UpdatePdfForUser(id, existingValue))Diese Methode versucht, einen Wert hinzuzufügen und gibt einen booleschen Wert zurück, der den Erfolg anzeigt.
bool added = pdfCache.TryAdd(userId, pdfBytes);
if (!added)
{
Console.WriteLine("PDF already cached.");
}Dim added As Boolean = pdfCache.TryAdd(userId, pdfBytes)
If Not added Then
Console.WriteLine("PDF already cached.")
End If
ConcurrentDictionary unterstützt Tuning über den Konstruktor:
int concurrencyLevel = 4;
int initialCapacity = 100;
var dictionary = new ConcurrentDictionary<string, byte[]>(concurrencyLevel, initialCapacity);Dim concurrencyLevel As Integer = 4
Dim initialCapacity As Integer = 100
Dim dictionary = New ConcurrentDictionary(Of String, Byte())(concurrencyLevel, initialCapacity)Durch richtiges Setzen dieser Werte wird der Durchsatz verbessert und Verdrängung über mehrere Threads hinweg reduziert.
Wenn ein Schlüssel nicht existiert, können Operationen wie TryGetValue den Standardwert des Typs zurückgeben:
if (!pdfCache.TryGetValue(userId, out var pdf))
{
pdf = GeneratePdfForUser(userId); // Second call
}Dim pdf As var
If Not pdfCache.TryGetValue(userId, pdf) Then
pdf = GeneratePdfForUser(userId) ' Second call
End IfDies schützt Ihren Code vor unbekanntem Code oder Nullverweisen. Überprüfen Sie immer auf einen bestimmten Wert, bevor Sie die Anwesenheit annehmen.
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using IronPdf;
public class Program
{
static ConcurrentDictionary<string, byte[]> pdfReports =
new ConcurrentDictionary<string, byte[]>();
static void Main(string[] args)
{
// Simulated user list with HTML content
var users = new List<User>
{
new User { Id = "user1", HtmlContent = "<h1>Report for User 1</h1>" },
new User { Id = "user2", HtmlContent = "<h1>Report for User 2</h1>" },
new User { Id = "user3", HtmlContent = "<h1>Report for User 3</h1>" }
};
// Generate PDFs concurrently
var renderer = new ChromePdfRenderer();
Parallel.ForEach(users, user =>
{
var pdf = pdfReports.GetOrAdd(user.Id, id =>
{
var pdfDoc = renderer.RenderHtmlAsPdf(user.HtmlContent);
return pdfDoc.BinaryData;
});
SaveToFile(pdf, $"{user.Id}.pdf");
});
Console.WriteLine("PDF generation complete.");
}
// Utility method to write PDF binary data to file
static void SaveToFile(byte[] pdfBytes, string filePath)
{
File.WriteAllBytes(filePath, pdfBytes);
Console.WriteLine($"Saved: {filePath}");
}
}
// Simple user class with ID and HTML content
public class User
{
public string Id { get; set; }
public string HtmlContent { get; set; }
}Imports System
Imports System.Collections.Concurrent
Imports System.Collections.Generic
Imports System.IO
Imports System.Threading.Tasks
Imports IronPdf
Public Class Program
Private Shared pdfReports As New ConcurrentDictionary(Of String, Byte())()
Shared Sub Main(ByVal args() As String)
' Simulated user list with HTML content
Dim users = New List(Of User) From {
New User With {
.Id = "user1",
.HtmlContent = "<h1>Report for User 1</h1>"
},
New User With {
.Id = "user2",
.HtmlContent = "<h1>Report for User 2</h1>"
},
New User With {
.Id = "user3",
.HtmlContent = "<h1>Report for User 3</h1>"
}
}
' Generate PDFs concurrently
Dim renderer = New ChromePdfRenderer()
Parallel.ForEach(users, Sub(user)
Dim pdf = pdfReports.GetOrAdd(user.Id, Function(id)
Dim pdfDoc = renderer.RenderHtmlAsPdf(user.HtmlContent)
Return pdfDoc.BinaryData
End Function)
SaveToFile(pdf, $"{user.Id}.pdf")
End Sub)
Console.WriteLine("PDF generation complete.")
End Sub
' Utility method to write PDF binary data to file
Private Shared Sub SaveToFile(ByVal pdfBytes() As Byte, ByVal filePath As String)
File.WriteAllBytes(filePath, pdfBytes)
Console.WriteLine($"Saved: {filePath}")
End Sub
End Class
' Simple user class with ID and HTML content
Public Class User
Public Property Id() As String
Public Property HtmlContent() As String
End Class
Dieses Beispiel zeigt, wie man ConcurrentDictionary<TKey, TValue> mit IronPDF kombiniert, um PDFs in einer threadsicheren Weise zu generieren. Es ist perfekt für Apps, in denen mehrere Threads gleichzeitig PDF-Dateien verarbeiten und zwischenspeichern.
Warum ConcurrentDictionary?
Gewährleistet threadsicheren Zugriff auf Schlüssel-Wert-Paare.
GetOrAdd() vermeidet doppelte PDF-Erzeugung.
Keine manuellen Locks erforderlich – perfekt für hohe Parallelität. Wie es funktioniert
Eine Liste von Benutzern, von denen jeder eine ID und HTML hat.
Parallel.ForEach startet Threads zur Generierung von PDFs.
Jeder Thread verwendet GetOrAdd(), um entweder das PDF abzurufen oder zu erstellen.
Das PDF wird unter Verwendung der Benutzer-ID als Dateiname gespeichert. Zusammenfassung
Dieses Muster ist ideal, wenn:
Während ConcurrentDictionary nicht alle LINQ-Funktionen bereitstellt, können Sie dennoch Erweiterungsmethoden nutzen, um Werte abzufragen:
var completedKeys = pdfReports.Keys.Where(k => k.StartsWith("done-")).ToList();Dim completedKeys = pdfReports.Keys.Where(Function(k) k.StartsWith("done-")).ToList()Vermeiden Sie jedoch, sich auf Elemente zu verlassen, die während der Iteration kopiert werden, da sich das Wörterbuch ändern kann. Verwenden Sie .ToList() oder .ToArray(), um bei Bedarf mit einem Snapshot zu arbeiten.
Das ConcurrentDictionary<TKey, TValue> ist ideal für Szenarien, in denen mehrere Threads gleichzeitig Schlüssel-Wert-Paare lesen/schreiben müssen—es ist der perfekte Begleiter für IronPDF in multithreaded Anwendungen.
Ob Sie gerenderte PDFs zwischenspeichern, den Status von Jobs verfolgen oder redundante Operationen verhindern, mit dieser threadsicheren Sammlung stellen Sie sicher, dass Ihre Logik mit Leistung und Zuverlässigkeit skaliert.
Bereit, hochleistungsfähige PDF-Anwendungen mit vollständiger Threadsicherheit zu entwickeln? Laden Sie eine kostenlose Testversion von IronPDF herunter und erleben Sie nahtlose PDF-Generierung kombiniert mit der Leistung von C#'s ConcurrentDictionary.
Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO Cameron Rimington in ein Unternehmen mit mehr als 50 Mitarbeitern verwandelt, das die NASA, Tesla und globale Regierungsbehörden beliefert.
IronPDF ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Wenn Ihr PDF wie HTML aussehen soll, schnell.
