Die Migration von Microsoft Dramatikerfor .NET zu IronPDF verschiebt Ihren PDF-Erstellungs-Workflow von einem Browser-Automatisierungs-Framework zu einer speziell entwickelten PDF-Bibliothek. Diese Anleitung bietet einen Schritt-für-Schritt-Migrationspfad, der die asynchrone Lebenszyklusverwaltung des Browsers entfernt und den separaten playwright install Schritt für das Herunterladen der Browser-Binärdateien.
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:
playwright install installiert werden.Playwright wurde für End-to-End-Tests entwickelt, nicht für die Dokumentenerstellung. Einige praktische Implikationen bei der Zweckentfremdung für PDFs:
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.
Asynchrones Browser-/Kontext-/Seitenmodell. Entwickler müssen sich mit Browser-Kontexten und Seiten-Lifecycle-Management, einschließlich Entsorgung, auskennen.
Testorientierte Architektur, nicht optimiert für die hohe Volumen-Dokumentenerzeugung.
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.
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.
Pro-Render-Browser-Ressourcenverbrauch bei jedem PDF, das Browser-Kontexte und -Seiten initiiert.
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)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 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 UsingTestspezifische 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 TestumgebungenProxy: Netzwerkabfangung für Tests (unnötiger Overhead)DownloadsPath: Test-ArtefaktverwaltungTracesDir: Testausführungs-TracesBrowserkontextverwaltung:
// 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 requiredMulti-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.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");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.
| Metrik | Dramatiker | IronPDF |
|---|---|---|
| Primärer Zweck | E2E-Browserautomatisierungs-Framework | PDF-Dokumentenerzeugung |
| Designphilosophie | Testorientiert; PDF ist eine sekundäre Funktion | Speziell entwickelte PDF-Bibliothek |
| NuGet-Paket | Microsoft.Playwright (MIT) | IronPdf (kommerziell) |
| Browser-Binär-Schritt | Separates playwright install Herunterladen | Gebündelt im NuGet-Paket |
| Unterstützende Engines für PDF | Nur Chromium (Firefox / WebKit implementieren Page.PdfAsync() nicht) | Einzelner gebündelter Chromium-basierter Renderer |
| Erster Render (Kaltstart) | 4.5 Sekunden | 2.8 Sekunden |
| Nachfolgende Renderings | 3.8-4.1 Sekunden | 0.8-1.2 Sekunden |
| Speicher pro Konvertierung | 280-420MB | 80-120MB |
| API-Stil | Asynchroner Browser/Kontext/Seiten-Lebenszyklus | Synchron oder asynchron; renderer-based |
| Initialisierung | CreateAsync() + LaunchAsync() + NewPageAsync() | new ChromePdfRenderer() |
| PDF/A-Unterstützung | Nicht verfügbar | Unterstützt |
| PDF/UA Barrierefreiheit | Nicht verfügbar | Unterstützt |
| Digitale Signaturen | Nicht verfügbar | Unterstützt |
| PDF-Bearbeitung | Nicht verfügbar | Zusammenführen, teilen, stempeln, bearbeiten |
| Unterstützungsmodell | Gemeinschaft | Kommerziell mit SLA |
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.
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.
# 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 IronPdfKein playwright install erforderlich mit IronPDF - Die Rendering-Engine wird automatisch gebündelt.
// Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";' Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"// 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| Playwright-API | IronPDF API |
|---|---|
Playwright.CreateAsync() | new ChromePdfRenderer() |
playwright.Chromium.LaunchAsync() | Nicht erforderlich |
browser.NewPageAsync() | Nicht erforderlich |
page.GotoAsync(url) | renderer.RenderUrlAsPdf(url) |
page.SetContentAsync(html) + page.PdfAsync() | renderer.RenderHtmlAsPdf(html) |
page.CloseAsync() | Nicht erforderlich |
browser.CloseAsync() | Nicht erforderlich |
PagePdfOptions.Format | RenderingOptions.PaperSize |
PagePdfOptions.Margin | RenderingOptions.MarginTop/Bottom/Left/Right |
PagePdfOptions.DisplayHeaderFooter | TextFooter |
PagePdfOptions.HeaderTemplate | RenderingOptions.HtmlHeader |
PagePdfOptions.FooterTemplate | RenderingOptions.HtmlFooter |
<span class='pageNumber'> | {page} |
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
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 ModuleNach (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
Imports IronPdf
Module Program
Sub Main(args As String())
Dim renderer As 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 ModuleDieses 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.
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
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 ModuleNach (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
Imports IronPdf
Module Program
Sub Main(args As String())
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderUrlAsPdf("https://www.example.com")
pdf.SaveAs("webpage.pdf")
End Sub
End ModulePlaywright 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.
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" }
});
}
}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 ModuleNach (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");
}
}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 ClassPlaywright 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.
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
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 ModuleNach (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
Imports IronPdf
Imports IronPdf.Rendering
Module Program
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 ModuleDieses 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.
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;
}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 ClassPlaywright verwendet String-Einheiten;IronPDF arbeitet mit numerischen Millimetern:
| Dramatiker | IronPDF(mm) |
|---|---|
"1in" | 25 |
"0.5in" | 12 |
"1cm" | 10 |
| Dramatiker-Klasse | IronPDF Platzhalter |
|---|---|
<span class='pageNumber'> | {page} |
<span class='totalPages'> | {total-pages} |
<span class='date'> | {date} |
<span class='title'> | {html-title} |
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
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")Nach der Migration zu IronPDF erhalten Sie Funktionen, die Dramatikernicht bieten kann:
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")pdf.ApplyWatermark("<h1 style='color:red; opacity:0.3;'>DRAFT</h1>");IRON VB CONVERTER ERROR developers@ironsoftware.compdf.SecuritySettings.OwnerPassword = "admin";
pdf.SecuritySettings.UserPassword = "readonly";
pdf.SecuritySettings.AllowUserCopyPasteContent = false;pdf.SecuritySettings.OwnerPassword = "admin"
pdf.SecuritySettings.UserPassword = "readonly"
pdf.SecuritySettings.AllowUserCopyPasteContent = Falsevar signature = new PdfSignature("certificate.pfx", "password");
pdf.Sign(signature);Dim signature = New PdfSignature("certificate.pfx", "password")
pdf.Sign(signature)pdf.SaveAsPdfA("archive.pdf", PdfAVersions.PdfA3b);pdf.SaveAsPdfA("archive.pdf", PdfAVersions.PdfA3b)Microsoft.Playwright NuGet-Paket.playwright Ordner (und alle zwischengespeicherten Playwright-Browser-Binärdateien unter Ihrem Benutzerprofil)IronPdf NuGet-Paket: dotnet add package IronPdfChromePdfRendererpage.SetContentAsync() + page.PdfAsync() zu RenderHtmlAsPdf()page.GotoAsync() + page.PdfAsync() zu RenderUrlAsPdf()
Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender Handbücher.
IronPDF ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Wenn Ihr PDF wie HTML aussehen soll, schnell.
