Migrieren von Playwright zu IronPDF in C#

Playwright for .NET besser verstehen

Playwright for .NET ist Microsofts umfassendes Testframework und keine Dokumentengenerierungsbibliothek. Es wurde von Grund auf für automatisierte Tests auf Chromium-, Firefox- und WebKit-Browsern entwickelt. Playwright ist hervorragend im Testen von Szenarien: Klicken von Schaltflächen, Ausfüllen von Formularen, Abfangen von Netzwerkanfragen, Erstellen von Screenshots und Überprüfen der Browserkompatibilität.

Wichtiges Verständnis: Playwright ist ein Testwerkzeug, das für die PDF-Erstellung umfunktioniert wurde. Die PDF-Erstellung ist lediglich ein Nebeneffekt der Druckfunktion des Browsers (Strg+P) und kein primäres Designziel. Dies führt zu grundlegenden architektonischen Diskrepanzen:

• Testorientierte Architektur: Entwickelt für interaktive Browsertests, nicht für die Erstellung von Dokumenten ohne grafische Benutzeroberfläche
• Mehraufwand durch mehrere Browser: Es werden über 400 MB an Browser-Binärdateien (Chromium, Firefox, WebKit) heruntergeladen, selbst wenn nur die PDF-Generierung benötigt wird.
• Testzentrierte API: Komplexe asynchrone Muster, die für Testautomatisierungs-Workflows und nicht für die Dokumentengenerierung entwickelt wurden.
• Fehlende Dokumentfunktionen: Fehlende PDF/A-Konformität, digitale Signaturen, Wasserzeichen, Zusammenführung, Sicherheitskontrollen

Das Problem mit dem Testing Framework

Playwright wurde für End-to-End-Tests entwickelt, nicht für die Dokumentenerstellung. Dies führt zu grundlegenden Problemen bei der Verwendung für PDFs:

1. 400MB+ Browser-Downloads vor der ersten Verwendung erforderlich. Die Standardkonfiguration von Playwright erfordert das Herunterladen mehrerer Browser, was in Umgebungen mit strengen Ressourcenbeschränkungen ein Problem darstellen kann.

2. Komplexe asynchrone Muster mit Browser-Kontexten und Seitenverwaltung. Die Entwickler müssen mit Browser-Kontexten und der Seitenverwaltung vertraut gemacht werden, ebenso wie mit den richtigen Entsorgungspraktiken.

3. die Testing-first-Architektur ist nicht für die Dokumentenerstellung optimiert.

4. Einschränkungen beim Drucken in PDF entspricht Strg+P Browserdruck. Layouts können umbrochen werden, Hintergründe können standardmäßig weggelassen werden, und die Ausgabe wird für den Druck paginiert.

5. Keine Unterstützung von PDF/A oder PDF/UA für die Einhaltung der Barrierefreiheit. Playwright kann keine PDF/A- (Archivierung) oder PDF/UA- (Barrierefreiheit) konforme Dokumente erstellen. Für Section 508, EU-Richtlinien zur Barrierefreiheit oder langfristige Archivierungsanforderungen benötigen Sie eine spezielle PDF-Bibliothek.

6. Ressourcenintensive Operationen, die vollständige Browserinstanzen erfordern.

Das Problem der Testframework-Konfiguration

Playwright erfordert eine umfangreiche, testorientierte Konfiguration , die QA-Ingenieure verstehen, Dokumentationsentwickler aber nicht benötigen sollten:

Browserinstallation erforderlich:

# 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

Browser-Startkonfiguration:

// 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

Testspezifische Konfigurationsoptionen:

• Headless: Für den Produktivbetrieb muss der Headless-Modus konfiguriert werden (Standardeinstellung für Tests: Headed-Modus)
• SlowMo: Testzeitverzögerungen (irrelevant für die PDF-Generierung)
• Devtools: Konfiguration der Testwerkzeuge (für Dokumente nicht erforderlich)
• ExecutablePath: Benutzerdefinierte Browserpfade für Testumgebungen
• Proxy: Netzwerküberwachung zu Testzwecken (unnötiger Overhead)
• DownloadsPath: Testartefaktverwaltung
• TracesDir: Testausführungsprotokolle

Browserkontextverwaltung:

// 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

Komplexität durch mehrere Browser:

// 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

' 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: Keine Konfiguration, keine Installation

// 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")

Echte Plug-and-Play-Funktionalität:IronPDF eliminiert den gesamten Overhead von Test-Frameworks. Keine Browserinstallationsbefehle, keine Headless-Konfiguration, kein Kontextmanagement – ​​einfach instanziieren und rendern. Speziell für die Dokumentenerstellung entwickelt, nicht aus Testwerkzeugen adaptiert.

Playwright vs.IronPDF Leistungsvergleich

IronPDF wurde mit Schwerpunkt auf der PDF-Erstellung entwickelt. Im Gegensatz zum testzentrierten Playwright bietet IronPDF eine Vielzahl von dokumentenzentrierten API-Funktionen. Sie stützt sich auf eine einzige optimierte Chromium-Instanz, die die Effizienz fördert und sowohl synchrone als auch asynchrone Operationen ermöglicht. Dies führt zu einem einfacheren mentalen Modell und Arbeitsablauf für Entwickler, die PDF-Funktionen benötigen.

Für Teams, die die Einführung von .NET 10 und C# 14 bis 2025 und 2026 planen, bietet IronPDF eine speziell entwickelte PDF-Lösung, die den Overhead der Browser-Automatisierung eliminiert und gleichzeitig eine bessere Leistung und professionelle Dokumentenfunktionen bietet.

Fazit

Playwright ist Microsofts Testframework, das für QA-Ingenieure entwickelt wurde, die browserübergreifende automatisierte Tests durchführen. Die Verwendung zur PDF-Generierung stellt eine architektonische Inkompatibilität dar, die umfangreiche testspezifische Kenntnisse erfordert:

• Manuelle Browserinstallation (playwright install)
• Headless-Modus-Konfiguration für die Produktion
• Verwaltung der Browser-Startoptionen
• Konfiguration des Kontextlebenszyklus
• Downloads über mehrere Browser (400 MB+), obwohl nur einer benötigt wird
• Komplexe async/await-Muster aus dem Testparadigma

IronPDF ist eine Dokumentengenerierungsbibliothek, die für Entwickler konzipiert wurde, die PDF-Workflows erstellen. Es ist wirklich kinderleicht:

• Keine Installation erforderlich – funktioniert sofort
• Keine Konfiguration erforderlich – intelligente Standardeinstellungen
• Keine Browser-Downloads erforderlich – optimierte Engine inklusive
• Einfache API – keine Testkonzepte zu erlernen
• Automatische Ressourcenverwaltung – keine Komplexität im Lebenszyklus

Wenn Sie Webanwendungen browserübergreifend testen müssen, verwenden Sie Playwright. Wenn Sie PDF-Dokumente erstellen müssen, verwenden Sie IronPDF. Verwenden Sie für die Dokumentengenerierung kein Testframework, sondern das speziell für diese Aufgabe entwickelte Tool.

Voraussetzungen

1. .NET -Umgebung: .NET Framework 4.6.2+ oder .NET Core 3.1+ / .NET 5/6/7/8/9+
2. NuGet -Zugriff: Möglichkeit zur Installation von NuGet -Paketen
3. IronPDF -Lizenz: Ihren Lizenzschlüssel erhalten Sie unter IronPDF.

NuGet-Paketänderungen

# 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

Kein playwright install erforderlich bei IronPDF - die Rendering-Engine ist automatisch integriert.

Lizenz-Konfiguration

// 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"

Namensraumänderungen

// 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

Kern-API-Zuordnungen

Beispiel 1: Konvertierung von HTML-Strings in PDF

Vor (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

Nach (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

Dieses Beispiel verdeutlicht den grundlegenden architektonischen Unterschied. Playwright benötigt fünf asynchrone Operationen: Playwright.CreateAsync(), Chromium.LaunchAsync(), NewPageAsync(), SetContentAsync() und PdfAsync(), Plus eine explizite Browserbereinigung mit CloseAsync().

IronPDF beseitigt diese ganze Komplexität: Erstellen Sie ein ChromePdfRenderer, rufen Sie RenderHtmlAsPdf() und SaveAs() auf. Keine asynchronen Muster, kein Browser-Lebenszyklus, kein Cleanup-Code. Der Ansatz von IronPDF bietet eine sauberere Syntax und eine bessere Integration in moderne .NET-Anwendungen. Umfassende Beispiele finden Sie in der HTML to PDF Dokumentation.

Beispiel 2: Konvertierung von URL in PDF

Vor (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

Nach (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

Der Playwright verwendet GotoAsync(), um zu einer URL zu navigieren, gefolgt von PdfAsync().IronPDF bietet eine einzige RenderUrlAsPdf() Methode, die Navigation und PDF-Generierung in einem Aufruf übernimmt. Beachten Sie, dass Playwright die Angabe von Format in PagePdfOptions erfordert, während IronPDFRenderingOptions.PaperSize für die Papierformatkonfiguration verwendet. Erfahren Sie mehr in unseren Tutorials.

Beispiel 3: Benutzerdefinierte Seitengröße mit Rändern

Vor (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

Nach (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 verwendet zeichenkettenbasierte Randwerte ("1in", "0.5in"), während IronPDF numerische Millimeterwerte verwendet. Die Umrechnung lautet: 1 Zoll = 25,4 mm, daher wird "1in" zu 25 und "0.5in" wird ungefähr zu 12. Playwright's Format = "Letter" maps to IronPDF's PaperSize = PdfPaperSize.Letter.

Beispiel 4: Kopfzeilen, Fußzeilen und benutzerdefinierte Einstellungen

Vor (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

Nach (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

Dieses Beispiel zeigt den Unterschied in der Syntax von Kopf- und Fußzeilenplatzhaltern. Playwright verwendet HTML-klassenbasierte Platzhalter (<span class='pageNumber'></span>), während IronPDF geschweifte Klammerplatzhalter verwendet ({page}). Beachten Sie, dass PlaywrightDisplayHeaderFooter = true benötigt, um Kopf- und Fußzeilen zu aktivieren, während IronPDF diese automatisch aktiviert, wenn Sie den Inhalt für Kopf- und Fußzeilen festlegen.

Async zu Sync Konvertierung

Playwright erfordert durchgehend async/await;IronPDF unterstützt synchrone Operationen:

// 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

Umrechnung von Maßeinheiten

Playwright verwendet String-Einheiten;IronPDF arbeitet mit numerischen Millimetern:

Kopf-/Fußzeilen-Platzhalter-Konvertierung

Eliminierung des Browser-Lebenszyklus

Entfernen Sie den gesamten Browser-Verwaltungscode:

// 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")

PDF-Zusammenführung

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")

Wasserzeichen

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

Passwortschutz

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

Digitale Signaturen

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)

PDF/A-Konformität

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

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

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

Vor der Migration

• Identifizieren Sie den gesamten PDF-Generierungscode für Playwright.
• Dokumentrandwerte (Zoll/cm in Millimeter umrechnen)
• Beachten Sie die Syntax für Kopf-/Fußzeilenplatzhalter zur Konvertierung
• Den IronPDF Lizenzschlüssel erhalten Sie unter IronPDF

Paketänderungen

• Entfernen Sie das NuGet Paket Microsoft.Playwright Löschen Sie den Ordner .playwright, um ca. 400 MB Speicherplatz freizugeben.
• Installieren Sie das NuGet Paket IronPdf: dotnet add package IronPdf

Code-Änderungen

• Namespace-Importe aktualisieren
• Ersetzen Sie den asynchronen Browserlebenszyklus durch ChromePdfRenderer
• Konvertiere page.SetContentAsync() + page.PdfAsync() in RenderHtmlAsPdf()
• Konvertiere page.GotoAsync() + page.PdfAsync() in RenderUrlAsPdf()
• Randzeichenketten in Millimeterwerte umwandeln
• Syntax für Kopf-/Fußzeilenplatzhalter konvertieren
• Entfernen Sie jeglichen Browser-/Seitenfreigabecode.
• Lizenzinitialisierung beim Anwendungsstart hinzufügen

Nach der Migration

• Visueller Vergleich der PDF-Ausgabe
• Überprüfen Sie die Darstellung von Kopf- und Fußzeilen mit Seitenzahlen
• Testen Sie die Genauigkeit von Rändern und Seitengrößen.
• Fügen Sie bei Bedarf neue Funktionen hinzu (Sicherheit, Wasserzeichen, Zusammenführung).