iTextsharp HTML do PDF z stylami CSS C# Przykład vs IronPDF

Czym jest IronPDF?

IronPDF to biblioteka PDF dla .NET stworzona do generowania, edytowania i manipulowania dokumentami PDF w zarządzanym kodzie C#. Jego wbudowany silnik Chromium konwertuje HTML — włącznie z pełnym CSS3 i JavaScript — na PDF bez wymagania zewnętrznego procesu przeglądarki. API obejmuje szyfrowanie, podpisy cyfrowe, wypełnianie formularzy, znakowanie wodne i scalanie dokumentów, wszystko dostępne za pomocą pojedynczego pakietu NuGet.

IronPDF obsługuje .NET 9 i jest w trakcie zapewniania kompatybilności z .NET 10. Zaawansowana manipulacja PDF-em, w tym ekstrakcja treści i stemplowanie stron, również wchodzi w skład.

Czym jest Puppeteer Sharp?

Puppeteer Sharp to port .NET popularnej biblioteki Puppeteer dla Node.js firmy Google, utrzymywany przez Darío Kondratiuka. Oferuje wysokopoziomowe API do programatycznego sterowania przeglądarkami Headless Chrome lub Chromium za pomocą Protokołu DevTools. Chociaż Puppeteer Sharp może generować PDF-y, jest głównie zaprojektowany jako narzędzie do automatyzacji przeglądarek, które doskonale nadaje się do skrobania sieci, testów automatycznych i przechwytywania zrzutów ekranu.

Biblioteka działa poprzez uruchamianie i kontrolę przykładowej przeglądarki bezgłowej, pozwalając deweloperom nawigować po stronach sieciowych, wchodzić w interakcję z elementami i eksportować treści w różnych formatach, w tym PDF. Według najnowszych benchmarków, Puppeteer Sharp oferuje przewagę wydajnościową dla prostego renderowania HTML, ale wymaga bardziej złożonego ustawienia w porównaniu do dedykowanych bibliotek PDF. Zespoły oceniające IronPDF pod kątem wymogów generowania PDF mogą uzyskać bezpłatną wersję próbną na 30 dni.

Obsługa wielu platform przez IronPDF

IronPDF zapewnia szeroką kompatybilność między platformami, wspierając wdrożenie w różnych środowiskach. Biblioteka działa na:

• Wersje .NET:

  • .NET 10, 9, 8, 7, 6, 5 (z gotowością na .NET 10)
  • .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 i środowiska:

  • Windows (w tym serwer Windows)
  • Linux (wszystkie główne dystrybucje)
  • macOS (Intel i Apple Silicon)
  • Kontenery Docker
  • Cloud platforms: Azure, AWS Lambda
• Narzędzia deweloperskie:
  • Microsoft Visual Studio
  • JetBrains Rider & ReSharper
  • Visual Studio Code

Natywna obsługa różnych platform w IronPDF oznacza brak konieczności dodawania dodatkowych pakietów lub konfiguracji do różnych środowisk. Biblioteka automatycznie wykrywa i optymalizuje docelową platformę, o czym wspomniano w aktualizacji dotyczącej kamieni milowych kompatybilności.

Kompatybilność między platformami Puppeteer Sharp

Puppeteer Sharp oferuje kompatybilność między platformami z pewnymi istotnymi uwagami:

• Wersje .NET:

  • .NET 10 i .NET Standard 2.0 (od kwietnia 2026)
  • .NET Framework 4.6.1+
  • .NET Core 2.0 lub wyższy

• Systemy operacyjne:

  • Windows (pełne wsparcie)
  • Linux (wymaga X-serwera, może potrzebować rozwiązywania problemów)
  • macOS (standardowe wsparcie)
  • Docker (z zależnościami Chrome)
• Wymagania dotyczące przeglądarki:
  • Wymaga pobrania plików binarnych Chromium (~170MB)
  • Obsługuje przeglądarki Chrome, Chromium i Firefox
  • Tryby bezgłowy i głowy dostępne

Według oficjalnej dokumentacji, użytkownicy Linuxa mogą napotkać problemy podczas uruchamiania Chrome i muszą skonsultować się z przewodnikiem rozwiązywania problemów. Biblioteka wymaga zarządzania pobieraniem przeglądarki i cyklu życia, co zwiększa złożoność wdrożenia.

Funkcje IronPDF

IronPDF zapewnia wszechstronny zestaw narzędzi do manipulacji PDF:

• Generowanie i konwersja PDF:

  • Konwersja HTML na PDF z pełnym wsparciem dla CSS3, JavaScript i fontów webowych
  • Convert from multiple formats: DOCX, images, RTF, and Markdown
  • URL na PDF z wsparciem autoryzacji
  • Renderowanie widoków ASPX i MVC

• Funkcje bezpieczeństwa:

  • 256-bitowe szyfrowanie AES
  • Ochrona hasłem z uprawnieniami użytkownika/właściciela
  • Podpisy cyfrowe z obsługą certyfikatów
  • Zarządzanie uprawnieniami (drukowanie, kopiowanie, edytowanie ograniczenia)

• 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 bezgłowym 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żono w API Template, "Puppeteer Sharp jest portem C# popularnej biblioteki Puppeteer używanej do automatyzacji Be W tym artykułe 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. Klasa ChromePdfRenderer radzi sobie z całą złożonością renderowania HTML wewnętrznie. Główne zalety to:

• Pojedyncze wywołanie metody do konwersji (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. Opcja RenderDelay zapewnia prosty sposób oczekiwania na wykonanie i renderowanie JavaScript. 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.

Wydajność IronPDF

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 śmieći 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:
  • 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.

Wydajność Puppeteer Sharp

Charakterystyka wydajności Puppeteer Sharp różni się ze względu na swoją architekturę:

• Narzut przeglądarki:

  • ~170MB pobrania Chromium jest wymagane
  • Każda instancja przeglądarki zużywa znaczną ilość RAM
  • Czas uruchamiania przeglądarki dodaje mierzalne opóźnienie podczas uruchamiania

• Szybkość renderowania:

  • Wydajność może spadać przy wielu równoczesnych przypadkach
  • Intensywne zużycie zasobów dla operacji równoczesnych
• Strategie optymalizacji:
  • Zalecane ponowne wykorzystanie instancji przeglądarki
  • Połączenie pooling dla wielu plików PDF
  • Tryb bezgłowy zmniejsza obciążenie

Testy porównawcze pokazują, że Puppeteer może być szybszy dla prostego HTML, ale wymaga dokładnego zarządzania zasobami do zastosowań produkcyjnych.

Struktura cenowa IronPDF

IronPDF oferuje elastyczne komercyjne opcje licencjonowania:

• Poziomy licencji (ceny na kwiecień 2026):

  • Lite License: $999 - 1 developer, 1 location, 1 project
  • Plus License: $1,499 - 3 deweloperów, 3 lokalizacje, 3 projekty
  • Professional License: $2,999 - 10 developers, 10 locations, 10 projects
  • Unlimited License: $5,999 - nieograniczona liczba deweloperów i projektów

• Dodatkowe Opcje:

  • Redystrybucja bez oplat licencyjnych: +$2,999
  • Licencjonowanie SaaS/OEM dostępne
  • Iron Suite: $2,998 for 10 products
  • Gwarancja zwrotu pieniędzy w ciągu 30 dni
• Wsparcie i aktualizacje:
  • Jeden rok wsparcia i aktualizacji w cenie
  • Przedłużone wsparcie: $999/rok lub $1,999 na 5 lat
  • Wsparcie inżynierskie 24/5 z każdą licencją

Licencjonowanie Puppeteer Sharp

Puppeteer Sharp korzysta z licencji MIT:

• Koszt: Całkowicie bezpłatny
• Użycie komercyjne: Dozwolone bez ograniczeń
• Wsparcie: Oparte na społeczności za pośrednictwem GitHub
• Aktualizacje: Wsparcie społeczności open-source

Podczas gdy sama licencja jest bezpłatna, zespoły powinny uwzględnić całkowite koszty projektu:

• Wsparcie opiera się na społeczności open-source, a nie na dedykowanym zespole
• Zarządzanie infrastrukturą spoczywa na twoim zespole
• Zaawansowane funkcje PDF wymagają integracji dodatkowych bibliotek
• Rozwiązywanie problemów często zależy od forów społecznościowych i samodzielnego diagnozowania

Wybór często zależy od tego, czy profesjonalne wsparcie i zaawansowane funkcje uzasadniają inwestycję dla danego projektu.

Poza kosztami licencji, całkowity koszt projektu obejmuje godziny dewelopera spędzone na zarządzaniu kodem cyklu życia przeglądarki, integrowaniu oddzielnych bibliotek dla szyfrowania i podpisów cyfrowych oraz rozwiązywaniu problemów z wdrażaniem w różnych środowiskach bez dedykowanego wsparcia. 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.

Dokumentacja i wsparcie IronPDF

IronPDF zapewnia kompleksowe zasoby profesjonalistów:

• Dokumentacja:

  • Rozległa dokumentacja API
  • Ponad 50 tutoriali omawiających typowe scenariusze
  • Ponad 200 przykładów kodu
  • Samouczki wideo na YouTube
  • Regularne aktualizacje dokumentacji

• Kanały Wsparcia:

  • Wsparcie inżynierskie 24/5 na żywo
  • Wsparcie e-mail i telefon (zależne od licencji)
  • Sesje udostępniania ekranu dla złożonych problemów
  • Forum społeczności
  • Kanał Slack do dyskusji
• Zasoby Edukacyjne:
  • Przewodniki dla początkujących
  • Sekcja rozwiązywania problemów
  • Dokumentacja najlepszych praktyk
  • Przewodniki migracji z innych bibliotek

Dokumentacja i wsparcie Puppeteer Sharp

Puppeteer Sharp polega na zasobach społecznościowych:

• Dokumentacja:

  • API documentation
  • README GitHub i wiki
  • Przykłady kodu w repozytorium
  • Linki do oryginalnej dokumentacji Puppeteer

• Opcje wsparcia:

  • Problemy GitHub dla raportowania błędów
  • Dyskusje społecznościowe
  • Pytania na Stack Overflow
  • Brak oficjalnego kanału wsparcia
• Rozważania:
  • Aktualizacje dokumentacji podążają za cyklem kontrybucji open-source
  • Członkowie społeczności odpowiadają za większość dodatkowych treści
  • Wskazówki dotyczące rozwiązywania problemów mają węższy zakres niż komercyjne biblioteki
  • Niektóre przykłady odzwierciedlają wcześniejsze wersje API

Blog dewelopera zapewnia przydatne wglądy techniczne, choć posty podążają za harmonogramem opiekuna, a nie ustalonym rytmem.

Kiedy wybrać IronPDF:

• Budowanie aplikacji korporacyjnych wymagających bezpiecznych, profesjonalnych PDF
• Potrzeba kompleksowych funkcji PDF wykraczających poza podstawowe generowanie
• Chęć minimalnej złożoności kodu z prostymi API
• Wymóg profesjonalnego wsparcia i dokumentacji
• Praca z wieloma formatami PDF (DOCX, obrazy itp.)
• Potrzeba wbudowanych funkcji bezpieczeństwa jak szyfrowanie i podpisy
• Wdrażanie na różnych platformach bez obaw o kompatybilność
• Wartość szybkości wprowadzenia na rynek nad początkowym kosztem

IronPDF przoduje w scenariuszach takich jak:

• Generowanie faktur i raportów
• Systemy zarządzania dokumentami
• Dokumentacja wymagana przepisami
• Przetwarzanie dokumentów w wielu formatach
• Operacje PDF o dużej skali

Wybierz Puppeteer Sharp, gdy:

• Główny nacisk kładzie się na automatyzację przeglądarki z PDF jako wtórnym
• Ograniczenia budżetowe uniemożliwiają licencje komercyjne
• Potrzeba możliwości web scrapingu razem z generowaniem PDF
• Komfort w zarządzaniu infrastrukturą przeglądarki
• Proste wymagania dotyczące PDF bez zaawansowanych funkcji
• Znajomość Puppeteer z Node.js
• Budowanie frameworków testowych lub narzędzi automatyzacyjnych

Puppeteer Sharp sprawdza się w:

• Testowaniu automatycznym z raportami PDF
• Scraping web z eksportem PDF
• Prosta konwersja HTML do PDF
• Przepływy pracy z przechwytywaniem zrzutów ekranu
• Zadania automatyzacji oparte na przeglądarce

Rekomendacje w świecie rzeczywistym

Na podstawie rozległych analiz porównawczych i opinii deweloperów, oto praktyczne rekomendacje:

1. Dla aplikacji produkcyjnych: Niezawodność, wsparcie i funkcje IronPDF uzasadniają inwestycję
2. Dla prototypów: Bezpłatna licencja Puppeteer Sharp umożliwia szybkie eksperymentowanie
3. Dla złożonych PDF: Zaawansowane funkcje IronPDF oszczędzają czas na rozwój
4. Dla testów przeglądarki: Możliwości automatyzacji Puppeteer Sharp są niezrównane

IronPDF: Uproszczone renderowanie Bootstrap

API skoncentrowane na PDF IronPDF ułatwia renderowanie układów Bootstrap z minimalnym kodem:

• Konwersja jednym wierszem: Nie wymaga zarządzania cyklem życia przeglądarki
• Wbudowana optymalizacja: Automatyczne ładowanie CSS/JavaScript
• Bootstrap 5 gotowy: Pełne wsparcie dla strony głównej Bootstrap i szablonów
• Gotowość do produkcji: Zawiera funkcje bezpieczeństwa, kompresji i Enterprise

Przykład kodu: Renderowanie Bootstrap IronPDF

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: Renderowanie Bootstrap oparte na przeglądarce

Puppeteer Sharp wymaga jawnego zarządzania przeglądarką i kontroli cyklu życia do renderowania Bootstrap:

Przykład kodu: Renderowanie Bootstrap Puppeteer Sharp

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

Kluczowe różnice dla rozwoju Bootstrap

Złożoność:

• IronPDF: 4 linie kodu (inicjalizacja, renderowanie, zapisywanie)
• Puppeteer Sharp: 15+ linii (pobieranie, uruchamianie, zarządzanie stroną, czyszczenie)

Funkcje:

• IronPDF: Wbudowane bezpieczeństwo, kompresja, znakowanie wodne, podpisy
• Puppeteer Sharp: Zespoły potrzebujące manipulacji PDF dodają oddzielne biblioteki

Wdrożenie:

• IronPDF: Samodzielne, brak zewnętrznych zależności
• Puppeteer Sharp: Wymaga binariów Chromium (~170MB) i zarządzania przeglądarką

Obie biblioteki dokładnie renderują Bootstrap, ponieważ używają silników Chromium. Wybór zależy od tego, czy potrzebujesz prostego przepływu generowania PDF (IronPDF) czy szerszych możliwości automatyzacji przeglądarki (Puppeteer Sharp).

Więcej informacji o zgodności frameworków CSS można znaleźć w Przewodniku Bootstrap & Flexbox CSS.