WebGL-Inhalte in PDFs mit IronPDF rendern

Dramatikerfor .NET besser verstehen

Playwright for .NET (NuGet Microsoft.Playwright, MIT-lizenziert) ist Microsofts Framework für Browserautomatisierung, das hauptsächlich für End-to-End-Tests über Chromium, Firefox und WebKit konzipiert ist. Sein typisches Arbeitslasten sind interaktiv: Klicken auf Schaltflächen, Ausfüllen von Formularen, Abfangen von Netzwerk-Anfragen, Erstellen von Screenshots und Überprüfen der Browserkompatibilität.

Die PDF-Erstellung in Dramatikerist eine sekundäre Funktion, die über Page.PdfAsync() verfügbar gemacht wird und wird nur auf Chromium unterstützt - Firefox und WebKit implementieren keine PDF-Ausgabe. Die Ausgabe verwendet den Druck-zu-PDF-Pfad des Browsers (entspricht Strg+P), was Implikationen für Layouts, Hintergründe und Paginierungen hat:

• Testorientierte Architektur, nicht optimiert für headless Dokumentenproduktion
• Browser-Binärdateien (Chromium plus optional Firefox und WebKit) müssen separat über playwright install installiert werden.
• Asynchrone API, entwickelt für Testautomatisierungs-Workflows
• Keine integrierte PDF/A-, PDF/UA-, digitale Signatur-, Wasserzeichen-, Zusammenführungs- oder Sicherheitsfunktionen

Überlegungen beim Einsatz von Dramatikerfür PDFs

Playwright wurde für End-to-End-Tests entwickelt, nicht für die Dokumentenerstellung. Einige praktische Implikationen bei der Zweckentfremdung für PDFs:

1. Browser-Binärdateien über playwright install. Die Standardkonfiguration von Dramatikerlädt Browser-Binärdateien (Chromium, Firefox, WebKit) herunter, was für Umgebungen mit strikten Ressourcen- oder Bereitstellungseinschränkungen berücksichtigt werden kann.

2. Asynchrones Browser-/Kontext-/Seitenmodell. Entwickler müssen sich mit Browser-Kontexten und Seiten-Lifecycle-Management, einschließlich Entsorgung, auskennen.

3. Testorientierte Architektur, nicht optimiert für die hohe Volumen-Dokumentenerzeugung.

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

5. Keine PDF/A- oder PDF/UA-Ausgabe. Dramatikerproduziert keine PDF/A (Archivierung) oder PDF/UA (Barrierefreiheit) konformen Dokumente. Für Section-508-, EU-Zugänglichkeitsrichtlinien- oder langfristige Archivierungsanforderungen ist in der Regel eine dedizierte PDF-Bibliothek erforderlich.

6. Pro-Render-Browser-Ressourcenverbrauch bei jedem PDF, das Browser-Kontexte und -Seiten initiiert.

Konfigurationsoberfläche

Playwright bietet eine Konfigurationsoberfläche, die auf Testautomatisierung ausgerichtet ist. Die Teile, die am relevantesten sind, wenn es nur für die PDF-Erstellung verwenden wird:

Schritt zur Browser-Installation:

# Separate installation step before first use
playwright install            # Downloads browser binaries (Chromium, Firefox, WebKit)
# Or for a single browser:
playwright install chromium   # Chromium-only (the only engine that supports PDF output)

# Separate installation step before first use
playwright install            # Downloads browser binaries (Chromium, Firefox, WebKit)
# Or for a single browser:
playwright install chromium   # Chromium-only (the only engine that supports PDF output)

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: Muss den Headless-Modus für die Produktion konfigurieren (Standardmäßig ist headed für Tests)
• SlowMo: Testzeit-Verzögerungen (für die PDF-Erstellung irrelevant)
• Devtools: Testwerkzeugkonfiguration (nicht für Dokumente benötigt)
• ExecutablePath: Benutzerdefinierte Browserpfade für Testumgebungen
• Proxy: Netzwerkabfangung für Tests (unnötiger Overhead)
• DownloadsPath: Test-Artefaktverwaltung
• TracesDir: Testausführungs-Traces

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

Multi-Browser-Oberfläche:

// Dramatikersupports launching multiple engines
await playwright.Chromium.LaunchAsync();  // For Chromium-based testing (and PDF output)
await playwright.Firefox.LaunchAsync();   // For Firefox testing
await playwright.Webkit.LaunchAsync();    // For WebKit/Safari testing
// Note: Page.PdfAsync() is implemented on Chromium only.

// Dramatikersupports launching multiple engines
await playwright.Chromium.LaunchAsync();  // For Chromium-based testing (and PDF output)
await playwright.Firefox.LaunchAsync();   // For Firefox testing
await playwright.Webkit.LaunchAsync();    // For WebKit/Safari testing
// Note: Page.PdfAsync() is implemented on Chromium only.

IronPDF: einzelner gebündelter Renderer

// No separate browser-binary install or context management
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

// No separate browser-binary install or context management
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")

IronPDF liefert seine Rendering-Engine im NuGet-Paket, sodass kein separater playwright install Schritt erforderlich ist und kein Browser-/Kontext-/Seiten-Lebenszyklus zu verwalten ist.

Dramatikervs.IronPDF Leistungsvergleich

IronPDF ist speziell für die PDF-Erstellung gebaut, mit einer dokumentzentrierten API-Oberfläche. Es verwendet eine einzige gebündelte Chromium-basierte Rendering-Engine und unterstützt sowohl synchrone als auch asynchrone Operationen, was Entwicklern ein einfacheres mentales Modell gibt, wenn PDF-Ausgabe — nicht Browser-Interaktion — das Ziel ist.

Fazit

Playwright eignet sich gut, wenn die primäre Arbeitslast die Browserautomatisierung oder der Cross-Browser-Test ist, mit PDF-Ausgabe als gelegentliche sekundäre Aufgabe.IronPDF ist die bessere Wahl, wenn die PDF-Erzeugung die primäre Arbeitslast ist: es gibt keinen separaten Browser-Binär-Installationsschritt, keinen Browser-/Kontext-/Seiten-Lifecycle zu verwalten, und Dokumentfunktionen wie PDF/A, digitale Signaturen, Sicherheit und Zusammenführung sind direkt verfügbar.

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 the downloaded browser binaries
# Delete the .playwright folder in your project (and any cached binaries
# under your user profile, e.g. %USERPROFILE%\.cache\ms-playwright on Windows)

# Add IronPDF
dotnet add package IronPdf

# Remove Playwright
dotnet remove package Microsoft.Playwright

# Remove the downloaded browser binaries
# Delete the .playwright folder in your project (and any cached binaries
# under your user profile, e.g. %USERPROFILE%\.cache\ms-playwright on Windows)

# Add IronPDF
dotnet add package IronPdf

Kein playwright install erforderlich mit IronPDF - Die Rendering-Engine wird automatisch gebündelt.

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 (Dramatiker):

// 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. Dramatikerbenötigt fünf asynchrone Operationen: Playwright.CreateAsync(), Chromium.LaunchAsync(), NewPageAsync(), SetContentAsync() und PdfAsync(), plus explizite Browserbereinigung mit CloseAsync().

IronPDF eliminiert diese Komplexität: erstellen Sie ein ChromePdfRenderer, rufen Sie RenderHtmlAsPdf() auf und SaveAs(). 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 (Dramatiker):

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

Playwright verwendet GotoAsync(), um zu einer URL zu navigieren, gefolgt von PdfAsync().IronPDF bietet eine einzige RenderUrlAsPdf() Methode, die in einem Aufruf sowohl Navigation als auch PDF-Erstellung abwickelt. Beachten Sie, dass Dramatikererfordert, dass die Format in PagePdfOptions angegeben wird, während IronPDFRenderingOptions.PaperSize für die Papiergrößenkonfiguration verwendet. Erfahren Sie mehr in unseren Tutorials.

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

Vor (Dramatiker):

// 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 string-basierte Margin-Werte ("1in", "0.5in"), während IronPDF numerische Millimeterwerte verwendet. Die Umrechnung ist: 1 Zoll = 25,4 mm, also wird "1in" zu 25 und "0.5in" wird ungefähr zu 12. Playwright's Format = "Letter" wird auf IronPDF's PaperSize = PdfPaperSize.Letter abgebildet.

Beispiel 4: Kopfzeilen, Fußzeilen und benutzerdefinierte Einstellungen

Vor (Dramatiker):

// 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. Dramatikerverwendet HTML-Klassen-basierte Platzhalter (<span class='pageNumber'></span>), während IronPDF geschweifte Klammer-Platzhalter ({page}) verwendet. Beachten Sie, dass DramatikerDisplayHeaderFooter = true erfordert, um Kopf-/Fußzeilen zu aktivieren, während IronPDF sie automatisch aktiviert, wenn Sie Kopf-/Fußzeileninhalte 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 Dramatiker.
• 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 Microsoft.Playwright NuGet-Paket
• Löschen Sie den .playwright Ordner (und alle zwischengespeicherten Playwright-Browser-Binärdateien unter Ihrem Benutzerprofil)
• Installieren Sie das IronPdf NuGet-Paket: dotnet add package IronPdf

Code-Änderungen

• Namespace-Importe aktualisieren
• Ersetzen Sie den asynchronen Browser-Lebenszyklus durch ChromePdfRenderer
• Konvertieren Sie page.SetContentAsync() + page.PdfAsync() zu RenderHtmlAsPdf()
• Konvertieren Sie page.GotoAsync() + page.PdfAsync() zu 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).