Convert Multiple HTML Pages to PDF in Parallel

HiQPdf Next can convert multiple HTML documents to PDF in parallel tasks using the asynchronous HTML to PDF methods such as HtmlToPdfConvertUrlToMemoryAsync(String, CancellationToken) and merge the resulted PDFs using the PdfMergeAddPdf(Byte, String) method of HiQPdf.NextPdfMerge class. The PdfMerge class allows you to set security options, configure PDF viewer preferences and apply a digital signature to the resulting PDF.

The merged document gets a header and a footer with the page numbers of the whole document through the delayed rendering of the templates. Each converter sets the header and the footer HTML with DelayContentRendering set to true, so the converted pages reserve their space without drawing them. Once the conversions are merged, the header and the footer are added to the merged document with the PdfMergeAddHtmlTemplate(Int32, Int32, Int32, Int32, PdfTemplateHorizontalAlign, PdfTemplateVerticalAlign, String, String) method, with the size the header and the footer took in the converted pages, given by DestinationSize of the first converter, and drawn at the zoom of the pages. The templates are rendered when the merged document is saved, with the {page_number} and {total_pages} variables of the merged document.

When the documents can be converted one after the other, the PDF document API renders them in the same document, with the header and the footer as templates of the document, as described in the Convert Multiple HTML to a Single PDF and Add Header and Footer to PDF from Multiple HTML topics.

Code Sample - Convert Multiple HTML Pages to PDF in Parallel

C#
using System.Collections.Generic;
using System.Threading.Tasks;
using System.ComponentModel.DataAnnotations;
using Microsoft.AspNetCore.Mvc;
using HiQPdf_Next_AspNetDemo.Models;

using HiQPdf.Next;

namespace HiQPdf_Next_AspNetDemo.Controllers
{
    public class ConvertMultipleHtmlToPdfInParallelController : Controller
    {
        public IActionResult Index()
        {
            var model = new ConvertMultipleHtmlToPdfInParallelViewModel();
            return View(model);
        }

        [HttpPost]
        public async Task<ActionResult> ConvertToPdfInParallel(ConvertMultipleHtmlToPdfInParallelViewModel model)
        {
            if (!ModelState.IsValid)
            {
                var errorMessage = ModelStateHelper.GetModelErrors(ModelState);
                throw new ValidationException(errorMessage);
            }

            // Set the serial number received after purchase to use the library in licensed mode; leave it commented for demo mode
            // Licensing.SerialNumber = "your-serial-number";

            // Create PDF merger
            using PdfMerge pdfMerge = new PdfMerge();

            // Set PDF merge options
            SetPdfMergeOptions(pdfMerge, model);

            // Create the list of URLs to convert
            List<string> urlsToConvert = new List<string>() {
                model.Url1,
                model.Url2
            };

            // One converter for each HTML document; the first one gives the size of the header and of the footer
            List<HtmlToPdf> converters = new List<HtmlToPdf>();
            foreach (string url in urlsToConvert)
            {
                // Create the HTML to PDF Converter
                HtmlToPdf htmlToPdfConverter = new HtmlToPdf();

                // Set the HTML to PDF Converter options
                SetHtmlToPdfConverterOptions(htmlToPdfConverter, model);

                converters.Add(htmlToPdfConverter);
            }

            if (model.AsyncParallelConversionEnabled)
            {
                // Parallel conversion using asynchronous methods to convert HTML to PDF

                // List of tasks that will run in parallel
                List<Task<byte[]>> conversionTasks = new List<Task<byte[]>>();

                for (int i = 0; i < urlsToConvert.Count; i++)
                {
                    // Start async conversion
                    Task<byte[]> convertTask = converters[i].ConvertUrlToMemoryAsync(urlsToConvert[i]);
                    conversionTasks.Add(convertTask);
                }

                // Wait for all conversions to finish
                byte[][] pdfBytesArray = await Task.WhenAll(conversionTasks);

                // Add PDFs in the original order
                foreach (byte[] pdfBytes in pdfBytesArray)
                {
                    pdfMerge.AddPdf(pdfBytes);
                }
            }
            else
            {
                for (int i = 0; i < urlsToConvert.Count; i++)
                {
                    // Convert HTML to PDF
                    byte[] pdfBytes = converters[i].ConvertUrlToMemory(urlsToConvert[i]);

                    // Add the PDF to the merger
                    int pdfPageCount = pdfMerge.AddPdf(pdfBytes);
                }
            }

            // The header and the footer of the merged document, rendered when it is saved with the page numbers
            // of the whole document. The pages were converted with the space of the header and of the footer
            // reserved, so the templates take their size from the first conversion
            SetPdfMergeHeaderFooter(pdfMerge, converters[0], model);

            // Merge the PDF documents
            byte[] mergedPdf = pdfMerge.Save();

            // Send the merged PDF file to browser
            FileResult fileResult = new FileContentResult(mergedPdf, "application/pdf");
            fileResult.FileDownloadName = "Convert_Multiple_HTML_in_Parallel.pdf";

            return fileResult;
        }

        private void SetHtmlToPdfConverterOptions(HtmlToPdf htmlToPdfConverter, ConvertMultipleHtmlToPdfInParallelViewModel model)
        {

            // set browser height if specified, otherwise use the default
            if (model.BrowserHeight.HasValue)
                htmlToPdfConverter.BrowserHeight = model.BrowserHeight.Value;

            // Set an additional delay, in seconds, to wait for asynchronous content after the initial load
            // The default value is 0
            htmlToPdfConverter.WaitBeforeConvert = model.WaitTime;

            // Set the maximum time, in seconds, to wait for the HTML page to load
            // The default value is 120 seconds
            htmlToPdfConverter.HtmlLoadedTimeout = model.LoadHtmlTimeout;

            // Set the PDF page margins in points. The default is 0
            htmlToPdfConverter.Document.Margins = new PdfMargins(
                        model.LeftMargin, model.RightMargin,
                        model.TopMargin, model.BottomMargin);

            // Set the page layout: how the width at which the HTML is laid out relates to the PDF page width
            PdfPageSize pageSize = GetSelectedPageSize(model.PageSize);
            PdfPageOrientation pageOrientation = GetSelectedPageOrientation(model.PageOrientation);

            switch (model.PageLayout)
            {
                case "FitBrowserWindowToPage":
                    // Fixed page size: the HTML is laid out as in a browser window of the given width and the result
                    // is scaled to the content width of the page, so a responsive site keeps its desktop layout.
                    // This is the default layout of the converter, with an A4 page and a 1024 pixel window
                    htmlToPdfConverter.FitBrowserWindowToPage(pageSize, pageOrientation, windowWidth: model.BrowserWidth);
                    break;

                case "LayoutAtPageWidth":
                    // Fixed page size: the HTML is laid out at the content width of the page, one CSS pixel
                    // being 0.75 points. For HTML templates designed for the paper size
                    htmlToPdfConverter.LayoutAtPageWidth(pageSize, pageOrientation);
                    break;

                default:
                    // The PDF page width follows the browser window width and the HTML is drawn 1:1;
                    // the page height comes from the page size and the orientation
                    htmlToPdfConverter.PageWidthFromBrowserWindow(model.BrowserWidth, singlePage: false, zoom: model.BrowserZoom);
                    htmlToPdfConverter.Document.PageSize = pageSize;
                    htmlToPdfConverter.Document.PageOrientation = pageOrientation;
                    break;
            }

            // Enable the creation of a hierarchy of bookmarks from H1 to H6 tags
            htmlToPdfConverter.Document.GenerateDocumentOutline = model.AutoBookmarks;

            // The header and the footer reserve their space in the pages of each conversion; their rendering is
            // delayed until the conversions are merged, so the page numbers are those of the merged document
            if (model.HeaderEnabled)
            {
                htmlToPdfConverter.Document.PdfHtmlHeader.Html = model.HeaderHtml;
                htmlToPdfConverter.Document.PdfHtmlHeader.DelayContentRendering = true;
            }
            if (model.FooterEnabled)
            {
                htmlToPdfConverter.Document.PdfHtmlFooter.Html = model.FooterHtml;
                htmlToPdfConverter.Document.PdfHtmlFooter.DelayContentRendering = true;
            }
        }

        private void SetPdfMergeHeaderFooter(PdfMerge pdfMerge, HtmlToPdf firstConverter, ConvertMultipleHtmlToPdfInParallelViewModel model)
        {
            if (model.HeaderEnabled)
            {
                // The header template of the merged document has the size the header took in the converted pages
                PdfSizeF headerSize = firstConverter.Document.PdfHtmlHeader.DestinationSize;
                PdfHtmlTemplate headerTemplate = pdfMerge.AddHtmlTemplate(0, 0, (int)headerSize.Width, (int)headerSize.Height,
                    PdfTemplateHorizontalAlign.Left, PdfTemplateVerticalAlign.Top, model.HeaderHtml, null);
                // The template is drawn at the zoom of the merged pages, like the header of the conversions
                headerTemplate.Zoom = firstConverter.BrowserZoom;
            }

            if (model.FooterEnabled)
            {
                PdfSizeF footerSize = firstConverter.Document.PdfHtmlFooter.DestinationSize;
                PdfHtmlTemplate footerTemplate = pdfMerge.AddHtmlTemplate(0, 0, (int)footerSize.Width, (int)footerSize.Height,
                    PdfTemplateHorizontalAlign.Left, PdfTemplateVerticalAlign.Bottom, model.FooterHtml, null);
                footerTemplate.Zoom = firstConverter.BrowserZoom;
            }
        }

        private void SetPdfMergeOptions(PdfMerge pdfMerge, ConvertMultipleHtmlToPdfInParallelViewModel model)
        {
            // set the document security
            pdfMerge.Security.OpenPassword = model.OpenPassword;
            pdfMerge.Security.AllowPrinting = model.AllowPrinting;
        }

        private PdfPageSize GetSelectedPageSize(string pageSize)
        {
            switch (pageSize)
            {
                case "A0":
                    return PdfPageSize.A0;
                case "A1":
                    return PdfPageSize.A1;
                case "A10":
                    return PdfPageSize.A10;
                case "A2":
                    return PdfPageSize.A2;
                case "A3":
                    return PdfPageSize.A3;
                case "A4":
                    return PdfPageSize.A4;
                case "A5":
                    return PdfPageSize.A5;
                case "A6":
                    return PdfPageSize.A6;
                case "A7":
                    return PdfPageSize.A7;
                case "A8":
                    return PdfPageSize.A8;
                case "A9":
                    return PdfPageSize.A9;
                case "ArchA":
                    return PdfPageSize.ArchA;
                case "ArchB":
                    return PdfPageSize.ArchB;
                case "ArchC":
                    return PdfPageSize.ArchC;
                case "ArchD":
                    return PdfPageSize.ArchD;
                case "ArchE":
                    return PdfPageSize.ArchE;
                case "B0":
                    return PdfPageSize.B0;
                case "B1":
                    return PdfPageSize.B1;
                case "B2":
                    return PdfPageSize.B2;
                case "B3":
                    return PdfPageSize.B3;
                case "B4":
                    return PdfPageSize.B4;
                case "B5":
                    return PdfPageSize.B5;
                case "Flsa":
                    return PdfPageSize.Flsa;
                case "HalfLetter":
                    return PdfPageSize.HalfLetter;
                case "Ledger":
                    return PdfPageSize.Ledger;
                case "Legal":
                    return PdfPageSize.Legal;
                case "Letter":
                    return PdfPageSize.Letter;
                case "Letter11x17":
                    return PdfPageSize.Letter11x17;
                case "Note":
                    return PdfPageSize.Note;
                default:
                    return PdfPageSize.A4;
            }
        }

        private PdfPageOrientation GetSelectedPageOrientation(string pageOrientation)
        {
            return pageOrientation == "Portrait" ?
                PdfPageOrientation.Portrait : PdfPageOrientation.Landscape;
        }
    }
}

See Also