IronPDF vs Puppeteer Sharp: Kompleksowy przewodnik porównawczy bibliotek PDF C#

Czym jest IronPDF?

IronPDF is a .NET PDF library built for generating, editing, and manipulating PDF documents within managed C# code. Its embedded Chromium engine converts HTML — including full CSS3 and JavaScript — to PDF without requiring an external browser process. The API covers encryption, digital signatures, form filling, watermarking, and document merging, all accessible through a single NuGet package.

IronPDF supports .NET 9 and has .NET 10 compatibility in progress. Advanced PDF manipulation including content extraction and page stamping is also included.

What is Puppeteer Sharp?

Puppeteer Sharp is a .NET port of Google's popular Node.js Puppeteer library, maintained by Darío Kondratiuk. It provides a high-level API to control headless Chrome or Chromium browsers programmatically through the DevTools Protocol. While Puppeteer Sharp can generate PDFs, it's primarily designed as a browser automation tool that excels at web scraping, automated testing, and capturing screenshots.

The library operates by launching and controlling a headless browser instance, allowing developers to navigate web pages, interact with elements, and export content in various formats including PDF. According to recent benchmarks, Puppeteer Sharp offers performance advantages for simple HTML rendering but requires more complex setup compared to dedicated PDF libraries. Teams evaluating IronPDF for their PDF generation requirements can access a [free 30-day trial](trial-license.

Obsługa wielu platform przez IronPDF

IronPDF provides broad cross-platform compatibility, supporting deployment across a wide range of environments. The library works on:

• .NET versions:

  • .NET 10, 9, 8, 7, 6, 5 (with .NET 10 readiness)
  • .NET Core 3.1+
  • .NET Standard 2.0+
  • .NET Framework 4.6.2+
  • Pełna obsługa języków C#, VB.NET i F#

• Systemy operacyjne & Environments:

  • Windows (including Windows Server)
  • Linux (all major distributions)
  • macOS (Intel i Apple Silicon)
  • Docker containers
  • Cloud platforms: Azure, AWS Lambda
• Development Tools:
  • Microsoft Visual Studio
  • JetBrains Rider & ReSharper
  • Visual Studio Code

IronPDF's native cross-platform support means no additional packages or configuration needed for different environments. The library automatically detects and optimizes for the target platform, as noted in the compatibility milestone update.

Puppeteer Sharp Wieloplatformowe Support

Puppeteer Sharp offers cross-platform compatibility with some important considerations:

• .NET versions:

  • .NET 8 version available
  • .NET Standard 2.0 library
  • .NET Framework 4.6.1+
  • .NET Core 2.0 or greater

• Systemy operacyjne:

  • Windows (full support)
  • Linux (requires X-server, may need troubleshooting)
  • macOS (standard support)
  • Docker (with Chrome dependencies)
• Browser Requirements:
  • Requires downloading Chromium binaries (~170MB)
  • Supports Chrome, Chromium, and Firefox browsers
  • Headless and headful modes available

According to the official documentation, Linux users may encounter issues running Chrome and need to consult the troubleshooting guide. The library requires managing browser downloads and lifecycle, adding complexity to deployment.

Funkcje IronPDF

IronPDF provides a comprehensive suite of PDF manipulation tools:

• PDF Generation & Conversion:

  • HTML to PDF conversion with full CSS3, JavaScript, and web font support
  • Convert from multiple formats: DOCX, images, RTF, and Markdown
  • URL to PDF with authentication support
  • ASPX and MVC view rendering

• Security Features:

  • 256-bit AES encryption
  • Password protection with user/owner permissions
  • Digital signatures with certificate support
  • Permission management (print, copy, edit restrictions)

• Możliwości edycji plików PDF:

  • Łączenie i dzielenie plików PDF
  • Dodaj nagłówki, stopki i numery stron
  • Znak wodny za pomocą HTML/CSS
  • Tworzenie i wypełnianie formularzy
  • Tekst i stemple graficzne
  • Kompresja plików PDF
• Zaawansowane funkcje:
  • Zgodność z formatem PDF/A do celów archiwizacji
  • Funkcje OCR (dzięki integracji z IronOCR)
  • Generowanie kodów kreskowych
  • Obsługa wielowątkowości

Funkcje Puppeteer Sharp

Puppeteer Sharp koncentruje się na automatyzacji przeglądarek z opcją wyjściową w formacie PDF:

• Generowanie plików PDF:

  • Konwersja HTML do PDF za pomocą funkcji drukowania w przeglądarce
  • Niestandardowe rozmiary stron i marginesy
  • Nagłówki i stopki (ograniczone formatowanie)
  • Kontrola okna wyświetlania dla układów responsywnych

• Automatyzacja przeglądarki:

  • Pełna kontrola nad bezinterfejsową przeglądarką Chrome/Chromium
  • Wykonanie kodu JavaScript i oczekiwanie
  • Wypełnianie formularzy i interakcja z interfejsem użytkownika
  • Przechwytywanie żądań sieciowych

• Możliwości zrzutu ekranu:

  • Zrzuty całej strony lub konkretnych elementów
  • Różne formaty obrazów (PNG, JPG)
  • Manipulacja oknem wyświetlania
• Ograniczenia projektowe:
  • Edycja plików PDF wykracza poza obecny zakres działania Puppeteer Sharp
  • Opcje szyfrowania i zabezpieczeń nie są uwzględnione
  • Obsługa podpisu cyfrowego nie wchodzi w zakres jego funkcji
  • Narzędzia do tworzenia formularzy nie są udostępniane
  • Zespoły zajmujące się przetwarzaniem plików PDF zazwyczaj dodają osobne biblioteki

Jak zauważa API Template, "Puppeteer Sharp to port popularnej biblioteki Puppeteer na język C#, używany do automatyzacji bezinterfejsowej przeglądarki Chrome". W tym artykule zobaczymy, jak używać Puppeteer Sharp do generowania plików PDF z szablonów HTML.

Porównanie konwersji HTML do PDF

Przykład IronPDF:

using IronPdf;

// Initialize the Chrome renderer
var renderer = new ChromePdfRenderer();

// Configure rendering options for professional output
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop = 40;
renderer.RenderingOptions.MarginBottom = 40;
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;

// Convert HTML string to PDF
var pdf = renderer.RenderHtmlAsPdf(@"
    <html>
        <head>
            <style>
                body { font-family: Arial, sans-serif; }
                h1 { color: #2e6da4; }
                .invoice-header { background-color: #f5f5f5; padding: 20px; }
            </style>
        </head>
        <body>
            <div class='invoice-header'>
                <h1>Invoice #12345</h1>
                <p>Generated on: " + DateTime.Now.ToString("yyyy-MM-dd") + @"</p>
            </div>
        </body>
    </html>");

// Save the PDF
pdf.SaveAs("invoice.pdf");

using IronPdf;

// Initialize the Chrome renderer
var renderer = new ChromePdfRenderer();

// Configure rendering options for professional output
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop = 40;
renderer.RenderingOptions.MarginBottom = 40;
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;

// Convert HTML string to PDF
var pdf = renderer.RenderHtmlAsPdf(@"
    <html>
        <head>
            <style>
                body { font-family: Arial, sans-serif; }
                h1 { color: #2e6da4; }
                .invoice-header { background-color: #f5f5f5; padding: 20px; }
            </style>
        </head>
        <body>
            <div class='invoice-header'>
                <h1>Invoice #12345</h1>
                <p>Generated on: " + DateTime.Now.ToString("yyyy-MM-dd") + @"</p>
            </div>
        </body>
    </html>");

// Save the PDF
pdf.SaveAs("invoice.pdf");

Imports IronPdf

' Initialize the Chrome renderer
Private renderer = New ChromePdfRenderer()

' Configure rendering options for professional output
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
renderer.RenderingOptions.MarginTop = 40
renderer.RenderingOptions.MarginBottom = 40
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print

' Convert HTML string to PDF
Dim pdf = renderer.RenderHtmlAsPdf("
    <html>
        <head>
            <style>
                body { font-family: Arial, sans-serif; }
                h1 { color: #2e6da4; }
                .invoice-header { background-color: #f5f5f5; padding: 20px; }
            </style>
        </head>
        <body>
            <div class='invoice-header'>
                <h1>Invoice #12345</h1>
                <p>Generated on: " & DateTime.Now.ToString("yyyy-MM-dd") & "</p>
            </div>
        </body>
    </html>")

' Save the PDF
pdf.SaveAs("invoice.pdf")

Ten przykład IronPDF ilustruje proste podejście biblioteki. The ChromePdfRenderer class handles all the complexity of HTML rendering internally. Główne zalety to:

• Single method call for conversion (RenderHtmlAsPdf)
• Wbudowana obsługa typów mediów CSS
• Nie jest wymagane zarządzanie cyklem życia przeglądarki
• Natychmiastowa dostępność bez konieczności pobierania zewnętrznych zależności

Przykład Puppeteer Sharp:

using PuppeteerSharp;

// Download Chromium if not already present
await new BrowserFetcher().DownloadAsync();

// Launch browser instance
var browser = await Puppeteer.LaunchAsync(new LaunchOptions
{
    Headless = true,
    Args = new[] { "--no-sandbox", "--disable-setuid-sandbox" }
});

try
{
    // Create new page
    var page = await browser.NewPageAsync();

    // Set content
    await page.SetContentAsync(@"
        <html>
            <head>
                <style>
                    body { font-family: Arial, sans-serif; }
                    h1 { color: #2e6da4; }
                    .invoice-header { background-color: #f5f5f5; padding: 20px; }
                </style>
            </head>
            <body>
                <div class='invoice-header'>
                    <h1>Invoice #12345</h1>
                    <p>Generated on: " + DateTime.Now.ToString("yyyy-MM-dd") + @"</p>
                </div>
            </body>
        </html>");

    // Wait for content to load
    await page.WaitForSelectorAsync(".invoice-header");

    // Generate PDF
    await page.PdfAsync("invoice.pdf", new PdfOptions
    {
        Format = PaperFormat.A4,
        MarginOptions = new MarginOptions
        {
            Top = "40px",
            Bottom = "40px",
            Left = "40px",
            Right = "40px"
        }
    });
}
finally
{
    // Clean up browser instance
    await browser.CloseAsync();
}

using PuppeteerSharp;

// Download Chromium if not already present
await new BrowserFetcher().DownloadAsync();

// Launch browser instance
var browser = await Puppeteer.LaunchAsync(new LaunchOptions
{
    Headless = true,
    Args = new[] { "--no-sandbox", "--disable-setuid-sandbox" }
});

try
{
    // Create new page
    var page = await browser.NewPageAsync();

    // Set content
    await page.SetContentAsync(@"
        <html>
            <head>
                <style>
                    body { font-family: Arial, sans-serif; }
                    h1 { color: #2e6da4; }
                    .invoice-header { background-color: #f5f5f5; padding: 20px; }
                </style>
            </head>
            <body>
                <div class='invoice-header'>
                    <h1>Invoice #12345</h1>
                    <p>Generated on: " + DateTime.Now.ToString("yyyy-MM-dd") + @"</p>
                </div>
            </body>
        </html>");

    // Wait for content to load
    await page.WaitForSelectorAsync(".invoice-header");

    // Generate PDF
    await page.PdfAsync("invoice.pdf", new PdfOptions
    {
        Format = PaperFormat.A4,
        MarginOptions = new MarginOptions
        {
            Top = "40px",
            Bottom = "40px",
            Left = "40px",
            Right = "40px"
        }
    });
}
finally
{
    // Clean up browser instance
    await browser.CloseAsync();
}

Imports PuppeteerSharp

' Download Chromium if not already present
Await (New BrowserFetcher()).DownloadAsync()

' Launch browser instance
Dim browser = Await Puppeteer.LaunchAsync(New LaunchOptions With {
	.Headless = True,
	.Args = { "--no-sandbox", "--disable-setuid-sandbox" }
})

Try
	' Create new page
	Dim page = Await browser.NewPageAsync()

	' Set content
	Await page.SetContentAsync("
        <html>
            <head>
                <style>
                    body { font-family: Arial, sans-serif; }
                    h1 { color: #2e6da4; }
                    .invoice-header { background-color: #f5f5f5; padding: 20px; }
                </style>
            </head>
            <body>
                <div class='invoice-header'>
                    <h1>Invoice #12345</h1>
                    <p>Generated on: " & DateTime.Now.ToString("yyyy-MM-dd") & "</p>
                </div>
            </body>
        </html>")

	' Wait for content to load
	Await page.WaitForSelectorAsync(".invoice-header")

	' Generate PDF
	Await page.PdfAsync("invoice.pdf", New PdfOptions With {
		.Format = PaperFormat.A4,
		.MarginOptions = New MarginOptions With {
			.Top = "40px",
			.Bottom = "40px",
			.Left = "40px",
			.Right = "40px"
		}
	})
Finally
	' Clean up browser instance
	Await browser.CloseAsync()
End Try

Podejście Puppeteer Sharp wymaga więcej konfiguracji:

• Pobieranie i zarządzanie przeglądarką (~170 MB Chromium)
• Wyraźne czyszczenie zasobów za pomocą try/finally
• Ręczne warunki oczekiwania na treści dynamiczne
• Specyfikacje marginesów oparte na ciągach znaków

Zgodnie z dyskusjami na Stack Overflow programiści często napotykają problemy związane z rozmiarem stron i spójnością renderowania w Puppeteer Sharp.

Praca z treścią dynamiczną

IronPDF z JavaScript:

using IronPdf;

var renderer = new ChromePdfRenderer();

// Configure JavaScript execution
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.RenderDelay = 2000; // Wait 2 seconds for JS

// Render a page with dynamic charts
var pdf = renderer.RenderUrlAsPdf("https://example.com/dashboard");

// Apply security settings
pdf.SecuritySettings.UserPassword = "user123";
pdf.SecuritySettings.OwnerPassword = "owner456";
pdf.SecuritySettings.AllowUserPrinting = IronPdf.Security.PdfPrintSecurity.NoPrint;

pdf.SaveAs("secure-dashboard.pdf");

using IronPdf;

var renderer = new ChromePdfRenderer();

// Configure JavaScript execution
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.RenderDelay = 2000; // Wait 2 seconds for JS

// Render a page with dynamic charts
var pdf = renderer.RenderUrlAsPdf("https://example.com/dashboard");

// Apply security settings
pdf.SecuritySettings.UserPassword = "user123";
pdf.SecuritySettings.OwnerPassword = "owner456";
pdf.SecuritySettings.AllowUserPrinting = IronPdf.Security.PdfPrintSecurity.NoPrint;

pdf.SaveAs("secure-dashboard.pdf");

Imports IronPdf

Private renderer = New ChromePdfRenderer()

' Configure JavaScript execution
renderer.RenderingOptions.EnableJavaScript = True
renderer.RenderingOptions.RenderDelay = 2000 ' Wait 2 seconds for JS

' Render a page with dynamic charts
Dim pdf = renderer.RenderUrlAsPdf("https://example.com/dashboard")

' Apply security settings
pdf.SecuritySettings.UserPassword = "user123"
pdf.SecuritySettings.OwnerPassword = "owner456"
pdf.SecuritySettings.AllowUserPrinting = IronPdf.Security.PdfPrintSecurity.NoPrint

pdf.SaveAs("secure-dashboard.pdf")

Podejście IronPDF do treści dynamicznych koncentruje się na prostocie. The RenderDelay option provides a straightforward way to wait for JavaScript execution and rendering. Dodatkowe korzyści:

• Funkcje bezpieczeństwa zintegrowane bezpośrednio
• Nie ma potrzeby zarządzania stanami przeglądarki
• Spójne odwzorowanie w różnych środowiskach

W przypadku bardziej złożonych scenariuszy JavaScript, IronPDF oferuje klasę WaitFor do precyzyjnej kontroli czasu.

Puppeteer Sharp z dynamiczną treścią:

using PuppeteerSharp;

var browser = await Puppeteer.LaunchAsync(new LaunchOptions { Headless = true });
var page = await browser.NewPageAsync();

// Navigate to page
await page.GoToAsync("https://example.com/dashboard", new NavigationOptions
{
    WaitUntil = new[] { WaitUntilNavigation.Networkidle0 }
});

// Execute custom JavaScript
await page.EvaluateExpressionAsync(@"
    // Trigger chart rendering
    document.dispatchEvent(new Event('load-charts'));
");

// Wait for specific element
await page.WaitForSelectorAsync(".chart-container", new WaitForSelectorOptions
{
    Visible = true,
    Timeout = 30000
});

// Generate PDF (no built-in security features)
await page.PdfAsync("dashboard.pdf");

await browser.CloseAsync();

using PuppeteerSharp;

var browser = await Puppeteer.LaunchAsync(new LaunchOptions { Headless = true });
var page = await browser.NewPageAsync();

// Navigate to page
await page.GoToAsync("https://example.com/dashboard", new NavigationOptions
{
    WaitUntil = new[] { WaitUntilNavigation.Networkidle0 }
});

// Execute custom JavaScript
await page.EvaluateExpressionAsync(@"
    // Trigger chart rendering
    document.dispatchEvent(new Event('load-charts'));
");

// Wait for specific element
await page.WaitForSelectorAsync(".chart-container", new WaitForSelectorOptions
{
    Visible = true,
    Timeout = 30000
});

// Generate PDF (no built-in security features)
await page.PdfAsync("dashboard.pdf");

await browser.CloseAsync();

Imports PuppeteerSharp

Private browser = await Puppeteer.LaunchAsync(New LaunchOptions With {.Headless = True})
Private page = await browser.NewPageAsync()

' Navigate to page
Await page.GoToAsync("https://example.com/dashboard", New NavigationOptions With {
	.WaitUntil = { WaitUntilNavigation.Networkidle0 }
})

' Execute custom JavaScript
Await page.EvaluateExpressionAsync("
    // Trigger chart rendering
    document.dispatchEvent(new Event('load-charts'));
")

' Wait for specific element
Await page.WaitForSelectorAsync(".chart-container", New WaitForSelectorOptions With {
	.Visible = True,
	.Timeout = 30000
})

' Generate PDF (no built-in security features)
Await page.PdfAsync("dashboard.pdf")

Await browser.CloseAsync()

Puppeteer Sharp doskonale radzi sobie ze złożonymi interakcjami z przeglądarką:

• Precyzyjna kontrola nad nawigacją po stronach
• Niestandardowe wykonywanie kodu JavaScript
• Elastyczne warunki oczekiwania
• Bezpośrednia manipulacja DOM

Funkcje bezpieczeństwa, takie jak szyfrowanie i ochrona hasłem, wykraczają poza zakres Puppeteer Sharp, więc zespoły potrzebujące tych możliwości powinny zintegrować oddzielną bibliotekę PDF, jak zaznaczono w oficjalnej dokumentacji.

Zaawansowane operacje na plikach PDF

IronPDF – Kompleksowy obieg dokumentów:

using IronPdf;
using IronPdf.Signing;

// Create initial PDF from HTML template
var renderer = new ChromePdfRenderer();
var invoice = renderer.RenderHtmlFileAsPdf("invoice-template.html");

// Add watermark
invoice.ApplyWatermark("<h2 style='color:red; opacity:0.5'>CONFIDENTIAL</h2>", 
    30, IronPdf.Editing.VerticalAlignment.Middle, 
    IronPdf.Editing.HorizontalAlignment.Center);

// Merge with terms and conditions
var terms = PdfDocument.FromFile("terms.pdf");
var combined = PdfDocument.Merge(invoice, terms);

// Add digital signature
var signature = new PdfSignature("certificate.pfx", "password");
combined.Sign(signature);

// Set metadata
combined.MetaData.Author = "Accounting Department";
combined.MetaData.Title = "Invoice #12345";
combined.MetaData.CreationDate = DateTime.Now;

// Compress and save
combined.CompressImages(90);
combined.SaveAs("final-invoice.pdf");

using IronPdf;
using IronPdf.Signing;

// Create initial PDF from HTML template
var renderer = new ChromePdfRenderer();
var invoice = renderer.RenderHtmlFileAsPdf("invoice-template.html");

// Add watermark
invoice.ApplyWatermark("<h2 style='color:red; opacity:0.5'>CONFIDENTIAL</h2>", 
    30, IronPdf.Editing.VerticalAlignment.Middle, 
    IronPdf.Editing.HorizontalAlignment.Center);

// Merge with terms and conditions
var terms = PdfDocument.FromFile("terms.pdf");
var combined = PdfDocument.Merge(invoice, terms);

// Add digital signature
var signature = new PdfSignature("certificate.pfx", "password");
combined.Sign(signature);

// Set metadata
combined.MetaData.Author = "Accounting Department";
combined.MetaData.Title = "Invoice #12345";
combined.MetaData.CreationDate = DateTime.Now;

// Compress and save
combined.CompressImages(90);
combined.SaveAs("final-invoice.pdf");

Imports IronPdf
Imports IronPdf.Signing

' Create initial PDF from HTML template
Private renderer = New ChromePdfRenderer()
Private invoice = renderer.RenderHtmlFileAsPdf("invoice-template.html")

' Add watermark
invoice.ApplyWatermark("<h2 style='color:red; opacity:0.5'>CONFIDENTIAL</h2>", 30, IronPdf.Editing.VerticalAlignment.Middle, IronPdf.Editing.HorizontalAlignment.Center)

' Merge with terms and conditions
Dim terms = PdfDocument.FromFile("terms.pdf")
Dim combined = PdfDocument.Merge(invoice, terms)

' Add digital signature
Dim signature = New PdfSignature("certificate.pfx", "password")
combined.Sign(signature)

' Set metadata
combined.MetaData.Author = "Accounting Department"
combined.MetaData.Title = "Invoice #12345"
combined.MetaData.CreationDate = DateTime.Now

' Compress and save
combined.CompressImages(90)
combined.SaveAs("final-invoice.pdf")

Ten przykład pokazuje wszechstronne możliwości IronPDF w zakresie obróbki plików PDF:

• Generowanie na podstawie szablonów z plików HTML
• Znak wodny z kontrolą stylów CSS
• Łączenie dokumentów w wieloczęściowe pliki PDF
• Podpisy cyfrowe do uwierzytelniania
• Zarządzanie metadanymi właściwości dokumentów
• Kompresja obrazów w celu zmniejszenia rozmiaru plików

Funkcje stemplowania i obsługa podpisów cyfrowych sprawiają, że IronPDF nadaje się do obsługi przepływu dokumentów w Enterprise.

Puppeteer Sharp – automatyzacja przeglądarek:

using PuppeteerSharp;

var browser = await Puppeteer.LaunchAsync(new LaunchOptions 
{ 
    Headless = false, // Show browser for debugging
    SlowMo = 50 // Slow down actions
});

var page = await browser.NewPageAsync();

// Navigate to web application
await page.GoToAsync("https://app.example.com/login");

// Automate login
await page.TypeAsync("#username", "user@example.com");
await page.TypeAsync("#password", "password123");
await page.ClickAsync("#login-button");

// Wait for dashboard
await page.WaitForNavigationAsync();

// Take screenshot for documentation
await page.ScreenshotAsync("dashboard-screenshot.png", new ScreenshotOptions
{
    FullPage = true,
    Type = ScreenshotType.Png
});

// Generate report PDF
await page.ClickAsync("#generate-report");
await page.WaitForSelectorAsync(".report-ready");

// Save the generated report
await page.PdfAsync("automated-report.pdf", new PdfOptions
{
    DisplayHeaderFooter = true,
    HeaderTemplate = "<div style='font-size:10px;'>Report Header</div>",
    FooterTemplate = "<div style='font-size:10px;'>Page <span class='pageNumber'></span></div>",
    Format = PaperFormat.A4
});

await browser.CloseAsync();

using PuppeteerSharp;

var browser = await Puppeteer.LaunchAsync(new LaunchOptions 
{ 
    Headless = false, // Show browser for debugging
    SlowMo = 50 // Slow down actions
});

var page = await browser.NewPageAsync();

// Navigate to web application
await page.GoToAsync("https://app.example.com/login");

// Automate login
await page.TypeAsync("#username", "user@example.com");
await page.TypeAsync("#password", "password123");
await page.ClickAsync("#login-button");

// Wait for dashboard
await page.WaitForNavigationAsync();

// Take screenshot for documentation
await page.ScreenshotAsync("dashboard-screenshot.png", new ScreenshotOptions
{
    FullPage = true,
    Type = ScreenshotType.Png
});

// Generate report PDF
await page.ClickAsync("#generate-report");
await page.WaitForSelectorAsync(".report-ready");

// Save the generated report
await page.PdfAsync("automated-report.pdf", new PdfOptions
{
    DisplayHeaderFooter = true,
    HeaderTemplate = "<div style='font-size:10px;'>Report Header</div>",
    FooterTemplate = "<div style='font-size:10px;'>Page <span class='pageNumber'></span></div>",
    Format = PaperFormat.A4
});

await browser.CloseAsync();

Imports PuppeteerSharp

Private browser = await Puppeteer.LaunchAsync(New LaunchOptions With {
	.Headless = False,
	.SlowMo = 50
})

Private page = await browser.NewPageAsync()

' Navigate to web application
Await page.GoToAsync("https://app.example.com/login")

' Automate login
Await page.TypeAsync("#username", "user@example.com")
Await page.TypeAsync("#password", "password123")
Await page.ClickAsync("#login-button")

' Wait for dashboard
Await page.WaitForNavigationAsync()

' Take screenshot for documentation
Await page.ScreenshotAsync("dashboard-screenshot.png", New ScreenshotOptions With {
	.FullPage = True,
	.Type = ScreenshotType.Png
})

' Generate report PDF
Await page.ClickAsync("#generate-report")
Await page.WaitForSelectorAsync(".report-ready")

' Save the generated report
Await page.PdfAsync("automated-report.pdf", New PdfOptions With {
	.DisplayHeaderFooter = True,
	.HeaderTemplate = "<div style='font-size:10px;'>Report Header</div>",
	.FooterTemplate = "<div style='font-size:10px;'>Page <span class='pageNumber'></span></div>",
	.Format = PaperFormat.A4
})

Await browser.CloseAsync()

Siła Puppeteer Sharp leży w scenariuszach automatyzacji przeglądarek:

• Automatyczne logowanie i nawigacja
• Zrzut ekranu w dowolnym momencie
• Interakcja z aplikacjami internetowymi
• Dynamiczne generowanie raportów z aplikacji internetowych

Jak zauważa ZenRows, "Puppeteer Sharp może symulować różne automatyczne interakcje użytkownika". Obejmują one ruchy myszy, czasy oczekiwania i inne elementy.

IronPDF Performance

IronPDF jest zoptymalizowany do operacji na plikach PDF dzięki kilku funkcjom zwiększającym wydajność:

• Zarządzanie pamięcią:

  • Efektywne wykorzystanie pamięci dzięki mechanizmowi zbierania śmieci w .NET
  • Optymalizacja przetwarzania wsadowego
  • Obsługa strumieniowania dużych dokumentów

• Wielowątkowość:

  • Pełna obsługa async/await
  • Funkcje równoległego generowania plików PDF
  • Operacje bezpieczne dla wątków
• Szybkość renderowania:
  • Średnio 0,8–1,2 sekundy dla typowego pliku HTML do PDF
  • Wbudowany silnik Chrome eliminuje obciążenie związane z procesami zewnętrznymi
  • Mechanizmy buforowania dla powtarzających się operacji

Zgodnie z przewodnikami dotyczącymi optymalizacji wydajności, początkowe renderowanie IronPDF może być wolniejsze ze względu na inicjalizację silnika, ale kolejne operacje są wysoce zoptymalizowane.

Puppeteer Sharp Performance

Puppeteer Sharp's performance characteristics differ due to its architecture:

• Browser Overhead:

  • ~170MB Chromium download required
  • 150-200MB RAM per browser instance
  • Browser launch time adds 1-3 seconds

• Szybkość renderowania:

  • 0.3-0.5 seconds for simple HTML
  • Performance can decrease with multiple concurrent instances
  • Resource-intensive for concurrent operations
• Optimization Strategies:
  • Browser instance reuse recommended
  • Connection pooling for multiple PDFs
  • Headless mode reduces overhead

Benchmark tests show Puppeteer can be faster for simple HTML but requires careful resource management for production use.

IronPDF Pricing Structure

IronPDF offers flexible commercial licensing options:

• License Tiers (pricing as of 2025):

  • Lite License: $799 - 1 developer, 1 location, 1 project
  • Plus License: $1,199 - 3 developers, 3 locations, 3 projects
  • Professional License: $2,399 - 10 developers, 10 locations, 10 projects
  • Unlimited License: Custom pricing for larger teams

• Additional Options:

  • Royalty-free redistribution: +$2,399
  • SaaS/OEM licensing available
  • Iron Suite: $1,498 for 9 products
  • 30-day money-back guarantee
• Support & Updates:
  • One year of support and updates included
  • Extended support: $999/year or $1,999 for 5 years
  • 24/5 engineer support with all licenses

Puppeteer Sharp Licensing

Puppeteer Sharp uses the MIT License:

• Cost: Completely free
• Commercial Use: Allowed without restrictions
• Support: Community-based through GitHub
• Updates: Open-source community driven

While the license itself is free, teams should factor in total project costs:

• Support relies on the open-source community rather than a dedicated team
• Infrastructure management falls on your team
• Advanced PDF features require integrating additional libraries
• Troubleshooting often depends on community forums and self-diagnosis

As discussed on Reddit's dotnet community, the choice often depends on whether professional support and advanced features justify the investment.

Beyond license cost, total project cost includes the developer hours spent managing browser lifecycle code, integrating separate libraries for encryption and digital signatures, and troubleshooting deployment issues across environments without dedicated support. Dla zespołów oceniających koszty w perspektywie wieloletniego cyklu życia projektu koszty integracji i utrzymania często przewyższają różnicę między licencjami open source a komercyjnymi.

IronPDF Dokumentacja & Support

IronPDF provides comprehensive professional resources:

• Dokumentacja:

  • Extensive API reference
  • 50+ tutorials covering common scenarios
  • 200+ code examples
  • Video tutorials on YouTube
  • Regular documentation updates

• Support Channels:

  • 24/5 live engineer support
  • Email and phone support (license dependent)
  • Screen-sharing sessions for complex issues
  • Community forum
  • Slack channel for discussions
• Learning Resources:
  • Getting started guides
  • Troubleshooting section
  • Best practices documentation
  • Migration guides from other libraries

Puppeteer Sharp Dokumentacja & Support

Puppeteer Sharp relies on community resources:

• Dokumentacja:

  • API documentation
  • GitHub README and wiki
  • Code examples in repository
  • Links to original Puppeteer docs

• Opcje wsparcia:

  • GitHub issues for bug reports
  • Community discussions
  • Stack Overflow questions
  • No official support channel
• Considerations:
  • Dokumentacja updates follow the open-source contribution cycle
  • Community members drive most content additions
  • Troubleshooting guidance has a narrower surface area than commercial libraries
  • Some examples reflect earlier API versions

The developer blog provides useful technical insights, though posts follow the maintainer's schedule rather than a fixed cadence.

Kiedy wybrać IronPDF:

• Building enterprise applications requiring secure, professional PDFs
• Need comprehensive PDF features beyond basic generation
• Want minimal code complexity with straightforward APIs
• Require professional support and documentation
• Working with multiple PDF formats (DOCX, images, etc.)
• Need built-in security features like encryption and signatures
• Deploying across various platforms without compatibility concerns
• Value time-to-market over initial cost

IronPDF excels in scenarios like:

• Invoice and report generation
• Document management systems
• Compliance-required documentation
• Multi-format document processing
• High-volume PDF operations

Choose Puppeteer Sharp When:

• Primary focus is browser automation with PDF as secondary
• Budget constraints prevent commercial licenses
• Need web scraping capabilities alongside PDF generation
• Comfortable managing browser infrastructure
• Simple PDF requirements without advanced features
• Have existing Puppeteer knowledge from Node.js
• Building testing frameworks or automation tools

Puppeteer Sharp works well for:

• Automated testing with PDF reports
• Web scraping with PDF export
• Simple HTML to PDF conversion
• Screenshot capture workflows
• Browser-based automation tasks

Real-World Recommendations

Based on extensive comparison analyses and developer feedback, here are practical recommendations:

1. For Production Applications: IronPDF's reliability, support, and features justify the investment
2. For Prototypes: Puppeteer Sharp's free license allows quick experimentation
3. For Complex PDFs: IronPDF's advanced features save development time
4. For Browser Testing: Puppeteer Sharp's automation capabilities are unmatched

IronPDF: Simplified Bootstrap Rendering

IronPDF's PDF-focused API makes rendering Bootstrap layouts straightforward with minimal code:

• One-line conversion: No browser lifecycle management required
• Built-in optimization: Automatic handling of CSS/JavaScript loading
• Bootstrap 5 ready: Full support for Bootstrap homepage and templates
• Production-ready: Includes security, compression, and enterprise features

Code Example: IronPDF Bootstrap Rendering

using IronPdf;

// Simple, direct Bootstrap rendering
var renderer = new ChromePdfRenderer();

string bootstrapContent = @"
<!DOCTYPE html>
<html>
<head>
    <link href='https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css' rel='stylesheet'>
</head>
<body>
    <div class='container mt-5'>
        <div class='row'>
            <div class='col-md-4 mb-4'>
                <div class='card shadow'>
                    <div class='card-body'>
                        <h5 class='card-title'>Quick Start</h5>
                        <p class='card-text'>Render Bootstrap with one method call.</p>
                        <a href='#' class='btn btn-primary'>Learn More</a>
                    </div>
                </div>
            </div>

        </div>
    </div>
</body>
</html>";

// Single method call - no browser management
var pdf = renderer.RenderHtmlAsPdf(bootstrapContent);
pdf.SaveAs("bootstrap-layout.pdf");

using IronPdf;

// Simple, direct Bootstrap rendering
var renderer = new ChromePdfRenderer();

string bootstrapContent = @"
<!DOCTYPE html>
<html>
<head>
    <link href='https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css' rel='stylesheet'>
</head>
<body>
    <div class='container mt-5'>
        <div class='row'>
            <div class='col-md-4 mb-4'>
                <div class='card shadow'>
                    <div class='card-body'>
                        <h5 class='card-title'>Quick Start</h5>
                        <p class='card-text'>Render Bootstrap with one method call.</p>
                        <a href='#' class='btn btn-primary'>Learn More</a>
                    </div>
                </div>
            </div>

        </div>
    </div>
</body>
</html>";

// Single method call - no browser management
var pdf = renderer.RenderHtmlAsPdf(bootstrapContent);
pdf.SaveAs("bootstrap-layout.pdf");

Imports IronPdf

' Simple, direct Bootstrap rendering
Dim renderer As New ChromePdfRenderer()

Dim bootstrapContent As String = "
<!DOCTYPE html>
<html>
<head>
    <link href='https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css' rel='stylesheet'>
</head>
<body>
    <div class='container mt-5'>
        <div class='row'>
            <div class='col-md-4 mb-4'>
                <div class='card shadow'>
                    <div class='card-body'>
                        <h5 class='card-title'>Quick Start</h5>
                        <p class='card-text'>Render Bootstrap with one method call.</p>
                        <a href='#' class='btn btn-primary'>Learn More</a>
                    </div>
                </div>
            </div>

        </div>
    </div>
</body>
</html>"

' Single method call - no browser management
Dim pdf = renderer.RenderHtmlAsPdf(bootstrapContent)
pdf.SaveAs("bootstrap-layout.pdf")

Puppeteer Sharp: Browser-Based Bootstrap Rendering

Puppeteer Sharp requires explicit browser management and lifecycle control for Bootstrap rendering:

Code Example: Puppeteer Sharp Bootstrap Rendering

using PuppeteerSharp;

// Download Chromium if needed (one-time ~170MB)
await new BrowserFetcher().DownloadAsync();

// Launch browser instance
var browser = await Puppeteer.LaunchAsync(new LaunchOptions { Headless = true });

try
{
    var page = await browser.NewPageAsync();

    // Set Bootstrap content
    await page.SetContentAsync(@"
    <!DOCTYPE html>
    <html>
    <head>
        <link href='https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css' rel='stylesheet'>
    </head>
    <body>
        <div class='container mt-5'>
            <div class='row'>
                <div class='col-md-4 mb-4'>
                    <div class='card shadow'>
                        <div class='card-body'>
                            <h5 class='card-title'>Quick Start</h5>
                            <p class='card-text'>Render Bootstrap with browser automation.</p>
                            <a href='#' class='btn btn-primary'>Learn More</a>
                        </div>
                    </div>
                </div>
            </div>
        </div>
    </body>
    </html>");

    // Wait for Bootstrap CSS to load
    await page.WaitForNetworkIdleAsync();

    // Generate PDF
    await page.PdfAsync("bootstrap-layout.pdf");
}
finally
{
    // Required cleanup
    await browser.CloseAsync();
}

using PuppeteerSharp;

// Download Chromium if needed (one-time ~170MB)
await new BrowserFetcher().DownloadAsync();

// Launch browser instance
var browser = await Puppeteer.LaunchAsync(new LaunchOptions { Headless = true });

try
{
    var page = await browser.NewPageAsync();

    // Set Bootstrap content
    await page.SetContentAsync(@"
    <!DOCTYPE html>
    <html>
    <head>
        <link href='https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css' rel='stylesheet'>
    </head>
    <body>
        <div class='container mt-5'>
            <div class='row'>
                <div class='col-md-4 mb-4'>
                    <div class='card shadow'>
                        <div class='card-body'>
                            <h5 class='card-title'>Quick Start</h5>
                            <p class='card-text'>Render Bootstrap with browser automation.</p>
                            <a href='#' class='btn btn-primary'>Learn More</a>
                        </div>
                    </div>
                </div>
            </div>
        </div>
    </body>
    </html>");

    // Wait for Bootstrap CSS to load
    await page.WaitForNetworkIdleAsync();

    // Generate PDF
    await page.PdfAsync("bootstrap-layout.pdf");
}
finally
{
    // Required cleanup
    await browser.CloseAsync();
}

Imports PuppeteerSharp

' Download Chromium if needed (one-time ~170MB)
Await (New BrowserFetcher()).DownloadAsync()

' Launch browser instance
Dim browser = Await Puppeteer.LaunchAsync(New LaunchOptions With {.Headless = True})

Try
    Dim page = Await browser.NewPageAsync()

    ' Set Bootstrap content
    Await page.SetContentAsync("
    <!DOCTYPE html>
    <html>
    <head>
        <link href='https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css' rel='stylesheet'>
    </head>
    <body>
        <div class='container mt-5'>
            <div class='row'>
                <div class='col-md-4 mb-4'>
                    <div class='card shadow'>
                        <div class='card-body'>
                            <h5 class='card-title'>Quick Start</h5>
                            <p class='card-text'>Render Bootstrap with browser automation.</p>
                            <a href='#' class='btn btn-primary'>Learn More</a>
                        </div>
                    </div>
                </div>
            </div>
        </div>
    </body>
    </html>")

    ' Wait for Bootstrap CSS to load
    Await page.WaitForNetworkIdleAsync()

    ' Generate PDF
    Await page.PdfAsync("bootstrap-layout.pdf")
Finally
    ' Required cleanup
    Await browser.CloseAsync()
End Try

Key Differences for Bootstrap Development

Complexity:

• IronPDF: 4 lines of code (initialize, render, save)
• Puppeteer Sharp: 15+ lines (download, launch, page management, cleanup)

Features:

• IronPDF: Built-in security, compression, watermarking, signatures
• Puppeteer Sharp: Teams needing PDF manipulation add separate libraries

Deployment:

• IronPDF: Self-contained, no external dependencies
• Puppeteer Sharp: Requires Chromium binaries (~170MB) and browser management

Both libraries render Bootstrap accurately since they use Chromium engines. The choice depends on whether you need a simple PDF generation workflow (IronPDF) or broader browser automation capabilities (Puppeteer Sharp).

For more information on CSS framework compatibility, see the Bootstrap & Flexbox CSS Guide.