// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Engines.Chrome;
using IronPdf.Rendering;

var renderer = new ChromePdfRenderer
{
    RenderingOptions = new ChromePdfRenderOptions
    {
        EnableJavaScript = true,

        // Page margins in millimetres
        MarginTop = 20,
        MarginBottom = 20,
        MarginLeft = 15,
        MarginRight = 15,

        CssMediaType = PdfCssMediaType.Print,
        ViewPortWidth = 1920,
        FitToPaperMode = FitToPaperModes.Automatic
    }
};

// Render only after the page calls window.ironpdf.notifyRender(), or after 10 seconds at most
renderer.RenderingOptions.WaitFor.JavaScript(10000);

// The page loads Chart.js and a Google Font from their CDNs, so the renderer needs network access
var htmlContent = @"
<!DOCTYPE html>
<html>
<head>
    <link href='https://fonts.googleapis.com/css2?family=Roboto:wght@300;400;700&display=swap' rel='stylesheet'>
    <style>
        body { font-family: 'Roboto', sans-serif; }
        .chart-container { width: 100%; height: 400px; }
        @media print {
            .no-print { display: none; }
        }
    </style>
    <script src='https://cdn.jsdelivr.net/npm/chart.js@4.4.1/dist/chart.umd.min.js'></script>
</head>
<body>
    <h1>Dynamic Sales Report</h1>
    <div class='chart-container'>
        <canvas id='salesChart'></canvas>
    </div>
    <script>
        new Chart(document.getElementById('salesChart'), {
            type: 'line',
            data: {
                labels: ['Jan', 'Feb', 'Mar', 'Apr', 'May'],
                datasets: [{
                    label: 'Sales 2025',
                    data: [65, 78, 90, 81, 96],
                    borderColor: 'rgb(75, 192, 192)',
                    tension: 0.4
                }]
            },
            // No animation, so the chart is fully drawn when the constructor returns
            options: { animation: false }
        });
        window.ironpdf.notifyRender();
    </script>
</body>
</html>";

using var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs("sales-report.pdf");

// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Engines.Chrome;
using IronPdf.Rendering;

var renderer = new ChromePdfRenderer
{
    RenderingOptions = new ChromePdfRenderOptions
    {
        EnableJavaScript = true,

        // Page margins in millimetres
        MarginTop = 20,
        MarginBottom = 20,
        MarginLeft = 15,
        MarginRight = 15,

        CssMediaType = PdfCssMediaType.Print,
        ViewPortWidth = 1920,
        FitToPaperMode = FitToPaperModes.Automatic
    }
};

// Render only after the page calls window.ironpdf.notifyRender(), or after 10 seconds at most
renderer.RenderingOptions.WaitFor.JavaScript(10000);

// The page loads Chart.js and a Google Font from their CDNs, so the renderer needs network access
var htmlContent = @"
<!DOCTYPE html>
<html>
<head>
    <link href='https://fonts.googleapis.com/css2?family=Roboto:wght@300;400;700&display=swap' rel='stylesheet'>
    <style>
        body { font-family: 'Roboto', sans-serif; }
        .chart-container { width: 100%; height: 400px; }
        @media print {
            .no-print { display: none; }
        }
    </style>
    <script src='https://cdn.jsdelivr.net/npm/chart.js@4.4.1/dist/chart.umd.min.js'></script>
</head>
<body>
    <h1>Dynamic Sales Report</h1>
    <div class='chart-container'>
        <canvas id='salesChart'></canvas>
    </div>
    <script>
        new Chart(document.getElementById('salesChart'), {
            type: 'line',
            data: {
                labels: ['Jan', 'Feb', 'Mar', 'Apr', 'May'],
                datasets: [{
                    label: 'Sales 2025',
                    data: [65, 78, 90, 81, 96],
                    borderColor: 'rgb(75, 192, 192)',
                    tension: 0.4
                }]
            },
            // No animation, so the chart is fully drawn when the constructor returns
            options: { animation: false }
        });
        window.ironpdf.notifyRender();
    </script>
</body>
</html>";

using var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs("sales-report.pdf");

// NuGet: Install-Package EvoPdf.HtmlToPdf  (EvoPdf Classic, Windows)
using System.IO;
using EvoPdf;

HtmlToPdfConverter converter = new HtmlToPdfConverter();

// Production use needs a license key. Leave this line out to evaluate:
// the output then carries an evaluation watermark. An invalid key makes the conversion throw.
// converter.LicenseKey = "<your EvoPdf license key>";

converter.PdfDocumentOptions.PdfPageSize = PdfPageSize.A4;
converter.PdfDocumentOptions.PdfPageOrientation = PdfPageOrientation.Portrait;

// EvoPdf margins are in points (1/72 inch): 57 pt is about 20 mm, 43 pt about 15 mm,
// matching the IronPDF example above, whose margins are in millimetres
converter.PdfDocumentOptions.TopMargin = 57;
converter.PdfDocumentOptions.BottomMargin = 57;
converter.PdfDocumentOptions.LeftMargin = 43;
converter.PdfDocumentOptions.RightMargin = 43;

converter.JavaScriptEnabled = true;
converter.ConversionDelay = 2; // seconds

// For pages behind HTTP authentication, also set
// converter.AuthenticationOptions.Username and .Password

// Convert HTML string
string htmlString = @"
<html>
<head>
    <style>
        body { font-family: Arial, sans-serif; }
        table { border-collapse: collapse; width: 100%; }
        th, td { border: 1px solid #ddd; padding: 8px; }
    </style>
</head>
<body>
    <h1>Invoice</h1>
    <table>
        <tr>
            <th>Item</th>
            <th>Quantity</th>
            <th>Price</th>
        </tr>
        <tr>
            <td>Product A</td>
            <td>5</td>
            <td>$50.00</td>
        </tr>
    </table>
</body>
</html>";

// Perform conversion
byte[] pdfBytes = converter.ConvertHtml(htmlString, "");

// Save to file
File.WriteAllBytes("invoice.pdf", pdfBytes);

// NuGet: Install-Package EvoPdf.HtmlToPdf  (EvoPdf Classic, Windows)
using System.IO;
using EvoPdf;

HtmlToPdfConverter converter = new HtmlToPdfConverter();

// Production use needs a license key. Leave this line out to evaluate:
// the output then carries an evaluation watermark. An invalid key makes the conversion throw.
// converter.LicenseKey = "<your EvoPdf license key>";

converter.PdfDocumentOptions.PdfPageSize = PdfPageSize.A4;
converter.PdfDocumentOptions.PdfPageOrientation = PdfPageOrientation.Portrait;

// EvoPdf margins are in points (1/72 inch): 57 pt is about 20 mm, 43 pt about 15 mm,
// matching the IronPDF example above, whose margins are in millimetres
converter.PdfDocumentOptions.TopMargin = 57;
converter.PdfDocumentOptions.BottomMargin = 57;
converter.PdfDocumentOptions.LeftMargin = 43;
converter.PdfDocumentOptions.RightMargin = 43;

converter.JavaScriptEnabled = true;
converter.ConversionDelay = 2; // seconds

// For pages behind HTTP authentication, also set
// converter.AuthenticationOptions.Username and .Password

// Convert HTML string
string htmlString = @"
<html>
<head>
    <style>
        body { font-family: Arial, sans-serif; }
        table { border-collapse: collapse; width: 100%; }
        th, td { border: 1px solid #ddd; padding: 8px; }
    </style>
</head>
<body>
    <h1>Invoice</h1>
    <table>
        <tr>
            <th>Item</th>
            <th>Quantity</th>
            <th>Price</th>
        </tr>
        <tr>
            <td>Product A</td>
            <td>5</td>
            <td>$50.00</td>
        </tr>
    </table>
</body>
</html>";

// Perform conversion
byte[] pdfBytes = converter.ConvertHtml(htmlString, "");

// Save to file
File.WriteAllBytes("invoice.pdf", pdfBytes);

// NuGet: Install-Package IronPdf
using System;
using IronPdf;
using IronPdf.Editing;
using IronPdf.Security;
using IronPdf.Signing;
using IronSoftware.Drawing;

using var pdf = PdfDocument.FromFile("confidential-report.pdf");

// Finish every content change before signing
pdf.ApplyWatermark("<h2 style='color:red; opacity:0.5;'>CONFIDENTIAL</h2>",
    45, VerticalAlignment.Middle, HorizontalAlignment.Center);

// Descriptive document properties (these do not restrict access)
pdf.MetaData.Author = "Finance Team";
pdf.MetaData.Title = "Quarterly Report (Internal)";
pdf.MetaData.ModifiedDate = DateTime.UtcNow;

// Owner password: required to change the permissions below
pdf.SecuritySettings.OwnerPassword = "owner-password";

// User password: required to open the document
pdf.SecuritySettings.UserPassword = "user-password";

pdf.SecuritySettings.AllowUserCopyPasteContentForAccessibility = false;
pdf.SecuritySettings.AllowUserAnnotations = false;
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserFormData = true;
pdf.SecuritySettings.AllowUserEdits = PdfEditSecurity.NoEdit;
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.PrintLowQuality;
pdf.SecuritySettings.EncryptionType = PdfEncryptionType.Aes_256;

// Visible digital signature: image file, page index, and position/size on the page
var signature = new PdfSignature("certificate.pfx", "cert-password")
{
    SigningReason = "Document Approval",
    SigningLocation = "Head Office",
    SigningContact = "security@example.com",
    SignatureImage = new PdfSignatureImage("signature.png", 0, new Rectangle(100, 100, 200, 50))
};
pdf.Sign(signature);

// The signature is applied when the file is saved
pdf.SaveAs("secured-document.pdf");

// NuGet: Install-Package IronPdf
using System;
using IronPdf;
using IronPdf.Editing;
using IronPdf.Security;
using IronPdf.Signing;
using IronSoftware.Drawing;

using var pdf = PdfDocument.FromFile("confidential-report.pdf");

// Finish every content change before signing
pdf.ApplyWatermark("<h2 style='color:red; opacity:0.5;'>CONFIDENTIAL</h2>",
    45, VerticalAlignment.Middle, HorizontalAlignment.Center);

// Descriptive document properties (these do not restrict access)
pdf.MetaData.Author = "Finance Team";
pdf.MetaData.Title = "Quarterly Report (Internal)";
pdf.MetaData.ModifiedDate = DateTime.UtcNow;

// Owner password: required to change the permissions below
pdf.SecuritySettings.OwnerPassword = "owner-password";

// User password: required to open the document
pdf.SecuritySettings.UserPassword = "user-password";

pdf.SecuritySettings.AllowUserCopyPasteContentForAccessibility = false;
pdf.SecuritySettings.AllowUserAnnotations = false;
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserFormData = true;
pdf.SecuritySettings.AllowUserEdits = PdfEditSecurity.NoEdit;
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.PrintLowQuality;
pdf.SecuritySettings.EncryptionType = PdfEncryptionType.Aes_256;

// Visible digital signature: image file, page index, and position/size on the page
var signature = new PdfSignature("certificate.pfx", "cert-password")
{
    SigningReason = "Document Approval",
    SigningLocation = "Head Office",
    SigningContact = "security@example.com",
    SignatureImage = new PdfSignatureImage("signature.png", 0, new Rectangle(100, 100, 200, 50))
};
pdf.Sign(signature);

// The signature is applied when the file is saved
pdf.SaveAs("secured-document.pdf");

// NuGet: Install-Package EvoPdf.PdfSecurity
// (licensed with the EVO PDF Toolkit; not included in the standalone HTML to PDF license)
using EvoPdf.PdfSecurity;

PdfSecurityOptions securityOptions = new PdfSecurityOptions();

// Set basic security parameters
securityOptions.UserPassword = "user123";
securityOptions.OwnerPassword = "owner456";
securityOptions.EncryptionAlgorithm = EncryptionAlgorithm.AES;
securityOptions.KeySize = EncryptionKeySize.EncryptKey256Bit;

// Configure permissions
securityOptions.CanPrint = true;
securityOptions.CanCopyContent = false;
securityOptions.CanEditContent = false;
securityOptions.CanEditAnnotations = false;
securityOptions.CanFillFormFields = true;
securityOptions.CanAssembleDocument = false;

// Apply security to existing PDF
PdfSecurityManager securityManager = new PdfSecurityManager(securityOptions);
securityManager.SaveSecuredPdfToFile("input.pdf", "secured-output.pdf");

// NuGet: Install-Package EvoPdf.PdfSecurity
// (licensed with the EVO PDF Toolkit; not included in the standalone HTML to PDF license)
using EvoPdf.PdfSecurity;

PdfSecurityOptions securityOptions = new PdfSecurityOptions();

// Set basic security parameters
securityOptions.UserPassword = "user123";
securityOptions.OwnerPassword = "owner456";
securityOptions.EncryptionAlgorithm = EncryptionAlgorithm.AES;
securityOptions.KeySize = EncryptionKeySize.EncryptKey256Bit;

// Configure permissions
securityOptions.CanPrint = true;
securityOptions.CanCopyContent = false;
securityOptions.CanEditContent = false;
securityOptions.CanEditAnnotations = false;
securityOptions.CanFillFormFields = true;
securityOptions.CanAssembleDocument = false;

// Apply security to existing PDF
PdfSecurityManager securityManager = new PdfSecurityManager(securityOptions);
securityManager.SaveSecuredPdfToFile("input.pdf", "secured-output.pdf");

// NuGet: Install-Package IronPdf
using IronPdf;
using IronSoftware.Drawing;

// This example expects a PDF with at least three pages
using var pdf = PdfDocument.FromFile("customer-records.pdf");

// 1. Redact a specific value on every page
pdf.RedactTextOnAllPages("123-45-6789");

// 2. Redact a word on specific pages (zero-based page indexes)
pdf.RedactTextOnPages(new[] { 0, 1, 2 }, "Confidential", CaseSensitive: false);

// 3. Redact a rectangular region on the first page
pdf.RedactRegionOnPage(0, new RectangleF(100, 200, 300, 50));

// 4. Replace a complete sensitive value with a label instead of drawing a black box
pdf.RedactTextOnAllPages("ACCT-0042-7781", DrawRectangles: false, ReplacementText: "[REDACTED]");

pdf.SaveAs("redacted-records.pdf");

// NuGet: Install-Package IronPdf
using IronPdf;
using IronSoftware.Drawing;

// This example expects a PDF with at least three pages
using var pdf = PdfDocument.FromFile("customer-records.pdf");

// 1. Redact a specific value on every page
pdf.RedactTextOnAllPages("123-45-6789");

// 2. Redact a word on specific pages (zero-based page indexes)
pdf.RedactTextOnPages(new[] { 0, 1, 2 }, "Confidential", CaseSensitive: false);

// 3. Redact a rectangular region on the first page
pdf.RedactRegionOnPage(0, new RectangleF(100, 200, 300, 50));

// 4. Replace a complete sensitive value with a label instead of drawing a black box
pdf.RedactTextOnAllPages("ACCT-0042-7781", DrawRectangles: false, ReplacementText: "[REDACTED]");

pdf.SaveAs("redacted-records.pdf");

// NuGet: Install-Package IronPdf
using System;
using IronPdf;

// Create a new PDF with an HTML form
var html = @"
<html>
<body>
    <h2>Employee Information Form</h2>
    <form>
        <label>Full Name:</label>
        <input type='text' name='fullName' required />
        
        <label>Email:</label>
        <input type='email' name='email' required />
        
        <label>Department:</label>
        <select name='department'>
            <option value=''>Select Department</option>
            <option value='IT'>Information Technology</option>
            <option value='HR'>Human Resources</option>
            <option value='Sales'>Sales</option>
        </select>
        
        <label>Start Date:</label>
        <input type='text' name='startDate' placeholder='YYYY-MM-DD' />
        
        <label>
            <input type='checkbox' name='agreement' />
            I agree to the terms and conditions
        </label>
        
        <button type='submit'>Submit</button>
    </form>
</body>
</html>";

var renderer = new ChromePdfRenderer
{
    RenderingOptions = new ChromePdfRenderOptions
    {
        CreatePdfFormsFromHtml = true // Enable form field creation
    }
};

using var pdf = renderer.RenderHtmlAsPdf(html);

// Programmatically fill form fields
pdf.Form.FindFormField("fullName").Value = "John Doe";
pdf.Form.FindFormField("email").Value = "john.doe@example.com";
// A dropdown takes one of its displayed choices, not the HTML option value ("IT")
pdf.Form.FindFormField("department").Value = "Information Technology";
pdf.Form.FindFormField("startDate").Value = DateTime.Now.ToString("yyyy-MM-dd");
// "Yes" is the checkbox's checked state
pdf.Form.FindFormField("agreement").Value = "Yes";

// Make specific fields read-only
pdf.Form.FindFormField("email").ReadOnly = true;

// Save as fillable form
pdf.SaveAs("fillable-form.pdf");

// Or flatten the form (convert to static content)
pdf.Flatten();
pdf.SaveAs("completed-form.pdf");

// NuGet: Install-Package IronPdf
using System;
using IronPdf;

// Create a new PDF with an HTML form
var html = @"
<html>
<body>
    <h2>Employee Information Form</h2>
    <form>
        <label>Full Name:</label>
        <input type='text' name='fullName' required />
        
        <label>Email:</label>
        <input type='email' name='email' required />
        
        <label>Department:</label>
        <select name='department'>
            <option value=''>Select Department</option>
            <option value='IT'>Information Technology</option>
            <option value='HR'>Human Resources</option>
            <option value='Sales'>Sales</option>
        </select>
        
        <label>Start Date:</label>
        <input type='text' name='startDate' placeholder='YYYY-MM-DD' />
        
        <label>
            <input type='checkbox' name='agreement' />
            I agree to the terms and conditions
        </label>
        
        <button type='submit'>Submit</button>
    </form>
</body>
</html>";

var renderer = new ChromePdfRenderer
{
    RenderingOptions = new ChromePdfRenderOptions
    {
        CreatePdfFormsFromHtml = true // Enable form field creation
    }
};

using var pdf = renderer.RenderHtmlAsPdf(html);

// Programmatically fill form fields
pdf.Form.FindFormField("fullName").Value = "John Doe";
pdf.Form.FindFormField("email").Value = "john.doe@example.com";
// A dropdown takes one of its displayed choices, not the HTML option value ("IT")
pdf.Form.FindFormField("department").Value = "Information Technology";
pdf.Form.FindFormField("startDate").Value = DateTime.Now.ToString("yyyy-MM-dd");
// "Yes" is the checkbox's checked state
pdf.Form.FindFormField("agreement").Value = "Yes";

// Make specific fields read-only
pdf.Form.FindFormField("email").ReadOnly = true;

// Save as fillable form
pdf.SaveAs("fillable-form.pdf");

// Or flatten the form (convert to static content)
pdf.Flatten();
pdf.SaveAs("completed-form.pdf");

// NuGet: Install-Package IronPdf
using System;
using System.Diagnostics;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using IronPdf;

// Timing harness for a batch of documents. Replace the generated HTML with your own templates.
const int documentCount = 100;
const int maxConcurrency = 4;

var htmlDocuments = Enumerable.Range(1, documentCount)
    .Select(i => $"<html><body><h1>Invoice {i}</h1><p>Amount due: {i * 10} USD</p></body></html>")
    .ToList();

var renderer = new ChromePdfRenderer
{
    RenderingOptions = new ChromePdfRenderOptions
    {
        EnableJavaScript = false // static content only
    }
};

// Cap how many renders run at once instead of starting every render immediately
using var gate = new SemaphoreSlim(maxConcurrency);
var stopwatch = Stopwatch.StartNew();

var tasks = htmlDocuments.Select(async (html, index) =>
{
    await gate.WaitAsync();
    try
    {
        using var pdf = await renderer.RenderHtmlAsPdfAsync(html);
        pdf.SaveAs($"invoice-{index + 1}.pdf");
    }
    finally
    {
        gate.Release();
    }
});
await Task.WhenAll(tasks);

stopwatch.Stop();
Console.WriteLine($"Documents: {documentCount}, at most {maxConcurrency} at a time");
Console.WriteLine($"Total elapsed: {stopwatch.ElapsedMilliseconds} ms");
// Elapsed time divided by the document count: an amortized figure, not the latency of one request
Console.WriteLine($"Amortized time per document: {stopwatch.ElapsedMilliseconds / (double)documentCount:F1} ms");
// Resident memory of this process only, sampled once at the end; the Chromium helper
// processes are not included, and this is not the peak
Console.WriteLine($"Working set of this process at end: {Process.GetCurrentProcess().WorkingSet64 / 1024 / 1024} MB");

// NuGet: Install-Package IronPdf
using System;
using System.Diagnostics;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using IronPdf;

// Timing harness for a batch of documents. Replace the generated HTML with your own templates.
const int documentCount = 100;
const int maxConcurrency = 4;

var htmlDocuments = Enumerable.Range(1, documentCount)
    .Select(i => $"<html><body><h1>Invoice {i}</h1><p>Amount due: {i * 10} USD</p></body></html>")
    .ToList();

var renderer = new ChromePdfRenderer
{
    RenderingOptions = new ChromePdfRenderOptions
    {
        EnableJavaScript = false // static content only
    }
};

// Cap how many renders run at once instead of starting every render immediately
using var gate = new SemaphoreSlim(maxConcurrency);
var stopwatch = Stopwatch.StartNew();

var tasks = htmlDocuments.Select(async (html, index) =>
{
    await gate.WaitAsync();
    try
    {
        using var pdf = await renderer.RenderHtmlAsPdfAsync(html);
        pdf.SaveAs($"invoice-{index + 1}.pdf");
    }
    finally
    {
        gate.Release();
    }
});
await Task.WhenAll(tasks);

stopwatch.Stop();
Console.WriteLine($"Documents: {documentCount}, at most {maxConcurrency} at a time");
Console.WriteLine($"Total elapsed: {stopwatch.ElapsedMilliseconds} ms");
// Elapsed time divided by the document count: an amortized figure, not the latency of one request
Console.WriteLine($"Amortized time per document: {stopwatch.ElapsedMilliseconds / (double)documentCount:F1} ms");
// Resident memory of this process only, sampled once at the end; the Chromium helper
// processes are not included, and this is not the peak
Console.WriteLine($"Working set of this process at end: {Process.GetCurrentProcess().WorkingSet64 / 1024 / 1024} MB");

// NuGet: Install-Package IronPdf
using IronPdf;

var renderer = new ChromePdfRenderer();

string bootstrapTimeline = @"
<!DOCTYPE html>
<html>
<head>
    <link href='https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css' rel='stylesheet'>
    <style>
        .timeline { position: relative; padding: 20px 0; }
        .timeline::before {
            content: '';
            position: absolute;
            left: 50%;
            width: 2px;
            height: 100%;
            background: #dee2e6;
        }
        .timeline-item { position: relative; margin: 20px 0; }
    </style>
</head>
<body>
    <div class='container py-5'>
        <h2 class='text-center mb-5'>Project Timeline</h2>
        <div class='timeline'>
            <div class='timeline-item'>
                <div class='row'>
                    <div class='col-md-6'>
                        <div class='card shadow-sm'>
                            <div class='card-body'>
                                <h5 class='card-title'>Phase 1: Planning</h5>
                                <p class='text-muted'>Q1 2025</p>
                                <p class='card-text'>Initial project scope and requirements gathering completed.</p>
                                <span class='badge bg-success'>Completed</span>
                            </div>
                        </div>
                    </div>
                </div>
            </div>
            <!-- Additional timeline items... -->
        </div>
    </div>
</body>
</html>";

// The page loads Bootstrap from a CDN, so the renderer needs network access
using var pdf = renderer.RenderHtmlAsPdf(bootstrapTimeline);
pdf.SaveAs("project-timeline.pdf");

// NuGet: Install-Package IronPdf
using IronPdf;

var renderer = new ChromePdfRenderer();

string bootstrapTimeline = @"
<!DOCTYPE html>
<html>
<head>
    <link href='https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css' rel='stylesheet'>
    <style>
        .timeline { position: relative; padding: 20px 0; }
        .timeline::before {
            content: '';
            position: absolute;
            left: 50%;
            width: 2px;
            height: 100%;
            background: #dee2e6;
        }
        .timeline-item { position: relative; margin: 20px 0; }
    </style>
</head>
<body>
    <div class='container py-5'>
        <h2 class='text-center mb-5'>Project Timeline</h2>
        <div class='timeline'>
            <div class='timeline-item'>
                <div class='row'>
                    <div class='col-md-6'>
                        <div class='card shadow-sm'>
                            <div class='card-body'>
                                <h5 class='card-title'>Phase 1: Planning</h5>
                                <p class='text-muted'>Q1 2025</p>
                                <p class='card-text'>Initial project scope and requirements gathering completed.</p>
                                <span class='badge bg-success'>Completed</span>
                            </div>
                        </div>
                    </div>
                </div>
            </div>
            <!-- Additional timeline items... -->
        </div>
    </div>
</body>
</html>";

// The page loads Bootstrap from a CDN, so the renderer needs network access
using var pdf = renderer.RenderHtmlAsPdf(bootstrapTimeline);
pdf.SaveAs("project-timeline.pdf");

// NuGet: Install-Package IronPdf
using System.Net;
using IronPdf;
using IronPdf.Security;
using IronPdf.Signing;

var patient = new PatientRecord("P-10442", "Jane <Q.> Doe & Family", "123-45-6789", "open-sesame");

// HTML-encode text values, so characters such as & and < print as text instead of changing the markup
var html = $@"
<html>
<body>
    <h1>Patient Summary</h1>
    <p>Patient ID: {WebUtility.HtmlEncode(patient.PatientId)}</p>
    <p>Name: {WebUtility.HtmlEncode(patient.Name)}</p>
    <p>SSN: {WebUtility.HtmlEncode(patient.Ssn)}</p>
</body>
</html>";

var renderer = new ChromePdfRenderer();
using var pdf = renderer.RenderHtmlAsPdf(html);

// Remove the SSN from the page content wherever it appears
pdf.RedactTextOnAllPages(patient.Ssn);

// Descriptive document properties
pdf.MetaData.Author = "Records System";
pdf.MetaData.Title = $"Patient Summary {patient.PatientId}";

// Require a password to open the file, restrict copying, and encrypt with AES-256
pdf.SecuritySettings.UserPassword = patient.AccessCode;
pdf.SecuritySettings.OwnerPassword = "records-owner-password";
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights;
pdf.SecuritySettings.EncryptionType = PdfEncryptionType.Aes_256;

// Sign last, so changes made to the file after signing can be detected
pdf.Sign(new PdfSignature("records-cert.pfx", "password")
{
    SigningReason = "Record export",
    SigningLocation = "Records Department"
});

pdf.SaveAs("patient-summary.pdf");

record PatientRecord(string PatientId, string Name, string Ssn, string AccessCode);

// NuGet: Install-Package IronPdf
using System.Net;
using IronPdf;
using IronPdf.Security;
using IronPdf.Signing;

var patient = new PatientRecord("P-10442", "Jane <Q.> Doe & Family", "123-45-6789", "open-sesame");

// HTML-encode text values, so characters such as & and < print as text instead of changing the markup
var html = $@"
<html>
<body>
    <h1>Patient Summary</h1>
    <p>Patient ID: {WebUtility.HtmlEncode(patient.PatientId)}</p>
    <p>Name: {WebUtility.HtmlEncode(patient.Name)}</p>
    <p>SSN: {WebUtility.HtmlEncode(patient.Ssn)}</p>
</body>
</html>";

var renderer = new ChromePdfRenderer();
using var pdf = renderer.RenderHtmlAsPdf(html);

// Remove the SSN from the page content wherever it appears
pdf.RedactTextOnAllPages(patient.Ssn);

// Descriptive document properties
pdf.MetaData.Author = "Records System";
pdf.MetaData.Title = $"Patient Summary {patient.PatientId}";

// Require a password to open the file, restrict copying, and encrypt with AES-256
pdf.SecuritySettings.UserPassword = patient.AccessCode;
pdf.SecuritySettings.OwnerPassword = "records-owner-password";
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights;
pdf.SecuritySettings.EncryptionType = PdfEncryptionType.Aes_256;

// Sign last, so changes made to the file after signing can be detected
pdf.Sign(new PdfSignature("records-cert.pfx", "password")
{
    SigningReason = "Record export",
    SigningLocation = "Records Department"
});

pdf.SaveAs("patient-summary.pdf");

record PatientRecord(string PatientId, string Name, string Ssn, string AccessCode);

// NuGet: Install-Package EvoPdf.HtmlToPdf  (EvoPdf Classic, Windows)
using System;
using System.Globalization;
using System.IO;
using System.Net;
using EvoPdf;

var invoice = new InvoiceData("INV-2026-0042", new DateTime(2026, 9, 1), "Smith & Sons <Ltd>", 1250.00m);

var converter = new HtmlToPdfConverter
{
    // LicenseKey = "<your EvoPdf license key>",
    JavaScriptEnabled = false, // not needed for static invoices
    ConversionDelay = 0
};
converter.PdfDocumentOptions.PdfPageSize = PdfPageSize.A4;
converter.PdfDocumentOptions.TopMargin = 30;    // points
converter.PdfDocumentOptions.BottomMargin = 30; // points

string template =
    "<html><body><h1>Invoice {{InvoiceNumber}}</h1>" +
    "<p>Date: {{Date}}</p><p>Customer: {{CustomerName}}</p><p>Total: {{Total}}</p></body></html>";

// HTML-encode text values, so characters such as & and < print as text instead of changing the markup
string html = template
    .Replace("{{InvoiceNumber}}", WebUtility.HtmlEncode(invoice.InvoiceNumber))
    .Replace("{{Date}}", invoice.Date.ToString("yyyy-MM-dd"))
    .Replace("{{CustomerName}}", WebUtility.HtmlEncode(invoice.CustomerName))
    .Replace("{{Total}}", invoice.Total.ToString("C", CultureInfo.GetCultureInfo("en-US")));

File.WriteAllBytes($"invoice-{invoice.InvoiceNumber}.pdf", converter.ConvertHtml(html, ""));

record InvoiceData(string InvoiceNumber, DateTime Date, string CustomerName, decimal Total);

// NuGet: Install-Package EvoPdf.HtmlToPdf  (EvoPdf Classic, Windows)
using System;
using System.Globalization;
using System.IO;
using System.Net;
using EvoPdf;

var invoice = new InvoiceData("INV-2026-0042", new DateTime(2026, 9, 1), "Smith & Sons <Ltd>", 1250.00m);

var converter = new HtmlToPdfConverter
{
    // LicenseKey = "<your EvoPdf license key>",
    JavaScriptEnabled = false, // not needed for static invoices
    ConversionDelay = 0
};
converter.PdfDocumentOptions.PdfPageSize = PdfPageSize.A4;
converter.PdfDocumentOptions.TopMargin = 30;    // points
converter.PdfDocumentOptions.BottomMargin = 30; // points

string template =
    "<html><body><h1>Invoice {{InvoiceNumber}}</h1>" +
    "<p>Date: {{Date}}</p><p>Customer: {{CustomerName}}</p><p>Total: {{Total}}</p></body></html>";

// HTML-encode text values, so characters such as & and < print as text instead of changing the markup
string html = template
    .Replace("{{InvoiceNumber}}", WebUtility.HtmlEncode(invoice.InvoiceNumber))
    .Replace("{{Date}}", invoice.Date.ToString("yyyy-MM-dd"))
    .Replace("{{CustomerName}}", WebUtility.HtmlEncode(invoice.CustomerName))
    .Replace("{{Total}}", invoice.Total.ToString("C", CultureInfo.GetCultureInfo("en-US")));

File.WriteAllBytes($"invoice-{invoice.InvoiceNumber}.pdf", converter.ConvertHtml(html, ""));

record InvoiceData(string InvoiceNumber, DateTime Date, string CustomerName, decimal Total);

// NuGet: Install-Package IronPdf
using System;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using IronPdf;
using IronPdf.Engines.Chrome;
using IronPdf.Rendering;

// Global engine settings: set once at startup, before the first render
Installation.ChromeGpuMode = ChromeGpuModes.Disabled; // servers usually have no GPU
// Set to false only if the Linux dependencies are already installed in your image
Installation.LinuxAndDockerDependenciesAutoConfig = false;

var service = new PdfService(maxConcurrency: 4);
var pages = Enumerable.Range(1, 8).Select(i => $"<h1>Report {i}</h1>");
byte[][] results = await Task.WhenAll(pages.Select(service.GeneratePdfAsync));

for (int i = 0; i < results.Length; i++)
    File.WriteAllBytes($"report-{i + 1}.pdf", results[i]);
Console.WriteLine($"Generated {results.Length} PDFs");

public class PdfService
{
    private readonly ChromePdfRenderer _renderer;
    private readonly SemaphoreSlim _gate;

    public PdfService(int maxConcurrency)
    {
        // Caps how many renders run at once
        _gate = new SemaphoreSlim(maxConcurrency);

        _renderer = new ChromePdfRenderer
        {
            RenderingOptions = new ChromePdfRenderOptions
            {
                EnableJavaScript = false, // only if the pages need no JavaScript
                CssMediaType = PdfCssMediaType.Screen,
                Timeout = 30 // seconds
            }
        };
    }

    public async Task<byte[]> GeneratePdfAsync(string html)
    {
        await _gate.WaitAsync();
        try
        {
            using var pdf = await _renderer.RenderHtmlAsPdfAsync(html);
            return pdf.BinaryData;
        }
        finally
        {
            _gate.Release();
        }
    }
}

// NuGet: Install-Package IronPdf
using System;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using IronPdf;
using IronPdf.Engines.Chrome;
using IronPdf.Rendering;

// Global engine settings: set once at startup, before the first render
Installation.ChromeGpuMode = ChromeGpuModes.Disabled; // servers usually have no GPU
// Set to false only if the Linux dependencies are already installed in your image
Installation.LinuxAndDockerDependenciesAutoConfig = false;

var service = new PdfService(maxConcurrency: 4);
var pages = Enumerable.Range(1, 8).Select(i => $"<h1>Report {i}</h1>");
byte[][] results = await Task.WhenAll(pages.Select(service.GeneratePdfAsync));

for (int i = 0; i < results.Length; i++)
    File.WriteAllBytes($"report-{i + 1}.pdf", results[i]);
Console.WriteLine($"Generated {results.Length} PDFs");

public class PdfService
{
    private readonly ChromePdfRenderer _renderer;
    private readonly SemaphoreSlim _gate;

    public PdfService(int maxConcurrency)
    {
        // Caps how many renders run at once
        _gate = new SemaphoreSlim(maxConcurrency);

        _renderer = new ChromePdfRenderer
        {
            RenderingOptions = new ChromePdfRenderOptions
            {
                EnableJavaScript = false, // only if the pages need no JavaScript
                CssMediaType = PdfCssMediaType.Screen,
                Timeout = 30 // seconds
            }
        };
    }

    public async Task<byte[]> GeneratePdfAsync(string html)
    {
        await _gate.WaitAsync();
        try
        {
            using var pdf = await _renderer.RenderHtmlAsPdfAsync(html);
            return pdf.BinaryData;
        }
        finally
        {
            _gate.Release();
        }
    }
}

// NuGet: Install-Package EvoPdf.HtmlToPdf  (EvoPdf Classic, Windows)
using System;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using EvoPdf;

var service = new EvoPdfService(maxConcurrency: 4);
var pages = Enumerable.Range(1, 8).Select(i => $"<h1>Report {i}</h1>");
byte[][] results = await Task.WhenAll(pages.Select(service.GeneratePdfAsync));

for (int i = 0; i < results.Length; i++)
    File.WriteAllBytes($"evopdf-report-{i + 1}.pdf", results[i]);
Console.WriteLine($"Generated {results.Length} PDFs");

public class EvoPdfService
{
    private readonly SemaphoreSlim _gate;

    // Caps how many conversions run at once
    public EvoPdfService(int maxConcurrency) => _gate = new SemaphoreSlim(maxConcurrency);

    public async Task<byte[]> GeneratePdfAsync(string html)
    {
        await _gate.WaitAsync();
        try
        {
            // A new converter for each conversion, as EVO documents for parallel conversions
            var converter = new HtmlToPdfConverter
            {
                // LicenseKey = "<your EvoPdf license key>",
                JavaScriptEnabled = false,
                ConversionDelay = 0
            };

            // The Classic API is synchronous, so run it on a thread-pool thread
            return await Task.Run(() => converter.ConvertHtml(html, ""));
        }
        finally
        {
            _gate.Release();
        }
    }
}

// NuGet: Install-Package EvoPdf.HtmlToPdf  (EvoPdf Classic, Windows)
using System;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using EvoPdf;

var service = new EvoPdfService(maxConcurrency: 4);
var pages = Enumerable.Range(1, 8).Select(i => $"<h1>Report {i}</h1>");
byte[][] results = await Task.WhenAll(pages.Select(service.GeneratePdfAsync));

for (int i = 0; i < results.Length; i++)
    File.WriteAllBytes($"evopdf-report-{i + 1}.pdf", results[i]);
Console.WriteLine($"Generated {results.Length} PDFs");

public class EvoPdfService
{
    private readonly SemaphoreSlim _gate;

    // Caps how many conversions run at once
    public EvoPdfService(int maxConcurrency) => _gate = new SemaphoreSlim(maxConcurrency);

    public async Task<byte[]> GeneratePdfAsync(string html)
    {
        await _gate.WaitAsync();
        try
        {
            // A new converter for each conversion, as EVO documents for parallel conversions
            var converter = new HtmlToPdfConverter
            {
                // LicenseKey = "<your EvoPdf license key>",
                JavaScriptEnabled = false,
                ConversionDelay = 0
            };

            // The Classic API is synchronous, so run it on a thread-pool thread
            return await Task.Run(() => converter.ConvertHtml(html, ""));
        }
        finally
        {
            _gate.Release();
        }
    }
}

// NuGet: Install-Package IronPdf
using System;
using System.IO;
using System.Threading.Tasks;
using IronPdf;
using IronPdf.Exceptions;

// Write IronPDF's own diagnostics to a log file
IronPdf.Logging.Logger.LogFilePath = "ironpdf.log";
IronPdf.Logging.Logger.LoggingMode = IronPdf.Logging.Logger.LoggingModes.All;

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.Timeout = 60; // seconds

byte[] page = await TryRenderUrlAsync(renderer, "https://example.com/");
if (page != null)
{
    File.WriteAllBytes("example.pdf", page);
    Console.WriteLine($"Rendered {page.Length} bytes");
}

// A host that does not resolve makes the render throw, which exercises the error path
byte[] missing = await TryRenderUrlAsync(renderer, "https://nonexistent.invalid/");
Console.WriteLine(missing == null ? "Second render failed and was handled" : "Second render succeeded");

// Returns the PDF bytes, or null if the page could not be rendered
static async Task<byte[]> TryRenderUrlAsync(ChromePdfRenderer renderer, string url)
{
    try
    {
        using var pdf = await renderer.RenderUrlAsPdfAsync(url);
        if (pdf.PageCount == 0)
        {
            Console.Error.WriteLine($"No pages rendered for {url}");
            return null;
        }
        return pdf.BinaryData;
    }
    catch (IronPdfNativeException ex)
    {
        // Raised by the rendering engine, for example when the page cannot be loaded
        Console.Error.WriteLine($"Rendering failed for {url}: {ex.Message}");
        return null;
    }
}

// NuGet: Install-Package IronPdf
using System;
using System.IO;
using System.Threading.Tasks;
using IronPdf;
using IronPdf.Exceptions;

// Write IronPDF's own diagnostics to a log file
IronPdf.Logging.Logger.LogFilePath = "ironpdf.log";
IronPdf.Logging.Logger.LoggingMode = IronPdf.Logging.Logger.LoggingModes.All;

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.Timeout = 60; // seconds

byte[] page = await TryRenderUrlAsync(renderer, "https://example.com/");
if (page != null)
{
    File.WriteAllBytes("example.pdf", page);
    Console.WriteLine($"Rendered {page.Length} bytes");
}

// A host that does not resolve makes the render throw, which exercises the error path
byte[] missing = await TryRenderUrlAsync(renderer, "https://nonexistent.invalid/");
Console.WriteLine(missing == null ? "Second render failed and was handled" : "Second render succeeded");

// Returns the PDF bytes, or null if the page could not be rendered
static async Task<byte[]> TryRenderUrlAsync(ChromePdfRenderer renderer, string url)
{
    try
    {
        using var pdf = await renderer.RenderUrlAsPdfAsync(url);
        if (pdf.PageCount == 0)
        {
            Console.Error.WriteLine($"No pages rendered for {url}");
            return null;
        }
        return pdf.BinaryData;
    }
    catch (IronPdfNativeException ex)
    {
        // Raised by the rendering engine, for example when the page cannot be loaded
        Console.Error.WriteLine($"Rendering failed for {url}: {ex.Message}");
        return null;
    }
}

// NuGet: Install-Package IronPdf
using System;
using IronPdf;
using IronPdf.Editing;
using IronPdf.Security;
using IronPdf.Signing;
using IronSoftware.Drawing;

var renderer = new ChromePdfRenderer();
using var pdf = renderer.RenderHtmlAsPdf(
    "<h1>Quarterly Statement: Q3 2026</h1>" +
    "<table><tr><td>Revenue</td><td>1,250,000</td></tr><tr><td>Expenses</td><td>980,000</td></tr></table>");

// Mark the document as a draft
pdf.ApplyWatermark(@"
    <div style='color: rgba(0,0,0,0.1); font-size: 120px; transform: rotate(-45deg); font-family: Arial;'>
        DRAFT
    </div>", 30, VerticalAlignment.Middle, HorizontalAlignment.Center);

// Descriptive document properties: useful for search and filing, not a record of who changed what
pdf.MetaData.Author = "Financial Reporting System";
pdf.MetaData.Keywords = "Quarterly Statement, Q3 2026";
pdf.MetaData.CustomProperties.Add("ReportPeriod", "2026-Q3");
pdf.MetaData.CustomProperties.Add("GeneratedAt", DateTime.UtcNow.ToString("O"));

// Restrict editing; the owner password is needed to change these permissions
pdf.SecuritySettings.OwnerPassword = "finance-owner-password";
pdf.SecuritySettings.AllowUserEdits = PdfEditSecurity.NoEdit;
pdf.SecuritySettings.AllowUserCopyPasteContent = true;
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights;
pdf.SecuritySettings.EncryptionType = PdfEncryptionType.Aes_256;

// Sign last: readers can then detect changes made after signing
pdf.Sign(new PdfSignature("financial-cert.pfx", "password")
{
    SigningReason = "Statement approval",
    SigningLocation = "Finance Department",
    // Visible signature image on the first page
    SignatureImage = new PdfSignatureImage("cfo-signature.png", 0, new Rectangle(50, 50, 200, 60))
});

pdf.SaveAs("quarterly-statement.pdf");

// NuGet: Install-Package IronPdf
using System;
using IronPdf;
using IronPdf.Editing;
using IronPdf.Security;
using IronPdf.Signing;
using IronSoftware.Drawing;

var renderer = new ChromePdfRenderer();
using var pdf = renderer.RenderHtmlAsPdf(
    "<h1>Quarterly Statement: Q3 2026</h1>" +
    "<table><tr><td>Revenue</td><td>1,250,000</td></tr><tr><td>Expenses</td><td>980,000</td></tr></table>");

// Mark the document as a draft
pdf.ApplyWatermark(@"
    <div style='color: rgba(0,0,0,0.1); font-size: 120px; transform: rotate(-45deg); font-family: Arial;'>
        DRAFT
    </div>", 30, VerticalAlignment.Middle, HorizontalAlignment.Center);

// Descriptive document properties: useful for search and filing, not a record of who changed what
pdf.MetaData.Author = "Financial Reporting System";
pdf.MetaData.Keywords = "Quarterly Statement, Q3 2026";
pdf.MetaData.CustomProperties.Add("ReportPeriod", "2026-Q3");
pdf.MetaData.CustomProperties.Add("GeneratedAt", DateTime.UtcNow.ToString("O"));

// Restrict editing; the owner password is needed to change these permissions
pdf.SecuritySettings.OwnerPassword = "finance-owner-password";
pdf.SecuritySettings.AllowUserEdits = PdfEditSecurity.NoEdit;
pdf.SecuritySettings.AllowUserCopyPasteContent = true;
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.FullPrintRights;
pdf.SecuritySettings.EncryptionType = PdfEncryptionType.Aes_256;

// Sign last: readers can then detect changes made after signing
pdf.Sign(new PdfSignature("financial-cert.pfx", "password")
{
    SigningReason = "Statement approval",
    SigningLocation = "Finance Department",
    // Visible signature image on the first page
    SignatureImage = new PdfSignatureImage("cfo-signature.png", 0, new Rectangle(50, 50, 200, 60))
});

pdf.SaveAs("quarterly-statement.pdf");

// NuGet: Install-Package IronPdf
using System;
using System.Globalization;
using System.Linq;
using System.Net;
using IronPdf;
using IronPdf.Rendering;

var order = new Order("INV-1001", new DateTime(2026, 9, 1), new[]
{
    new OrderItem("Widget <Deluxe> & Co. edition", 2, 19.99m),
    new OrderItem("Gift wrap", 1, 4.50m)
});

var renderer = new ChromePdfRenderer
{
    RenderingOptions = new ChromePdfRenderOptions
    {
        MarginTop = 10,    // millimetres
        MarginBottom = 10,
        PaperSize = PdfPaperSize.A4
    }
};

var usd = CultureInfo.GetCultureInfo("en-US");

// HTML-encode text values, so characters such as & and < print as text instead of changing the markup
string rows = string.Concat(order.Items.Select(item => $@"
        <tr>
            <td>{WebUtility.HtmlEncode(item.Name)}</td>
            <td>{item.Quantity}</td>
            <td>{item.Price.ToString("C", usd)}</td>
            <td>{item.Total.ToString("C", usd)}</td>
        </tr>"));

var html = $@"
<html>
<head>
    <style>
        body {{ font-family: Arial, sans-serif; }}
        .invoice-header {{ background: #f0f0f0; padding: 20px; }}
        table {{ width: 100%; border-collapse: collapse; }}
        th, td {{ padding: 10px; border-bottom: 1px solid #ddd; text-align: left; }}
    </style>
</head>
<body>
    <div class='invoice-header'>
        <h1>Invoice #{WebUtility.HtmlEncode(order.InvoiceNumber)}</h1>
        <p>Date: {order.Date:yyyy-MM-dd}</p>
    </div>
    <table>
        <tr><th>Item</th><th>Quantity</th><th>Price</th><th>Total</th></tr>
        {rows}
        <tr><td colspan='3'><strong>Total</strong></td><td><strong>{order.Total.ToString("C", usd)}</strong></td></tr>
    </table>
    <p>Thank you for your business!</p>
</body>
</html>";

using var pdf = await renderer.RenderHtmlAsPdfAsync(html);
pdf.SaveAs($"invoice-{order.InvoiceNumber}.pdf");

record OrderItem(string Name, int Quantity, decimal Price)
{
    public decimal Total => Price * Quantity;
}

record Order(string InvoiceNumber, DateTime Date, OrderItem[] Items)
{
    public decimal Total => Items.Sum(item => item.Total);
}

// NuGet: Install-Package IronPdf
using System;
using System.Globalization;
using System.Linq;
using System.Net;
using IronPdf;
using IronPdf.Rendering;

var order = new Order("INV-1001", new DateTime(2026, 9, 1), new[]
{
    new OrderItem("Widget <Deluxe> & Co. edition", 2, 19.99m),
    new OrderItem("Gift wrap", 1, 4.50m)
});

var renderer = new ChromePdfRenderer
{
    RenderingOptions = new ChromePdfRenderOptions
    {
        MarginTop = 10,    // millimetres
        MarginBottom = 10,
        PaperSize = PdfPaperSize.A4
    }
};

var usd = CultureInfo.GetCultureInfo("en-US");

// HTML-encode text values, so characters such as & and < print as text instead of changing the markup
string rows = string.Concat(order.Items.Select(item => $@"
        <tr>
            <td>{WebUtility.HtmlEncode(item.Name)}</td>
            <td>{item.Quantity}</td>
            <td>{item.Price.ToString("C", usd)}</td>
            <td>{item.Total.ToString("C", usd)}</td>
        </tr>"));

var html = $@"
<html>
<head>
    <style>
        body {{ font-family: Arial, sans-serif; }}
        .invoice-header {{ background: #f0f0f0; padding: 20px; }}
        table {{ width: 100%; border-collapse: collapse; }}
        th, td {{ padding: 10px; border-bottom: 1px solid #ddd; text-align: left; }}
    </style>
</head>
<body>
    <div class='invoice-header'>
        <h1>Invoice #{WebUtility.HtmlEncode(order.InvoiceNumber)}</h1>
        <p>Date: {order.Date:yyyy-MM-dd}</p>
    </div>
    <table>
        <tr><th>Item</th><th>Quantity</th><th>Price</th><th>Total</th></tr>
        {rows}
        <tr><td colspan='3'><strong>Total</strong></td><td><strong>{order.Total.ToString("C", usd)}</strong></td></tr>
    </table>
    <p>Thank you for your business!</p>
</body>
</html>";

using var pdf = await renderer.RenderHtmlAsPdfAsync(html);
pdf.SaveAs($"invoice-{order.InvoiceNumber}.pdf");

record OrderItem(string Name, int Quantity, decimal Price)
{
    public decimal Total => Price * Quantity;
}

record Order(string InvoiceNumber, DateTime Date, OrderItem[] Items)
{
    public decimal Total => Items.Sum(item => item.Total);
}

// NuGet: Install-Package EvoPdf.HtmlToPdf  (EvoPdf Classic, Windows)
// NuGet: Install-Package IronPdf
using System.IO;
using EvoPdf;
using IronPdf;
using IronPdf.Rendering;

string url = "https://example.com/";

// EvoPdf pattern
HtmlToPdfConverter evoPdfConverter = new HtmlToPdfConverter();
evoPdfConverter.PdfDocumentOptions.PdfPageSize = PdfPageSize.A4;
File.WriteAllBytes("evopdf.pdf", evoPdfConverter.ConvertUrl(url));

// Equivalent IronPDF pattern
var ironPdfRenderer = new ChromePdfRenderer
{
    RenderingOptions = new ChromePdfRenderOptions
    {
        PaperSize = PdfPaperSize.A4
    }
};
using (var pdf = ironPdfRenderer.RenderUrlAsPdf(url))
{
    File.WriteAllBytes("ironpdf.pdf", pdf.BinaryData);
}

// During a gradual migration, both libraries can sit behind one interface
IPdfConverter converter = new IronPdfAdapter();
File.WriteAllBytes("adapter.pdf", converter.ConvertUrlToPdf(url));

public interface IPdfConverter
{
    byte[] ConvertHtmlToPdf(string html);
    byte[] ConvertUrlToPdf(string url);
}

public class IronPdfAdapter : IPdfConverter
{
    private readonly ChromePdfRenderer _renderer = new ChromePdfRenderer();

    public byte[] ConvertHtmlToPdf(string html)
    {
        using var pdf = _renderer.RenderHtmlAsPdf(html);
        return pdf.BinaryData;
    }

    public byte[] ConvertUrlToPdf(string url)
    {
        using var pdf = _renderer.RenderUrlAsPdf(url);
        return pdf.BinaryData;
    }
}

public class EvoPdfAdapter : IPdfConverter
{
    private readonly HtmlToPdfConverter _converter = new HtmlToPdfConverter();
    
    public byte[] ConvertHtmlToPdf(string html)
    {
        return _converter.ConvertHtml(html, "");
    }
    
    public byte[] ConvertUrlToPdf(string url)
    {
        return _converter.ConvertUrl(url);
    }
}

// NuGet: Install-Package EvoPdf.HtmlToPdf  (EvoPdf Classic, Windows)
// NuGet: Install-Package IronPdf
using System.IO;
using EvoPdf;
using IronPdf;
using IronPdf.Rendering;

string url = "https://example.com/";

// EvoPdf pattern
HtmlToPdfConverter evoPdfConverter = new HtmlToPdfConverter();
evoPdfConverter.PdfDocumentOptions.PdfPageSize = PdfPageSize.A4;
File.WriteAllBytes("evopdf.pdf", evoPdfConverter.ConvertUrl(url));

// Equivalent IronPDF pattern
var ironPdfRenderer = new ChromePdfRenderer
{
    RenderingOptions = new ChromePdfRenderOptions
    {
        PaperSize = PdfPaperSize.A4
    }
};
using (var pdf = ironPdfRenderer.RenderUrlAsPdf(url))
{
    File.WriteAllBytes("ironpdf.pdf", pdf.BinaryData);
}

// During a gradual migration, both libraries can sit behind one interface
IPdfConverter converter = new IronPdfAdapter();
File.WriteAllBytes("adapter.pdf", converter.ConvertUrlToPdf(url));

public interface IPdfConverter
{
    byte[] ConvertHtmlToPdf(string html);
    byte[] ConvertUrlToPdf(string url);
}

public class IronPdfAdapter : IPdfConverter
{
    private readonly ChromePdfRenderer _renderer = new ChromePdfRenderer();

    public byte[] ConvertHtmlToPdf(string html)
    {
        using var pdf = _renderer.RenderHtmlAsPdf(html);
        return pdf.BinaryData;
    }

    public byte[] ConvertUrlToPdf(string url)
    {
        using var pdf = _renderer.RenderUrlAsPdf(url);
        return pdf.BinaryData;
    }
}

public class EvoPdfAdapter : IPdfConverter
{
    private readonly HtmlToPdfConverter _converter = new HtmlToPdfConverter();
    
    public byte[] ConvertHtmlToPdf(string html)
    {
        return _converter.ConvertHtml(html, "");
    }
    
    public byte[] ConvertUrlToPdf(string url)
    {
        return _converter.ConvertUrl(url);
    }
}