Czym jest Parallel.ForEach w C#?

Parallel.ForEach to metoda w C#, która pozwala na równoległe iteracje w kolekcji lub źródle danych. Zamiast przetwarzać każdy element w kolekcji sekwencyjnie, pętla równoległa umożliwia współbieżne wykonanie, co może znacząco poprawić wydajność poprzez skrócenie całkowitego czasu wykonania. Przetwarzanie równoległe działa przez podział pracy na wiele procesorów rdzeniowych, co pozwala na jednoczesne wykonywanie zadań. Jest to szczególnie przydatne przy przetwarzaniu zadań, które są od siebie niezależne.

W przeciwieństwie do zwykłej pętli foreach, która przetwarza elementy sekwencyjnie, podejście równoległe może obsługiwać duże zestawy danych znacznie szybciej, wykorzystując wiele wątków jednocześnie.

Dlaczego używać przetwarzania równoległego z IronPDF?

IronPDF to potężna biblioteka do obsługi PDF-ów w .NET, zdolna do konwertowania HTML na PDF, wydobywania tekstu z PDF-ów, scałania i dzielenia dokumentów i nie tylko. Podczas pracy z dużą ilością zadań PDF, użycie przetwarzania równoległego z Parallel.ForEach może znacznie skrócić czas wykonania. Niezależnie od tego, czy generujesz setki PDF-ów, czy też wydobywasz dane z wielu plików jednocześnie, wykorzystanie równoległej obróbki danych z IronPDF zapewnia, że zadania są wykonywane szybciej i bardziej efektywnie.

Ten przewodnik jest przeznaczony dla programistów .NET, którzy chcą zoptymalizować swoje zadania przetwarzania PDF z użyciem IronPDF i Parallel.ForEach. Zalecana jest podstawowa znajomość C# oraz znajomość biblioteki IronPDF. Na końcu tego przewodnika będziesz w stanie zaimplementować przetwarzanie równoległe, aby obsługiwać wiele zadań PDF jednocześnie, poprawiając zarówno wydajność, jak i skalowalność.

Pierwsze kroki

Instalacja IronPDF

Aby użyć IronPDF w swoim projekcie, musisz zainstalować bibliotekę za pośrednictwem NuGet.

Instalacja pakietu NuGet

Aby zainstalować IronPDF, postępuj zgodnie z następującymi krokami:

1. Otwórz swój projekt w Visual Studio.
2. Przejdź do Narzędzia → Menadżer pakietów NuGet → Zarządzaj pakietami NuGet dla rozwiązania.
3. Wyszukaj IronPDF w menedżerze pakietów NuGet.

4. Kliknij Zainstaluj, aby dodać bibliotekę IronPDF do swojego projektu.

Alternatywnie można zainstalować ją za pośrednictwem konsoli Menedżera pakietów NuGet:

Install-Package IronPdf

Po zainstalowaniu IronPDF jesteś gotowy do jej używania do generowania i manipulacji PDF-ami.

Basic Concepts of Parallel.ForEach in C#

Parallel.ForEach jest częścią przestrzeni nazw System.Threading.Tasks i zapewnia prosty oraz skuteczny sposób na równoczesne wykonywanie iteracji. Składnia dla Parallel.ForEach jest następująca:

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)

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

Każdy element w kolekcji jest przetwarzany równolegle, a system decyduje, jak podzielić obciążenie między dostępne wątki. Możesz również określić opcje kontrolowania stopnia równoległości, takie jak maksymalna liczba używanych wątków.

Dla porównania, tradycyjna pętla foreach przetwarza każdy element jeden po drugim, podczas gdy pętla równoległa może przetwarzać wiele elementów jednocześnie, co poprawia wydajność przy obsłudze dużych zbiorów.

Wdrożenie krok po kroku

Konfiguracja projektu

Po pierwsze, upewnij się, że IronPDF jest zainstalowany zgodnie z opisem w sekcji Pierwsze Kroki. Po tym możesz zacząć pisać swoją logikę przetwarzania równoległego dla PDF-ów.

Tworzenie logiki przetwarzania równoległego

Fragment kodu: Używanie Parallel.ForEach do konwersji HTML na PDF

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

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

Dim htmlFiles() 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 renderer As New ChromePdfRenderer()
	Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(htmlFile)
	' Save the generated PDF to the output folder
	pdf.SaveAs($"output_{htmlFile}.pdf")
End Sub)

Dim htmlFiles() 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 renderer As New ChromePdfRenderer()
	Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(htmlFile)
	' Save the generated PDF to the output folder
	pdf.SaveAs($"output_{htmlFile}.pdf")
End Sub)

Ten kod pokazuje, jak konwertować wiele stron HTML na PDF w trybie równoległym.

Obsługa błędów w przetwarzaniu równoległym

Podczas pracy z zadaniami równoległymi, obsługa błędów jest kluczowa. Używaj bloków try-catch wewnątrz pętli Parallel.ForEach, aby zarządzać wyjątkami.

Fragment kodu: Obsługa błędów w zadaniach równoległych PDF

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)

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)

Praktyczne przypadki użycia z pełnymi przykładami kodu

Wydobywanie tekstu z wielu PDF-ów jednocześnie

Kolejnym przypadkiem użycia przetwarzania równoległego jest wydobywanie tekstu z partii PDF-ów. Podczas pracy z wieloma plikami PDF równoczesne wydobywanie tekstu może zaoszczędzić dużo czasu. Poniższy przykład pokazuje, jak to można zrobić.

Przykład: Równoległe wydobywanie tekstu z wielu dokumentów

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

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

Dokumenty wynikowe

W tym kodzie każdy plik PDF jest przetwarzany równolegle w celu wydobyćia tekstu, a wyodrębniony tekst jest zapisywany w osobnych plikach tekstowych.

Przykład: Generowanie PDF-ów z plików HTML w partiach równolegle

W tym przykładzie wygenerujemy wiele PDF-ów z listy plików HTML równolegle, co może być typowym scenariuszem, gdy potrzebujesz przekonwertować kilka dynamicznych stron HTML na dokumenty PDF.

Kod

using IronPdf;
using System;
using System.Threading.Tasks;

class Program
{
    static void Main(string[] args)
    {
        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 renderer = new ChromePdfRenderer();
                PdfDocument pdf = renderer.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;
using System;
using System.Threading.Tasks;

class Program
{
    static void Main(string[] args)
    {
        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 renderer = new ChromePdfRenderer();
                PdfDocument pdf = renderer.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
Imports System
Imports System.Threading.Tasks

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim 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 renderer As New ChromePdfRenderer()
				Dim pdf As PdfDocument = renderer.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)
	End Sub
End Class

Imports IronPdf
Imports System
Imports System.Threading.Tasks

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim 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 renderer As New ChromePdfRenderer()
				Dim pdf As PdfDocument = renderer.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)
	End Sub
End Class

Wynik konsoli

Wynik w formacie PDF

Wyjaśnienie

1. Pliki HTML: Tablica htmlFiles zawiera ścieżki do wielu plików HTML, które chcesz przekonwertować na pliki PDF.

2. Przetwarzanie równoległe:

   • Parallel.ForEach(htmlFiles, htmlFile => {...}) przetwarza każdy plik HTML równocześnie, co przyspiesza operację przy pracy z wieloma plikami.
   • Dla każdego pliku w tablicy htmlFiles, kod konwertuje go na PDF przy użyciu renderer.RenderHtmlFileAsPdf(htmlFile);.

3. Zapisywanie PDF: Po wygenerowaniu PDF, jest on zapisywany przy użyciu metody pdf.SaveAs, dodając do nazwy pliku wyjściowego nazwę oryginalnego pliku HTML.

4. Obsługa błędów: Jeśli wystąpi jakikolwiek błąd (np. plik HTML nie istnieje lub wystąpi problem podczas konwersji), zostanie on wychwycony przez blok try-catch, a dla konkretnego pliku zostanie wyświetlony komunikat o błędzie.

Wskazowki dotyczące wydajności i najlepsze praktyki

Unikanie problemów z bezpieczeństwem wątków z IronPDF

IronPDF jest bezpieczny dla wątków w większości operacji. Jednak niektóre operacje, takie jak zapisywanie do tego samego pliku równocześnie, mogą powodować problemy. Zawsze upewnij się, że każda równoległa operacja działa na oddzielnym pliku wyjściowym lub zasobie.

Optymalizacja przetwarzania równoległego dla dużych zestawów danych

Aby zoptymalizować wydajność, rozważ kontrolowanie stopnia równoległości. Dla dużych zestawów danych możesz chcieć ograniczyć liczbę równoczesnych wątków, aby zapobiec przeciążeniu systemu.

var options = new ExecutionDataflowBlockOptions
{
    MaxDegreeOfParallelism = 4
};

var options = new ExecutionDataflowBlockOptions
{
    MaxDegreeOfParallelism = 4
};

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

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

Zarządzanie pamięcią w operacjach PDF w trybie równoległym

Podczas przetwarzania dużej liczby plików PDF zwracaj uwagę na zużycie pamięci. Spróbuj uwolnić zasoby, takie jak obiekty PdfDocument, jak tylko nie będą już potrzebne.

Używanie metod rozszerzających

Metoda rozszerzająca to specjalny rodzaj metody statycznej, która pozwala na dodanie nowej funkcjonalności do istniejącego typu bez modyfikowania jego kodu źródłowego. Może to być przydatne podczas pracy z bibliotekami takimi jak IronPDF, gdzie możesz chcieć dodać własne metody przetwarzania lub rozszerzyć ich funkcjonalność, aby uczynić pracę z PDF-ami bardziej wygodną, szczególnie w scenariuszach przetwarzania równoległego.

Zalety używania metod rozszerzających w przetwarzaniu równoległym

Dzięki użyciu metod rozszerzających możesz tworzyć zwięzły, wielokrotnego użytku kod, który upraszcza logikę w pętlach równoległych. Takie podejście nie tylko redukuje duplikację, ale również pomaga utrzymać czysty kod, szczególnie przy pracy z złożonymi procesami PDF i równoległą obróbką danych.

Wnioski

Użycie pętli równoległych takich jak Parallel.ForEach z IronPDF zapewnia znaczne przyrosty wydajności przy przetwarzaniu dużych ilości plików PDF. Niezależnie od tego, czy konwertujesz HTML na PDF-y, wydobywasz tekst, czy manipulujesz dokumentami, równoległa obróbka danych umożliwia szybsze wykonanie, wykonując zadania równocześnie. Podejście równoległe zapewnia, że operacje mogą być wykonywane na wielu procesorach, co skraca całkowity czas wykonania i poprawia wydajność przy zadaniach przetwarzania partii.

Chociaż przetwarzanie równoległe przyspiesza zadania, zwracaj uwagę na bezpieczeństwo wątków i zarządzanie zasobami. IronPDF jest bezpieczny dla wątków w większości operacji, ale ważne jest, aby radzić sobie z potencjalnymi konfliktami podczas uzyskiwania dostępu do wspólnych zasobów. Rozważ obsługę błędów i zarządzanie pamięcią, aby zapewnić stabilność, zwłaszcza gdy Twoja aplikacja się rozwija.

Jeśli jesteś gotowy, aby zagłębić się w IronPDF i odkryć zaawansowane funkcje, oficjalna dokumentacja zawiera obszerne informacje. Dodatkowo, możesz skorzystać z licencji próbnej, która pozwala przetestować bibliotekę w swoich projektach, zanim zdecydujesz się na zakup.