Jak przejść z Playwright na IronPDF w języku C#

ZrozumieniePlaywrightdla .NET

Playwright for .NET to kompleksowa platforma testowa firmy Microsoft, a NIE biblioteka do generowania dokumentów. Została stworzona od podstaw z myślą o automatycznym testowaniu w przeglądarkach Chromium, Firefox i WebKit.Playwrightdoskonale sprawdza się w testowaniu scenariuszy: klikaniu przycisków, wypełnianiu formularzy, przechwytywaniu żądań sieciowych, robieniu zrzutów ekranu oraz sprawdzaniu zgodności między przeglądarkami.

Kluczowe zrozumienie:Playwrightto narzędzie testowe, które zostało przystosowane do generowania plików PDF. Tworzenie plików PDF jest jedynie efektem ubocznym funkcji drukowania przeglądarki (Ctrl+P), a nie głównym celem projektu. Powoduje to fundamentalne niezgodności architektoniczne:

• Architektura oparta na testowaniu: Stworzona z myślą o interaktywnym testowaniu w przeglądarce, a nie o tworzeniu dokumentów w trybie bezinterfejsowym
• Obciążenie związane z obsługą wielu przeglądarek: pobiera ponad 400 MB plików binarnych przeglądarek (Chromium, Firefox, WebKit), nawet jeśli potrzebne jest jedynie generowanie plików PDF
• API zorientowane na testy: złożone wzorce asynchroniczne zaprojektowane z myślą o procesach automatyzacji testów, a nie generowaniu dokumentów
• Brak funkcji dokumentów: brak zgodności z PDF/A, podpisów cyfrowych, znaków wodnych, scalania, zabezpieczeń

Problem z frameworkiem testowym

Playwright został zaprojektowany do testowania end-to-end, a nie do generowania dokumentów. Powoduje to zasadnicze problemy podczas korzystania z niego w przypadku plików PDF:

1. Przed pierwszym użyciem wymagane jest pobranie ponad 400 MB plików do przeglądarki. Domyślna konfiguracja Playwrighta wymaga pobrania wielu przeglądarek, co może stanowić problem w środowiskach o ścisłych ograniczeniach zasobów.

2. Złożone wzorce asynchroniczne z kontekstami przeglądarki i zarządzaniem stronami. Programiści muszą zapoznać się z kontekstami przeglądarek i zarządzaniem stronami, a także z odpowiednimi praktykami w zakresie usuwania danych.

3. Architektura oparta na testowaniu nie jest zoptymalizowana pod kątem generowania dokumentów.

4. Ograniczenia funkcji "Drukuj do pliku PDF" odpowiadające drukowaniu w przeglądarce za pomocą skrótu klawiszowego Ctrl+P. Układ strony może ulec zmianie, tła mogą być domyślnie pominięte, a wynik jest paginowany do druku.

5. Brak obsługi formatów PDF/A lub PDF/UA w celu zapewnienia zgodności z wymogąmi dostępności.Playwrightnie może tworzyć dokumentów zgodnych ze standardami PDF/A (archiwizacja) ani PDF/UA (dostępność). W przypadku sekcji 508, dyrektyw UE dotyczących dostępności lub długoterminowych wymagań archiwizacyjnych potrzebna będzie dedykowana biblioteka plików PDF.

6. Operacje wymagające dużych zasobów, wymagające pełnych instancji przeglądarki.

Problem z konfiguracją środowiska testowego

Playwright wymaga rozbudowanej konfiguracji zorientowanej na testowanie, którą rozumieją inżynierowie ds. kontroli jakości, ale która nie powinna być potrzebna twórcom dokumentacji:

Wymagana instalacja przeglądarki:

# Manual installation step required before first use
playwright install  # Downloads 400MB+ of browser binaries
# Or programmatically:
playwright install chromium  # Still 100MB+ for single browser

# Manual installation step required before first use
playwright install  # Downloads 400MB+ of browser binaries
# Or programmatically:
playwright install chromium  # Still 100MB+ for single browser

Konfiguracja uruchamiania przeglądarki:

// Testing-focused launch options for PDF generation
using var playwright = await Playwright.CreateAsync();
var browser = await playwright.Chromium.LaunchAsync(new BrowserTypeLaunchOptions
{
    Headless = true,  // Required for server environments
    Args = new[] { "--disable-gpu", "--no-sandbox" } // Linux/Docker configs
});

// Testing-focused launch options for PDF generation
using var playwright = await Playwright.CreateAsync();
var browser = await playwright.Chromium.LaunchAsync(new BrowserTypeLaunchOptions
{
    Headless = true,  // Required for server environments
    Args = new[] { "--disable-gpu", "--no-sandbox" } // Linux/Docker configs
});

' Testing-focused launch options for PDF generation
Using playwright = Await Playwright.CreateAsync()
    Dim browser = Await playwright.Chromium.LaunchAsync(New BrowserTypeLaunchOptions With {
        .Headless = True,  ' Required for server environments
        .Args = New String() { "--disable-gpu", "--no-sandbox" } ' Linux/Docker configs
    })
End Using

Opcje konfiguracyjne dotyczące testowania:

• Headless: Należy skonfigurować tryb bezinterfejsu graficznego dla środowiska produkcyjnego (domyślnie dla testów jest tryb z interfejsem graficznym)
• SlowMo: Opóźnienia testowe (nieistotne dla generowania plików PDF)
• Devtools: Konfiguracja narzędzi testowych (nie jest wymagana w przypadku dokumentów)
• ExecutablePath: Niestandardowe ścieżki przeglądarki dla środowisk testowych
• Proxy: Przechwytywanie ruchu sieciowego do celów testowych (niepotrzebne obciążenie)
• DownloadsPath: Zarządzanie artefaktami testowymi
• TracesDir: Ślady wykonania testów

Zarządzanie kontekstem przeglądarki:

// Complex context lifecycle from testing paradigm
var context = await browser.NewContextAsync(new BrowserNewContextOptions
{
    ViewportSize = new ViewportSize { Width = 1920, Height = 1080 },
    UserAgent = "custom-user-agent",
    Locale = "en-US",
    TimezoneId = "America/New_York"
});
var page = await context.NewPageAsync();
// ... generate PDF ...
await context.CloseAsync();  // Manual cleanup required
await browser.CloseAsync();  // Manual cleanup required

// Complex context lifecycle from testing paradigm
var context = await browser.NewContextAsync(new BrowserNewContextOptions
{
    ViewportSize = new ViewportSize { Width = 1920, Height = 1080 },
    UserAgent = "custom-user-agent",
    Locale = "en-US",
    TimezoneId = "America/New_York"
});
var page = await context.NewPageAsync();
// ... generate PDF ...
await context.CloseAsync();  // Manual cleanup required
await browser.CloseAsync();  // Manual cleanup required

' Complex context lifecycle from testing paradigm
Dim context = Await browser.NewContextAsync(New BrowserNewContextOptions With {
    .ViewportSize = New ViewportSize With {.Width = 1920, .Height = 1080},
    .UserAgent = "custom-user-agent",
    .Locale = "en-US",
    .TimezoneId = "America/New_York"
})
Dim page = Await context.NewPageAsync()
' ... generate PDF ...
Await context.CloseAsync()  ' Manual cleanup required
Await browser.CloseAsync()  ' Manual cleanup required

Złożoność związana z obsługą wielu przeglądarek:

//Playwrightdownloads multiple browsers by default
await playwright.Chromium.LaunchAsync();  // For Chrome testing
await playwright.Firefox.LaunchAsync();   // For Firefox testing
await playwright.Webkit.LaunchAsync();    // For Safari testing
// All downloaded but only Chromium needed for PDF generation

//Playwrightdownloads multiple browsers by default
await playwright.Chromium.LaunchAsync();  // For Chrome testing
await playwright.Firefox.LaunchAsync();   // For Firefox testing
await playwright.Webkit.LaunchAsync();    // For Safari testing
// All downloaded but only Chromium needed for PDF generation

Option Strict On



' Playwright downloads multiple browsers by default
Await playwright.Chromium.LaunchAsync()  ' For Chrome testing
Await playwright.Firefox.LaunchAsync()   ' For Firefox testing
Await playwright.Webkit.LaunchAsync()    ' For Safari testing
' All downloaded but only Chromium needed for PDF generation

IronPDF: Zero konfiguracji, zero instalacji

// No installation, no configuration, no lifecycle management
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

// No installation, no configuration, no lifecycle management
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

' No installation, no configuration, no lifecycle management
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")

Prawdziwe rozwiązanie typu "plug-and-play":IronPDFeliminuje wszystkie obciążenia związane z frameworkami testowymi. Żadnych poleceń instalacyjnych przeglądarki, żadnej konfiguracji bezinterfejsowej, żadnego zarządzania kontekstem — wystarczy utworzyć instancję i wyrenderować. Stworzone specjalnie do generowania dokumentów, a nie zaadaptowane z narzędzi testowych.

Porównanie wydajnościPlaywrighti IronPDF

IronPDF został stworzony z myślą o generowaniu plików PDF. W przeciwieństwie do Playwright, który koncentruje się na testowaniu,IronPDFoferuje szereg funkcji API związanych z dokumentami. Opiera się na pojedynczej, zoptymalizowanej instancji Chromium, co sprzyja wydajności i umożliwia zarówno operacje synchroniczne, jak i asynchroniczne. Dzięki temu programiści, którzy potrzebują funkcji związanych z plikami PDF, zyskują prostszy model mentalny i przebieg pracy.

Dla zespołów planujących wdrożenie .NET 10 i C# 14 w latach 2025 i 2026,IronPDFoferuje specjalnie zaprojektowane rozwiązanie do obsługi plików PDF, które eliminuje obciążenie związane z automatyzacją przeglądarki, zapewniając jednocześnie lepszą wydajność i profesjonalne funkcje dokumentów.

Podsumowanie

Playwright to framework testowy firmy Microsoft przeznaczony dla inżynierów ds. kontroli jakości przeprowadzających automatyczne testy w różnych przeglądarkach. Wykorzystanie go do generowania plików PDF stanowi niedopasowanie architektury, które wymaga rozległej wiedzy z zakresu testowania:

• Ręczna instalacja przeglądarki (playwright install)
• Konfiguracja trybu bezinterfejsowego dla środowiska produkcyjnego
• Zarządzanie opcjami uruchamiania przeglądarki
• Konfiguracja cyklu życia kontekstu
• Pobieranie plików w wielu przeglądarkach (400 MB+), gdy potrzebna jest tylko jedna
• Złożone wzorce async/await z paradygmatu testowania

IronPDF to biblioteka do generowania dokumentów przeznaczona dla programistów tworzących procesy pracy z plikami PDF. To prawdziwie rozwiązanie typu "plug-and-play":

• Nie wymaga instalacji — działa od razu
• Zero konfiguracji — inteligentne ustawienia domyślne
• Zero pobrań przeglądarki — w zestawie zoptymalizowany silnik
• Proste API — nie trzeba uczyć się żadnych koncepcji testowania
• Automatyczne zarządzanie zasobami — brak złożoności cyklu życia

Jeśli chcesz testować aplikacje internetowe w różnych przeglądarkach, skorzystaj z Playwright. Jeśli chcesz generować dokumenty PDF, użyj IronPDF. Nie dostosowuj frameworka testowego do generowania dokumentów — użyj narzędzia stworzonego specjalnie do tego zadania.

Wymagania wstępne

1. Środowisko .NET: .NET Framework 4.6.2+ lub .NET Core 3.1+ / .NET 5/6/7/8/9+
2. Dostęp do NuGet: Możliwość instalowania pakietów NuGet
3. Licencja IronPDF: Uzyskaj klucz licencyjny na stronie ironpdf.com

Zmiany w pakiecie NuGet

# Remove Playwright
dotnet remove package Microsoft.Playwright

# Remove browser binaries (reclaim ~400MB disk space)
# Delete the .playwright folder in your project or user directory

# Add IronPDF
dotnet add package IronPdf

# Remove Playwright
dotnet remove package Microsoft.Playwright

# Remove browser binaries (reclaim ~400MB disk space)
# Delete the .playwright folder in your project or user directory

# Add IronPDF
dotnet add package IronPdf

W przypadkuIronPDFnie jest wymagany playwright install — silnik renderujący jest dołączany automatycznie.

Konfiguracja licencji

// Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

// Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

' Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

Zmiany w przestrzeni nazw

// Before: Playwright
using Microsoft.Playwright;
using System.Threading.Tasks;

// After: IronPDF
using IronPdf;
using IronPdf.Rendering;

// Before: Playwright
using Microsoft.Playwright;
using System.Threading.Tasks;

// After: IronPDF
using IronPdf;
using IronPdf.Rendering;

' Before: Playwright
Imports Microsoft.Playwright
Imports System.Threading.Tasks

' After: IronPDF
Imports IronPdf
Imports IronPdf.Rendering

Mapowania podstawowych interfejsów API

Przykład 1: Konwersja ciągu znaków HTML do formatu PDF

Przed (Playwright):

// NuGet: Install-Package Microsoft.Playwright
using Microsoft.Playwright;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var playwright = await Playwright.CreateAsync();
        var browser = await playwright.Chromium.LaunchAsync();
        var page = await browser.NewPageAsync();

        string html = "<h1>Hello World</h1><p>This is a test PDF.</p>";
        await page.SetContentAsync(html);
        await page.PdfAsync(new PagePdfOptions { Path = "output.pdf" });

        await browser.CloseAsync();
    }
}

// NuGet: Install-Package Microsoft.Playwright
using Microsoft.Playwright;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var playwright = await Playwright.CreateAsync();
        var browser = await playwright.Chromium.LaunchAsync();
        var page = await browser.NewPageAsync();

        string html = "<h1>Hello World</h1><p>This is a test PDF.</p>";
        await page.SetContentAsync(html);
        await page.PdfAsync(new PagePdfOptions { Path = "output.pdf" });

        await browser.CloseAsync();
    }
}

Imports Microsoft.Playwright
Imports System.Threading.Tasks

Module Program
    Async Function Main(args As String()) As Task
        Dim playwright = Await Playwright.CreateAsync()
        Dim browser = Await playwright.Chromium.LaunchAsync()
        Dim page = Await browser.NewPageAsync()

        Dim html As String = "<h1>Hello World</h1><p>This is a test PDF.</p>"
        Await page.SetContentAsync(html)
        Await page.PdfAsync(New PagePdfOptions With {.Path = "output.pdf"})

        Await browser.CloseAsync()
    End Function
End Module

Po (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        string html = "<h1>Hello World</h1><p>This is a test PDF.</p>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        string html = "<h1>Hello World</h1><p>This is a test PDF.</p>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}

Imports IronPdf

Class Program
    Shared Sub Main(ByVal args As String())
        Dim renderer = New ChromePdfRenderer()

        Dim html As String = "<h1>Hello World</h1><p>This is a test PDF.</p>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Class

Ten przykład ilustruje podstawową różnicę architektoniczną.Playwrightwymaga pięciu operacji asynchronicznych: Playwright.CreateAsync(), Chromium.LaunchAsync(), NewPageAsync(), SetContentAsync() oraz PdfAsync(), a także jawne czyszczenie przeglądarki za pomocą CloseAsync().

IronPDF eliminuje całą tę złożoność: utwórz ChromePdfRenderer, wywołaj RenderHtmlAsPdf() i SaveAs(). Żadnych wzorców asynchronicznych, żadnego cyklu życia przeglądarki, żadnego kodu czyszczącego. PodejścieIronPDFoferuje bardziej przejrzystą składnię i lepszą integrację z nowoczesnymi aplikacjami .NET. Kompleksowe przykłady można znaleźć w dokumentacji dotyczącej konwersji HTML do PDF.

Przykład 2: Konwersja adresów URL do formatu PDF

Przed (Playwright):

// NuGet: Install-Package Microsoft.Playwright
using Microsoft.Playwright;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var playwright = await Playwright.CreateAsync();
        var browser = await playwright.Chromium.LaunchAsync();
        var page = await browser.NewPageAsync();

        await page.GotoAsync("https://www.example.com");
        await page.PdfAsync(new PagePdfOptions 
        { 
            Path = "webpage.pdf",
            Format = "A4"
        });

        await browser.CloseAsync();
    }
}

// NuGet: Install-Package Microsoft.Playwright
using Microsoft.Playwright;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var playwright = await Playwright.CreateAsync();
        var browser = await playwright.Chromium.LaunchAsync();
        var page = await browser.NewPageAsync();

        await page.GotoAsync("https://www.example.com");
        await page.PdfAsync(new PagePdfOptions 
        { 
            Path = "webpage.pdf",
            Format = "A4"
        });

        await browser.CloseAsync();
    }
}

Imports Microsoft.Playwright
Imports System.Threading.Tasks

Module Program
    Async Function Main(args As String()) As Task
        Dim playwright = Await Playwright.CreateAsync()
        Dim browser = Await playwright.Chromium.LaunchAsync()
        Dim page = Await browser.NewPageAsync()

        Await page.GotoAsync("https://www.example.com")
        Await page.PdfAsync(New PagePdfOptions With {
            .Path = "webpage.pdf",
            .Format = "A4"
        })

        Await browser.CloseAsync()
    End Function
End Module

Po (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
        pdf.SaveAs("webpage.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
        pdf.SaveAs("webpage.pdf");
    }
}

Imports IronPdf

Class Program
    Shared Sub Main(ByVal args As String())
        Dim renderer = New ChromePdfRenderer()

        Dim pdf = renderer.RenderUrlAsPdf("https://www.example.com")
        pdf.SaveAs("webpage.pdf")
    End Sub
End Class

Playwright używa GotoAsync() do przejścia do adresu URL, po którym następuje PdfAsync().IronPDFudostępnia jedną metodę RenderUrlAsPdf(), która obsługuje nawigację i generowanie plików PDF w jednym wywołaniu. Należy pamiętać, żePlaywrightwymaga określenia Format w PagePdfOptions, podczas gdyIronPDFużywa RenderingOptions.PaperSize do konfiguracji rozmiaru papieru. Dowiedz się więcej z naszych samouczków.

Przykład 3: Niestandardowy rozmiar strony z marginesami

Przed (Playwright):

// NuGet: Install-Package Microsoft.Playwright
using Microsoft.Playwright;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using var playwright = await Playwright.CreateAsync();
        await using var browser = await playwright.Chromium.LaunchAsync();
        var page = await browser.NewPageAsync();
        await page.SetContentAsync("<h1>Custom PDF</h1><p>Letter size with margins</p>");
        await page.PdfAsync(new PagePdfOptions 
        { 
            Path = "custom.pdf",
            Format = "Letter",
            Margin = new Margin { Top = "1in", Bottom = "1in", Left = "0.5in", Right = "0.5in" }
        });
    }
}

// NuGet: Install-Package Microsoft.Playwright
using Microsoft.Playwright;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using var playwright = await Playwright.CreateAsync();
        await using var browser = await playwright.Chromium.LaunchAsync();
        var page = await browser.NewPageAsync();
        await page.SetContentAsync("<h1>Custom PDF</h1><p>Letter size with margins</p>");
        await page.PdfAsync(new PagePdfOptions 
        { 
            Path = "custom.pdf",
            Format = "Letter",
            Margin = new Margin { Top = "1in", Bottom = "1in", Left = "0.5in", Right = "0.5in" }
        });
    }
}

Imports Microsoft.Playwright
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Using playwright = Await Playwright.CreateAsync()
            Await Using browser = Await playwright.Chromium.LaunchAsync()
                Dim page = Await browser.NewPageAsync()
                Await page.SetContentAsync("<h1>Custom PDF</h1><p>Letter size with margins</p>")
                Await page.PdfAsync(New PagePdfOptions With {
                    .Path = "custom.pdf",
                    .Format = "Letter",
                    .Margin = New Margin With {
                        .Top = "1in",
                        .Bottom = "1in",
                        .Left = "0.5in",
                        .Right = "0.5in"
                    }
                })
            End Using
        End Using
    End Function
End Module

Po (IronPDF):

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
        renderer.RenderingOptions.MarginTop = 25;
        renderer.RenderingOptions.MarginBottom = 25;
        renderer.RenderingOptions.MarginLeft = 12;
        renderer.RenderingOptions.MarginRight = 12;
        var pdf = renderer.RenderHtmlAsPdf("<h1>Custom PDF</h1><p>Letter size with margins</p>");
        pdf.SaveAs("custom.pdf");
    }
}

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
        renderer.RenderingOptions.MarginTop = 25;
        renderer.RenderingOptions.MarginBottom = 25;
        renderer.RenderingOptions.MarginLeft = 12;
        renderer.RenderingOptions.MarginRight = 12;
        var pdf = renderer.RenderHtmlAsPdf("<h1>Custom PDF</h1><p>Letter size with margins</p>");
        pdf.SaveAs("custom.pdf");
    }
}

Imports IronPdf
Imports IronPdf.Rendering

Class Program
    Shared Sub Main()
        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter
        renderer.RenderingOptions.MarginTop = 25
        renderer.RenderingOptions.MarginBottom = 25
        renderer.RenderingOptions.MarginLeft = 12
        renderer.RenderingOptions.MarginRight = 12
        Dim pdf = renderer.RenderHtmlAsPdf("<h1>Custom PDF</h1><p>Letter size with margins</p>")
        pdf.SaveAs("custom.pdf")
    End Sub
End Class

Playwright używa wartości marginesów opartych na ciągach znaków ("1in", "0.5in"), podczas gdyIronPDFużywa wartości liczbowych w milimetrach. Przelicznik wynosi: 1 cal = 25,4 mm, więc "1in" staje się 25, a "0.5in" staje się w przybliżeniu 12. Format = "Letter" wPlaywrightodpowiada PaperSize = PdfPaperSize.Letter w IronPDF.

Przykład 4: Nagłówki, stopki i ustawienia niestandardowe

Przed (Playwright):

// NuGet: Install-Package Microsoft.Playwright
using Microsoft.Playwright;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var playwright = await Playwright.CreateAsync();
        var browser = await playwright.Chromium.LaunchAsync();
        var page = await browser.NewPageAsync();

        string html = "<h1>Custom PDF</h1><p>With margins and headers.</p>";
        await page.SetContentAsync(html);

        await page.PdfAsync(new PagePdfOptions
        {
            Path = "custom.pdf",
            Format = "A4",
            Margin = new Margin { Top = "1cm", Bottom = "1cm", Left = "1cm", Right = "1cm" },
            DisplayHeaderFooter = true,
            HeaderTemplate = "<div style='font-size:10px; text-align:center;'>Header</div>",
            FooterTemplate = "<div style='font-size:10px; text-align:center;'>Page <span class='pageNumber'></span></div>"
        });

        await browser.CloseAsync();
    }
}

// NuGet: Install-Package Microsoft.Playwright
using Microsoft.Playwright;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var playwright = await Playwright.CreateAsync();
        var browser = await playwright.Chromium.LaunchAsync();
        var page = await browser.NewPageAsync();

        string html = "<h1>Custom PDF</h1><p>With margins and headers.</p>";
        await page.SetContentAsync(html);

        await page.PdfAsync(new PagePdfOptions
        {
            Path = "custom.pdf",
            Format = "A4",
            Margin = new Margin { Top = "1cm", Bottom = "1cm", Left = "1cm", Right = "1cm" },
            DisplayHeaderFooter = true,
            HeaderTemplate = "<div style='font-size:10px; text-align:center;'>Header</div>",
            FooterTemplate = "<div style='font-size:10px; text-align:center;'>Page <span class='pageNumber'></span></div>"
        });

        await browser.CloseAsync();
    }
}

Imports Microsoft.Playwright
Imports System.Threading.Tasks

Module Program
    Async Function Main(args As String()) As Task
        Dim playwright = Await Playwright.CreateAsync()
        Dim browser = Await playwright.Chromium.LaunchAsync()
        Dim page = Await browser.NewPageAsync()

        Dim html As String = "<h1>Custom PDF</h1><p>With margins and headers.</p>"
        Await page.SetContentAsync(html)

        Await page.PdfAsync(New PagePdfOptions With {
            .Path = "custom.pdf",
            .Format = "A4",
            .Margin = New Margin With {.Top = "1cm", .Bottom = "1cm", .Left = "1cm", .Right = "1cm"},
            .DisplayHeaderFooter = True,
            .HeaderTemplate = "<div style='font-size:10px; text-align:center;'>Header</div>",
            .FooterTemplate = "<div style='font-size:10px; text-align:center;'>Page <span class='pageNumber'></span></div>"
        })

        Await browser.CloseAsync()
    End Function
End Module

Po (IronPDF):

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

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        renderer.RenderingOptions.MarginTop = 10;
        renderer.RenderingOptions.MarginBottom = 10;
        renderer.RenderingOptions.MarginLeft = 10;
        renderer.RenderingOptions.MarginRight = 10;
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.TextHeader.CenterText = "Header";
        renderer.RenderingOptions.TextFooter.CenterText = "Page {page}";

        string html = "<h1>Custom PDF</h1><p>With margins and headers.</p>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("custom.pdf");
    }
}

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

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        renderer.RenderingOptions.MarginTop = 10;
        renderer.RenderingOptions.MarginBottom = 10;
        renderer.RenderingOptions.MarginLeft = 10;
        renderer.RenderingOptions.MarginRight = 10;
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.TextHeader.CenterText = "Header";
        renderer.RenderingOptions.TextFooter.CenterText = "Page {page}";

        string html = "<h1>Custom PDF</h1><p>With margins and headers.</p>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("custom.pdf");
    }
}

Imports IronPdf
Imports IronPdf.Rendering

Class Program
    Shared Sub Main(args As String())
        Dim renderer = New ChromePdfRenderer()

        renderer.RenderingOptions.MarginTop = 10
        renderer.RenderingOptions.MarginBottom = 10
        renderer.RenderingOptions.MarginLeft = 10
        renderer.RenderingOptions.MarginRight = 10
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
        renderer.RenderingOptions.TextHeader.CenterText = "Header"
        renderer.RenderingOptions.TextFooter.CenterText = "Page {page}"

        Dim html As String = "<h1>Custom PDF</h1><p>With margins and headers.</p>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("custom.pdf")
    End Sub
End Class

Ten przykład pokazuje różnicę w składni symboli zastępczych nagłówka/stopki.Playwrightużywa symbolów zastępczych opartych na klasach HTML (<span class='pageNumber'></span>), podczas gdyIronPDFużywa symbolów zastępczych w postaci nawiasów klamrowych ({page}). Należy pamiętać, żePlaywrightwymaga DisplayHeaderFooter = true do włączenia nagłówków/stopek, podczas gdyIronPDFwłącza je automatycznie po ustawieniu treści nagłówka/stopki.

Konwersja z trybu asynchronicznego na synchroniczny

Playwright wymaga stosowania async/await w całym kodzie;IronPDFobsługuje operacje synchroniczne:

// Playwright: Async required
public async Task<byte[]> GeneratePdfAsync(string html)
{
    using var playwright = await Playwright.CreateAsync();
    await using var browser = await playwright.Chromium.LaunchAsync();
    var page = await browser.NewPageAsync();
    await page.SetContentAsync(html);
    return await page.PdfAsync();
}

// IronPDF: Sync is simpler
public byte[] GeneratePdf(string html)
{
    var renderer = new ChromePdfRenderer();
    return renderer.RenderHtmlAsPdf(html).BinaryData;
}

// Playwright: Async required
public async Task<byte[]> GeneratePdfAsync(string html)
{
    using var playwright = await Playwright.CreateAsync();
    await using var browser = await playwright.Chromium.LaunchAsync();
    var page = await browser.NewPageAsync();
    await page.SetContentAsync(html);
    return await page.PdfAsync();
}

// IronPDF: Sync is simpler
public byte[] GeneratePdf(string html)
{
    var renderer = new ChromePdfRenderer();
    return renderer.RenderHtmlAsPdf(html).BinaryData;
}

Imports System.Threading.Tasks
Imports Microsoft.Playwright

Public Class PdfGenerator
    ' Playwright: Async required
    Public Async Function GeneratePdfAsync(html As String) As Task(Of Byte())
        Using playwright = Await Playwright.CreateAsync()
            Await Using browser = Await playwright.Chromium.LaunchAsync()
                Dim page = Await browser.NewPageAsync()
                Await page.SetContentAsync(html)
                Return Await page.PdfAsync()
            End Using
        End Using
    End Function

    ' IronPDF: Sync is simpler
    Public Function GeneratePdf(html As String) As Byte()
        Dim renderer = New ChromePdfRenderer()
        Return renderer.RenderHtmlAsPdf(html).BinaryData
    End Function
End Class

Konwersja jednostek marginesu

Playwright używa jednostek typu string;IronPDFużywa milimetrów:

Konwersja symboli zastępczych nagłówków/stopek

Eliminacja cyklu życia przeglądarki

Usuń cały kod zarządzania przeglądarką:

// Playwright: Explicit cleanup required
await page.CloseAsync();
await browser.CloseAsync();
playwright.Dispose();

// IronPDF: No disposal needed - just use the renderer
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

// Playwright: Explicit cleanup required
await page.CloseAsync();
await browser.CloseAsync();
playwright.Dispose();

// IronPDF: No disposal needed - just use the renderer
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

' Playwright: Explicit cleanup required
Await page.CloseAsync()
Await browser.CloseAsync()
playwright.Dispose()

' IronPDF: No disposal needed - just use the renderer
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")

Łączenie plików PDF

var pdf1 = renderer.RenderHtmlAsPdf(html1);
var pdf2 = renderer.RenderHtmlAsPdf(html2);
var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("merged.pdf");

var pdf1 = renderer.RenderHtmlAsPdf(html1);
var pdf2 = renderer.RenderHtmlAsPdf(html2);
var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("merged.pdf");

Dim pdf1 = renderer.RenderHtmlAsPdf(html1)
Dim pdf2 = renderer.RenderHtmlAsPdf(html2)
Dim merged = PdfDocument.Merge(pdf1, pdf2)
merged.SaveAs("merged.pdf")

Znaki wodne

pdf.ApplyWatermark("<h1 style='color:red; opacity:0.3;'>DRAFT</h1>");

pdf.ApplyWatermark("<h1 style='color:red; opacity:0.3;'>DRAFT</h1>");

IRON VB CONVERTER ERROR developers@ironsoftware.com

Ochrona hasłem

pdf.SecuritySettings.OwnerPassword = "admin";
pdf.SecuritySettings.UserPassword = "readonly";
pdf.SecuritySettings.AllowUserCopyPasteContent = false;

pdf.SecuritySettings.OwnerPassword = "admin";
pdf.SecuritySettings.UserPassword = "readonly";
pdf.SecuritySettings.AllowUserCopyPasteContent = false;

pdf.SecuritySettings.OwnerPassword = "admin"
pdf.SecuritySettings.UserPassword = "readonly"
pdf.SecuritySettings.AllowUserCopyPasteContent = False

Podpisy cyfrowe

var signature = new PdfSignature("certificate.pfx", "password");
pdf.Sign(signature);

var signature = new PdfSignature("certificate.pfx", "password");
pdf.Sign(signature);

Dim signature = New PdfSignature("certificate.pfx", "password")
pdf.Sign(signature)

Zgodność z PDF/A

pdf.SaveAsPdfA("archive.pdf", PdfAVersions.PdfA3b);

pdf.SaveAsPdfA("archive.pdf", PdfAVersions.PdfA3b);

pdf.SaveAsPdfA("archive.pdf", PdfAVersions.PdfA3b)

Przed migracją

• Zidentyfikuj cały kod generujący pliki PDF w Playwright
• Wartości marginesów dokumentu (przelicz cal/cm na milimetry)
• Zwróć uwagę na składnię symboli zastępczych nagłówka/stopki przy konwersji
• Uzyskaj klucz licencyjnyIronPDFze strony ironpdf.com

Zmiany w pakiecie

• Usuń pakiet NuGet Microsoft.Playwright
• Usuń folder .playwright, aby odzyskać około 400 MB miejsca na dysku
• Zainstaluj pakiet NuGet IronPdf: dotnet add package IronPdf

Zmiany w kodzie

• Zaktualizuj importy przestrzeni nazw
• Zastąp async browser lifecycle przez ChromePdfRenderer
• Zamień page.SetContentAsync() + page.PdfAsync() na RenderHtmlAsPdf()
• Zamień page.GotoAsync() + page.PdfAsync() na RenderUrlAsPdf()
• Zamień wartości marginesów na wartości w milimetrach
• Przekształć składnię symboli zastępczych nagłówków/stopek
• Usuń cały kod dotyczący zamykania przeglądarki/strony
• Dodaj inicjalizację licencji podczas uruchamiania aplikacji

Po migracji

• Wizualne porównanie pliku PDF
• Sprawdź renderowanie nagłówków/stopek wraz z numerami stron
• Sprawdź marginesy i dokładność rozmiaru strony
• W razie potrzeby dodaj nowe funkcje (zabezpieczenia, znaki wodne, scalanie)