C# Parallel Foreach (Wie es für Entwickler funktioniert)

Einführung

Was ist Parallel.ForEach in C#?

Parallel.ForEachist eine Methode in C#, die es ermöglicht, parallele Iterationen über eine Sammlung oder Datenquelle durchzuführen. Anstatt jedes Element in der Sammlung nacheinander zu verarbeiten, ermöglicht eine parallele Schleife die gleichzeitige Ausführung, was die Leistung erheblich verbessern kann, indem die gesamte Ausführungszeit reduziert wird. Die parallele Verarbeitung funktioniert, indem die Arbeit auf mehrere Kernprozessoren aufgeteilt wird, sodass Aufgaben gleichzeitig ausgeführt werden können. Dies ist besonders nützlich, wenn Aufgaben verarbeitet werden, die unabhängig voneinander sind.

Im Gegensatz zu einer normalen foreach-Schleife, die Elemente sequenziell verarbeitet, kann der parallele Ansatz große Datensätze wesentlich schneller bewältigen, indem er mehrere Threads parallel nutzt.

Warum parallele Verarbeitung mit IronPDF verwenden?

IronPDFist eine leistungsstarke Bibliothek zur Verarbeitung von PDFs in .NET, fähig zukonvertierung von HTML in PDF, extrahieren von Text aus PDFs, Zusammenführen und Aufteilen von Dokumentenund mehr. Beim Arbeiten mit großen Volumen von PDF-Aufgaben kann die Verwendung von Parallelverarbeitung mit Parallel.ForEach die Ausführungszeit erheblich verkürzen. Egal, ob Sie Hunderte von PDFs erzeugen oder Daten aus mehreren Dateien gleichzeitig extrahieren, die Nutzung von Datenparallelismus mit IronPDF stellt sicher, dass Aufgaben schneller und effizienter abgeschlossen werden.

Dieser Leitfaden richtet sich an .NET-Entwickler, die ihre PDF-Verarbeitungsaufgaben mit IronPDF und Parallel.ForEach optimieren möchten. Grundkenntnisse in C# und Vertrautheit mit der IronPDF-Bibliothek werden empfohlen. Am Ende dieses Leitfadens werden Sie in der Lage sein, parallele Verarbeitung zu implementieren, um mehrere PDF-Aufgaben gleichzeitig zu bearbeiten, was sowohl die Leistung als auch die Skalierbarkeit verbessert.

Erste Schritte

Installation von IronPDF

Zu verwendenIronPDFIn Ihrem Projekt müssen Sie die Bibliothek über NuGet installieren.

NuGet-Paketinstallation

Um IronPDF zu installieren, befolgen Sie diese Schritte:

1. Öffnen Sie Ihr Projekt in Visual Studio.

2. Gehe zu Tools → NuGet-Paket-Manager → NuGet-Pakete für die Lösung verwalten.

   3. Suchen Sie nach IronPDF im NuGet-Paket-Manager.

   

   4. Klicken Sie auf Installieren, um die IronPDF-Bibliothek zu Ihrem Projekt hinzuzufügen.

   

   Alternativ können Sie es über die NuGet-Paket-Manager-Konsole installieren:

Install-Package IronPdf

Install-Package IronPdf

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Install-Package IronPdf

Sobald IronPDF installiert ist, können Sie mit der Verwendung für PDF-Erstellungs- und -Bearbeitungsaufgaben beginnen.

Grundkonzepte von Parallel.ForEach in C

Parallel.ForEach ist Teil des System.Threading.Tasks-Namespace und bietet eine einfache und effektive Möglichkeit, Iterationen gleichzeitig auszuführen. Die Syntax für Parallel.ForEach lautet wie folgt:

Parallel.ForEach(collection, item =>
{
    // Code to process each item
});

Parallel.ForEach(collection, item =>
{
    // Code to process each item
});

Parallel.ForEach(collection, Sub(item)
	' Code to process each item
End Sub)

Jeder Eintrag in der Sammlung wird parallel verarbeitet, und das System entscheidet, wie die Arbeitslast auf die verfügbaren Threads verteilt wird. Sie können auch Optionen angeben, um den Grad der Parallelität zu steuern, wie zum Beispiel die maximale Anzahl der verwendeten Threads.

Im Vergleich dazu verarbeitet eine herkömmliche foreach-Schleife jedes Element nacheinander, während die parallele Schleife mehrere Elemente gleichzeitig verarbeiten kann, was die Leistung beim Umgang mit großen Kollektionen verbessert.

Schritt-für-Schritt-Umsetzung

Einrichten des Projekts

Stellen Sie zunächst sicher, dass IronPDF wie im Abschnitt „Erste Schritte“ beschrieben installiert ist. Danach können Sie mit der Erstellung Ihrer parallelen PDF-Verarbeitungslogik beginnen.

Schreiben der Parallelverarbeitungslogik

Code-Snippet: Verwendung von Parallel.ForEach für die HTML-zu-PDF-Konvertierung

string[] htmlPages = { "page1.html", "page2.html", "page3.html" };
Parallel.ForEach(htmlFiles, htmlFile =>
{
    // Load the HTML content into IronPDF and convert it to PDF
    ChromePdfRenderer renederer = new ChromePdfRenderer();
    PdfDocument pdf = renederer.RenderHtmlAsPdf(htmlFile);
    // Save the generated PDF to the output folder
    pdf.SaveAs($"output_{htmlFile}.pdf");
 });

string[] htmlPages = { "page1.html", "page2.html", "page3.html" };
Parallel.ForEach(htmlFiles, htmlFile =>
{
    // Load the HTML content into IronPDF and convert it to PDF
    ChromePdfRenderer renederer = new ChromePdfRenderer();
    PdfDocument pdf = renederer.RenderHtmlAsPdf(htmlFile);
    // Save the generated PDF to the output folder
    pdf.SaveAs($"output_{htmlFile}.pdf");
 });

Dim htmlPages() As String = { "page1.html", "page2.html", "page3.html" }
Parallel.ForEach(htmlFiles, Sub(htmlFile)
	' Load the HTML content into IronPDF and convert it to PDF
	Dim renederer As New ChromePdfRenderer()
	Dim pdf As PdfDocument = renederer.RenderHtmlAsPdf(htmlFile)
	' Save the generated PDF to the output folder
	pdf.SaveAs($"output_{htmlFile}.pdf")
End Sub)

Dieser Code demonstriert, wie man mehrere HTML-Seiten parallel in PDFs konvertiert.

Umgang mit Parallelverarbeitungsfehlern

Bei der Bearbeitung paralleler Aufgaben ist das Fehlerhandling entscheidend. Verwenden Sie try-catch-Blöcke innerhalb der Parallel.ForEach-Schleife, um alle Ausnahmen zu verwalten.

Code-Snippet: Fehlerbehandlung in parallelen PDF-Aufgaben

Parallel.ForEach(pdfFiles, pdfFile =>
{
    try
    {
        var pdf = IronPdf.PdfDocument.FromFile(pdfFile);
        string text = pdf.ExtractAllText();
        System.IO.File.WriteAllText($"extracted_{pdfFile}.txt", text);
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error processing {pdfFile}: {ex.Message}");
    }
});

Parallel.ForEach(pdfFiles, pdfFile =>
{
    try
    {
        var pdf = IronPdf.PdfDocument.FromFile(pdfFile);
        string text = pdf.ExtractAllText();
        System.IO.File.WriteAllText($"extracted_{pdfFile}.txt", text);
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error processing {pdfFile}: {ex.Message}");
    }
});

Parallel.ForEach(pdfFiles, Sub(pdfFile)
	Try
		Dim pdf = IronPdf.PdfDocument.FromFile(pdfFile)
		Dim text As String = pdf.ExtractAllText()
		System.IO.File.WriteAllText($"extracted_{pdfFile}.txt", text)
	Catch ex As Exception
		Console.WriteLine($"Error processing {pdfFile}: {ex.Message}")
	End Try
End Sub)

Praktische Anwendungsfälle mit vollständigen Codebeispielen

Extrahieren von Text aus mehreren PDFs gleichzeitig

Ein weiterer Anwendungsfall für die Parallelverarbeitung ist das Extrahieren von Text aus einer Reihe von PDFs. Beim Umgang mit mehreren PDF-Dateien kann die gleichzeitige Textextraktion viel Zeit sparen. Das folgende Beispiel zeigt, wie dies erfolgen kann.

Beispiel: Parallele Textextraktion aus mehreren Dokumenten

using IronPdf;
using System.Linq;
using System.Threading.Tasks;
class Program
{
    static void Main(string[] args)
    {
        string[] pdfFiles = { "doc1.pdf", "doc2.pdf", "doc3.pdf" };
        Parallel.ForEach(pdfFiles, pdfFile =>
        {
            var pdf = IronPdf.PdfDocument.FromFile(pdfFile);
            string text = pdf.ExtractText();
            System.IO.File.WriteAllText($"extracted_{pdfFile}.txt", text);
        });
    }
}

using IronPdf;
using System.Linq;
using System.Threading.Tasks;
class Program
{
    static void Main(string[] args)
    {
        string[] pdfFiles = { "doc1.pdf", "doc2.pdf", "doc3.pdf" };
        Parallel.ForEach(pdfFiles, pdfFile =>
        {
            var pdf = IronPdf.PdfDocument.FromFile(pdfFile);
            string text = pdf.ExtractText();
            System.IO.File.WriteAllText($"extracted_{pdfFile}.txt", text);
        });
    }
}

Imports IronPdf
Imports System.Linq
Imports System.Threading.Tasks
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim pdfFiles() As String = { "doc1.pdf", "doc2.pdf", "doc3.pdf" }
		Parallel.ForEach(pdfFiles, Sub(pdfFile)
			Dim pdf = IronPdf.PdfDocument.FromFile(pdfFile)
			Dim text As String = pdf.ExtractText()
			System.IO.File.WriteAllText($"extracted_{pdfFile}.txt", text)
		End Sub)
	End Sub
End Class

Dokumente ausgeben

In diesem Code wird jede PDF-Datei parallel verarbeitet, um Text zu extrahieren, und der extrahierte Text wird in separaten Textdateien gespeichert.

Beispiel: Stapel-PDF-Erstellung aus HTML-Dateien parallel

In diesem Beispiel werden wir mehrere PDFs aus einer Liste von HTML-Dateien parallel erzeugen, was ein typisches Szenario sein könnte, wenn Sie mehrere dynamische HTML-Seiten in PDF-Dokumente umwandeln müssen.

Code

using IronPdf;
string[] htmlFiles = { "example.html", "example_1.html", "example_2.html" };
Parallel.ForEach(htmlFiles, htmlFile =>
{
    try
    {
        // Load the HTML content into IronPDF and convert it to PDF
        ChromePdfRenderer renederer = new ChromePdfRenderer();
        PdfDocument pdf = renederer.RenderHtmlFileAsPdf(htmlFile);
        // Save the generated PDF to the output folder
        pdf.SaveAs($"output_{htmlFile}.pdf");
        Console.WriteLine($"PDF created for {htmlFile}");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error processing {htmlFile}: {ex.Message}");
    }
});

using IronPdf;
string[] htmlFiles = { "example.html", "example_1.html", "example_2.html" };
Parallel.ForEach(htmlFiles, htmlFile =>
{
    try
    {
        // Load the HTML content into IronPDF and convert it to PDF
        ChromePdfRenderer renederer = new ChromePdfRenderer();
        PdfDocument pdf = renederer.RenderHtmlFileAsPdf(htmlFile);
        // Save the generated PDF to the output folder
        pdf.SaveAs($"output_{htmlFile}.pdf");
        Console.WriteLine($"PDF created for {htmlFile}");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error processing {htmlFile}: {ex.Message}");
    }
});

Imports IronPdf
Private htmlFiles() As String = { "example.html", "example_1.html", "example_2.html" }
Parallel.ForEach(htmlFiles, Sub(htmlFile)
	Try
		' Load the HTML content into IronPDF and convert it to PDF
		Dim renederer As New ChromePdfRenderer()
		Dim pdf As PdfDocument = renederer.RenderHtmlFileAsPdf(htmlFile)
		' Save the generated PDF to the output folder
		pdf.SaveAs($"output_{htmlFile}.pdf")
		Console.WriteLine($"PDF created for {htmlFile}")
	Catch ex As Exception
		Console.WriteLine($"Error processing {htmlFile}: {ex.Message}")
	End Try
End Sub)

Konsolenausgabe

PDF-Ausgabe

Erläuterung

1. HTML-Dateien: Das Array htmlFiles enthält Pfade zu mehreren HTML-Dateien, die Sie in PDFs umwandeln möchten.

   2. Parallelverarbeitung:

• Parallel.ForEach(htmlFiles, htmlFile =>{...}) verarbeitet jede HTML-Datei gleichzeitig, was die Ausführung beschleunigt, wenn mehrere Dateien bearbeitet werden.

  • Für jede Datei im Array htmlFiles konvertiert der Code diese mithilfe von renederer.RenderHtmlFileAsPdf in eine PDF.(htmlDatei);

3. Speichern des PDFs: Nach der Generierung des PDFs wird es mit der pdf.SaveAs-Methode gespeichert, wobei der Name der Ausgabedatei um den Namen der ursprünglichen HTML-Datei ergänzt wird.

4. Fehlerbehandlung: Wenn ein Fehler auftritt(z. B. existiert die HTML-Datei nicht oder es gibt ein Problem während der Konvertierung), wird es vom Try-Catch-Block aufgefangen, und eine Fehlermeldung wird für die spezifische Datei ausgegeben.

Leistungstipps und bewährte Praktiken

Vermeidung von Thread-Sicherheitsproblemen mit IronPDF

IronPDF ist für die meisten Operationen thread-sicher. Einige Vorgänge, wie z.B. das gleichzeitige Schreiben in dieselbe Datei, können jedoch Probleme verursachen. Stellen Sie stets sicher, dass jede parallele Aufgabe auf einer separaten Ausgabedatei oder Ressource arbeitet.

Optimierung der parallelen Verarbeitung für große Datensätze

Um die Leistung zu optimieren, sollten Sie den Grad der Parallelität steuern. Für große Datensätze sollten Sie möglicherweise die Anzahl der gleichzeitigen Threads begrenzen, um eine Systemüberlastung zu vermeiden.

var options = new ExecutionDataflowBlockOptions
{
    MaxDegreeOfParallelism = 4
};

var options = new ExecutionDataflowBlockOptions
{
    MaxDegreeOfParallelism = 4
};

Dim options = New ExecutionDataflowBlockOptions With {.MaxDegreeOfParallelism = 4}

Speicherverwaltung bei parallelen PDF-Operationen

Beim Verarbeiten einer großen Anzahl von PDFs sollte der Speicherverbrauch beachtet werden. Versuchen Sie, Ressourcen wie PdfDocument-Objekte freizugeben, sobald sie nicht mehr benötigt werden.

Verwendung von Erweiterungsmethoden

Eine Erweiterungsmethode ist eine besondere Art von statischer Methode, die es Ihnen ermöglicht, einem bestehenden Typ neue Funktionalität hinzuzufügen, ohne dessen Quellcode zu ändern. Dies kann nützlich sein, wenn Sie mit Bibliotheken wie IronPDF arbeiten, wo Sie benutzerdefinierte Verarbeitungsmethoden hinzufügen oder deren Funktionalität erweitern möchten, um die Arbeit mit PDFs angenehmer zu gestalten, insbesondere in Szenarien mit paralleler Verarbeitung.

Vorteile der Verwendung von Erweiterungsmethoden in der Parallelverarbeitung

Durch die Verwendung von Erweiterungsmethoden können Sie präzisen, wiederverwendbaren Code erstellen, der die Logik in parallelen Schleifen vereinfacht. Dieser Ansatz reduziert nicht nur Duplikationen, sondern hilft Ihnen auch, eine saubere Codebasis zu pflegen, besonders bei der Arbeit mit komplexen PDF-Workflows und Datenparallelität.

Schlussfolgerung

Verwenden von parallelen Schleifen wie Parallel.ForEach mitIronPDFbietet erhebliche Leistungssteigerungen bei der Verarbeitung großer Mengen von PDFs. Ob Sie HTML in PDFs umwandeln, Text extrahieren oder Dokumente bearbeiten: Datenparallelität ermöglicht eine schnellere Ausführung durch gleichzeitiges Ausführen von Aufgaben. Der parallele Ansatz stellt sicher, dass Operationen über mehrere Kernprozessoren hinweg ausgeführt werden können, wodurch die gesamte Ausführungszeit verkürzt und die Leistung bei Batch-Verarbeitungsvorgängen verbessert wird.

Während die Parallelverarbeitung Aufgaben beschleunigt, sollten Sie auf die Thread-Sicherheit und das Ressourcenmanagement achten. IronPDF ist für die meisten Vorgänge threadsicher, aber es ist wichtig, potenzielle Konflikte beim Zugriff auf gemeinsam genutzte Ressourcen zu handhaben. Berücksichtigen Sie Fehlerbehandlung und Speichermanagement, um Stabilität zu gewährleisten, insbesondere wenn Ihre Anwendung skaliert.

Wenn Sie bereit sind, tiefer in IronPDF einzutauchen und erweiterte Funktionen zu erforschen, dieoffizielle Dokumentation, sodass Sie die Bibliothek in Ihren eigenen Projekten testen können, bevor Sie sich zu einem Kauf verpflichten.