C# Parallel Foreach (How it Works for Developers)

Installing IronPDF

Install-Package IronPdf

Basic Concepts of Parallel.ForEach in C#

Parallel.ForEach is part of the System.Threading.Tasks namespace and provides a simple and effective way to execute iterations concurrently. The syntax for Parallel.ForEach is as follows:

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

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

Each item in the collection is processed in parallel, and the system decides how to distribute the workload across available threads. You can also specify options to control the degree of parallelism, such as the maximum number of threads used.

In comparison, a traditional foreach loop processes each item one after the other, whereas the parallel loop can process multiple items concurrently, improving performance when handling large collections.

Setting Up the Project

First, make sure IronPDF is installed as described in the Getting Started section. After that, you can start writing your parallel PDF processing logic.

Writing the Parallel Processing Logic

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

Handling Parallel Processing Errors

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

Extracting Text from Multiple PDFs Simultaneously

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

Output Documents

In this code, each PDF file is processed in parallel to extract text, and the extracted text is saved in separate text files.

Example: Batch PDF Generation from HTML Files in Parallel

In this example, we will generate multiple PDFs from a list of HTML files in parallel, which could be a typical scenario when you need to convert several dynamic HTML pages to PDF documents.

Code

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

Console Output

PDF Output

Explanation

1. HTML Files: The array htmlFiles contains paths to multiple HTML files that you want to convert into PDFs.

2. Parallel Processing:

   • Parallel.ForEach(htmlFiles, htmlFile => {...}) processes each HTML file concurrently, which speeds up the operation when dealing with multiple files.
   • For each file in the htmlFiles array, the code converts it to a PDF using renderer.RenderHtmlFileAsPdf(htmlFile);.

3. Saving the PDF: After generating the PDF, it is saved using the pdf.SaveAs method, appending the output file name with the original HTML file's name.

4. Error Handling: If any error occurs (e.g., the HTML file doesn't exist or there's an issue during the conversion), it's caught by the try-catch block, and an error message is printed for the specific file.

Avoiding Thread Safety Issues with IronPDF

IronPDF is thread-safe for most operations. However, some operations like writing to the same file in parallel may cause issues. Always ensure that each parallel task operates on a separate output file or resource.

Optimizing Parallel Processing for Large Datasets

To optimize performance, consider controlling the degree of parallelism. For large datasets, you may want to limit the number of concurrent threads to prevent system overload.

var options = new ExecutionDataflowBlockOptions
{
    MaxDegreeOfParallelism = 4
};

var options = new ExecutionDataflowBlockOptions
{
    MaxDegreeOfParallelism = 4
};

Memory Management in Parallel PDF Operations

When processing a large number of PDFs, be mindful of memory usage. Try to release resources like PdfDocument objects as soon as they are no longer needed.

Using Extension Methods