Iron Suite for .NET

10 .NET-Bibliotheken. Eine komplette Dokumenten-Suite.

Entdecken Sie Iron Suite

IRONPDF

IRONWORD

IRONXL

IRONPPT

IRONOCR

IRONBARCODE

IRONQR

IRONPRINT

IRONZIP

IRONWEBSCRAPER

VERGLEICH

RawPrint .NET vs. IronPDF: Leitfaden für einen technischen Vergleich

Curtis Chau

Updated: 21. April 2026

Wenn .NET-Entwickler HTML-Inhalte in PDF konvertieren müssen, erscheint Microsofts WebView2-Steuerelement aufgrund seiner Chromium-basierten Rendering-Engine manchmal als eine mögliche Lösung. Bei WebView2handelt es sich jedoch im Wesentlichen um ein Steuerelement zur Browsereinbettung, das für UI-Anwendungen entwickelt wurde, und nicht um eine Bibliothek zur PDF-Erzeugung. Dieser technische Vergleich untersucht WebView2neben IronPDF, um Architekten und Entwicklern zu helfen, die entscheidenden Unterschiede zwischen der Einbettung eines Browser-Steuerelements für die PDF-Ausgabe und der Verwendung einer speziell entwickelten PDF-Bibliothek zu verstehen.

WebView2 verstehen

WebView2 (Microsoft Edge) ist ein vielseitiges, einbettbares Browser-Steuerelement, das die Edge/Chromium-Engine in native Windows-Anwendungen integriert. Dieses Steuerelement unterstützt das Browsing-Erlebnis des Microsoft Edge-Browsers innerhalb eines eingeschränkten Ökosystems und bietet die Einhaltung moderner Webstandards für die Anzeige von HTML5-, CSS3- und JavaScript-Inhalten.

Die PDF-Erzeugungsfähigkeit von WebView2existiert durch seine PrintToPdfAsync Methode und die Integration des DevTools-Protokolls. Diese Funktionalität ist jedoch eher ein nachträglicher Aspekt als ein Hauptmerkmal:

Browser Control Architecture: Entwickelt für die Einbettung von Webinhalten in UI-Anwendungen, nicht für die serverseitige PDF-Erzeugung
Nur-Windows-Plattform: Keine Unterstützung für Linux, macOS, Docker oder Cloud-Umgebungen
UI-Thread-Anforderung: Muss auf STA-Thread mit Message Pump laufen - kann nicht in Webservern oder APIs arbeiten
Edge Runtime-Abhängigkeit: Edge WebView2Runtime muss auf dem Zielrechner installiert sein
Kein Headless-Modus: Erstellt immer UI-Elemente, auch wenn sie ausgeblendet sind

Einschränkungen von WebView2 bei der PDF-Erzeugung

Die Dokumentation des Migrationsleitfadens identifiziert kritische Probleme bei der Verwendung von WebView2zur PDF-Erzeugung:

Problem	Auswirkungen	Schweregrad
Speicherlecks	WebView2hat Speicherlecks in langlaufenden Prozessen dokumentiert	KRITISCH
Nur für Windows	Keine Unterstützung für Linux, macOS, Docker oder Cloud-Umgebungen	KRITISCH
UI Thread erforderlich	Muss auf STA Thread mit Message Pump laufen	KRITISCH
Nicht für PDFs konzipiert	`PrintToPdfAsync` ist ein Nachgedanke	HOCH
Instabil in Dienstleistungen	Häufige Abstürze und Hänger bei Windows-Diensten	HOCH
Komplexer asynchroner Fluss	Navigationsereignisse, Rückrufe zum Abschluss, Race Conditions	HOCH
Edge Runtime-Abhängigkeit	Erfordert Edge WebView2Runtime auf dem Zielrechner	MEDIUM
Kein Headless-Modus	Erstellt immer UI-Elemente, auch wenn sie versteckt sind	MEDIUM

IronPDF verstehen

IronPDF ist eine PDF-Bibliothek, die speziell für die PDF-Erzeugung aus HTML- und Web-Inhalten entwickelt wurde. Im Gegensatz zum Browser-Embedding-Ansatz von WebView2bietet IronPDF eine eigene PDF-Generierungs-Engine mit plattformübergreifender Unterstützung und serverseitigen Funktionen.

Zu den wichtigsten Merkmalen gehören:

Zweckgebundene PDF-Bibliothek: Von Grund auf für die PDF-Erzeugung und nicht für die Einbettung in die Benutzeroberfläche konzipiert
Plattformübergreifende Unterstützung: Windows, Linux, macOS, Docker, iOS und Android
Beliebiger Thread-Betrieb: Keine STA-Thread- oder Message-Pump-Anforderungen
Server/Cloud Ready: Unterstützt für ASP.NET Core, Azure, AWS, GCP und Docker
Keine externen Abhängigkeiten: Eigenständig, keine Laufzeitinstallationen erforderlich
Umfassende PDF-Funktionen: Kopf-/Fußzeilen, Wasserzeichen, Zusammenführen/Splitten, digitale Signaturen, PDF/A-Konformität

Funktionsvergleich

Die folgende Tabelle zeigt die grundlegenden Unterschiede zwischen WebView2und IronPDF:

Feature	WebView2	IronPDF
Zweck	Browser-Steuerung (UI)	PDF-Bibliothek (entwickelt für PDF)
Produktionsreif	NO	YES
Speichermanagement	Lecks in langlaufenden	Stabil, ordnungsgemäß entsorgt
Windows, Linux, macOS, Docker, Azure, AWS.	Nur für Windows	Windows, Linux, macOS, Docker
Thread-Anforderungen	STA + Message Pump	Jedes Thema
Server/Cloud	Nicht unterstützt	Unterstützt
Azure/AWS/GCP	Problematisch	Funktioniert perfekt
Docker	Nicht möglich	Offizielle Bilder verfügbar
ASP.NET Core	Kann nicht arbeiten	Erstklassige Unterstützung
Hintergrunddienste	Unstabil	Stabile
Konsolenanwendungen	Komplexe Hacks	Ja
WinForms/WPF	Ja	Ja
Kopf-/Fußzeilen	NO	Ja (HTML)
Wasserzeichen	NO	Ja
PDFs zusammenführen	NO	Ja
PDFs aufteilen	NO	Ja
Digitale Signaturen	NO	Ja
Passwortschutz	NO	Ja
PDF/A-Konformität	NO	Ja
Formularausfüllen	NO	Ja
Professionelle Unterstützung	Nicht für PDF-Verwendung	Ja
Dokumentation	Begrenzte PDF-Dokumente	Umfangreiche

Unterschiede in der API-Architektur

Die architektonischen Unterschiede zwischen WebView2und IronPDF werden sofort deutlich, wenn man sich ansieht, wie beide Ansätze die PDF-Erzeugung handhaben.

WebView2 Komplexes Async-Muster

WebView2 erfordert einen mehrstufigen asynchronen Prozess, der die Initialisierung des Browsers, die Navigation, die Ereignisbehandlung und die Aufrufe des DevTools-Protokolls umfasst:

// NuGet: Install-Package Microsoft.Web.WebView2.WinForms
using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.Web.WebView2.WinForms;
using Microsoft.Web.WebView2.Core;

class Program
{
    static async Task Main()
    {
        var webView = new WebView2();
        await webView.EnsureCoreWebView2Async();
        
        webView.CoreWebView2.NavigateToString("<html><body><h1>Hello World</h1></body></html>");
        await Task.Delay(2000);
        
        await webView.CoreWebView2.CallDevToolsProtocolMethodAsync(
            "Page.printToPDF",
            "{}"
        );
    }
}

// NuGet: Install-Package Microsoft.Web.WebView2.WinForms
using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.Web.WebView2.WinForms;
using Microsoft.Web.WebView2.Core;

class Program
{
    static async Task Main()
    {
        var webView = new WebView2();
        await webView.EnsureCoreWebView2Async();
        
        webView.CoreWebView2.NavigateToString("<html><body><h1>Hello World</h1></body></html>");
        await Task.Delay(2000);
        
        await webView.CoreWebView2.CallDevToolsProtocolMethodAsync(
            "Page.printToPDF",
            "{}"
        );
    }
}

' NuGet: Install-Package Microsoft.Web.WebView2.WinForms
Imports System
Imports System.IO
Imports System.Threading.Tasks
Imports Microsoft.Web.WebView2.WinForms
Imports Microsoft.Web.WebView2.Core

Module Program
    Async Function Main() As Task
        Dim webView As New WebView2()
        Await webView.EnsureCoreWebView2Async()

        webView.CoreWebView2.NavigateToString("<html><body><h1>Hello World</h1></body></html>")
        Await Task.Delay(2000)

        Await webView.CoreWebView2.CallDevToolsProtocolMethodAsync(
            "Page.printToPDF",
            "{}"
        )
    End Function
End Module

' NuGet: Install-Package Microsoft.Web.WebView2.WinForms
Imports System
Imports System.IO
Imports System.Threading.Tasks
Imports Microsoft.Web.WebView2.WinForms
Imports Microsoft.Web.WebView2.Core

Module Program
    Async Function Main() As Task
        Dim webView As New WebView2()
        Await webView.EnsureCoreWebView2Async()

        webView.CoreWebView2.NavigateToString("<html><body><h1>Hello World</h1></body></html>")
        Await Task.Delay(2000)

        Await webView.CoreWebView2.CallDevToolsProtocolMethodAsync(
            "Page.printToPDF",
            "{}"
        )
    End Function
End Module

Dieser Code demonstriert mehrere WebView2-Komplexitäten: explizite Initialisierung über EnsureCoreWebView2Async(), Navigation mit NavigateToString(), beliebige Verzögerungen, um auf das Laden von Inhalten zu warten, und Low-Level-DevTools-Protokollaufrufe. Das Task.Delay stellt eine unzuverlässige Vermutung dar, wann der Inhalt bereit ist – eine erwartete Race-Condition.

IronPDF Vereinfachter Ansatz

IronPDF beseitigt diese Komplexität mit einem unkomplizierten Ansatz, der nur eine Methode umfasst:

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1></body></html>");
        pdf.SaveAs("output.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1></body></html>");
        pdf.SaveAs("output.pdf");
    }
}

Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1></body></html>")
        pdf.SaveAs("output.pdf")
    End Sub
End Class

Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1></body></html>")
        pdf.SaveAs("output.pdf")
    End Sub
End Class

Die Klasse ChromePdfRenderer behandelt die gesamte Rendering-Komplexität intern. Keine Initialisierungszeremonie, keine Navigationsereignisse, keine Zeitschätzungen. Eine umfassende Anleitung zur HTML-Konvertierung finden Sie im HTML to PDF tutorial.

URL zu PDF Konvertierung

Die Konvertierung von Webseiten in PDF-Dokumente verdeutlicht den Komplexitätsunterschied zwischen WebView2und IronPDF.

WebView2 Implementierung

WebView2 erfordert die Behandlung von Navigationsereignissen, Vervollständigungs-Callbacks und die manuelle PDF-Extraktion:

// NuGet: Install-Package Microsoft.Web.WebView2.WinForms
using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.Web.WebView2.WinForms;
using Microsoft.Web.WebView2.Core;

class Program
{
    static async Task Main()
    {
        var webView = new WebView2();
        await webView.EnsureCoreWebView2Async();
        
        var tcs = new TaskCompletionSource<bool>();
        webView.CoreWebView2.NavigationCompleted += (s, e) => tcs.SetResult(true);
        
        webView.CoreWebView2.Navigate("https://example.com");
        await tcs.Task;
        await Task.Delay(1000);
        
        var result = await webView.CoreWebView2.CallDevToolsProtocolMethodAsync(
            "Page.printToPDF",
            "{\"printBackground\": true}"
        );
        
        var base64 = System.Text.Json.JsonDocument.Parse(result).RootElement.GetProperty("data").GetString();
        File.WriteAllBytes("output.pdf", Convert.FromBase64String(base64));
    }
}

// NuGet: Install-Package Microsoft.Web.WebView2.WinForms
using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.Web.WebView2.WinForms;
using Microsoft.Web.WebView2.Core;

class Program
{
    static async Task Main()
    {
        var webView = new WebView2();
        await webView.EnsureCoreWebView2Async();
        
        var tcs = new TaskCompletionSource<bool>();
        webView.CoreWebView2.NavigationCompleted += (s, e) => tcs.SetResult(true);
        
        webView.CoreWebView2.Navigate("https://example.com");
        await tcs.Task;
        await Task.Delay(1000);
        
        var result = await webView.CoreWebView2.CallDevToolsProtocolMethodAsync(
            "Page.printToPDF",
            "{\"printBackground\": true}"
        );
        
        var base64 = System.Text.Json.JsonDocument.Parse(result).RootElement.GetProperty("data").GetString();
        File.WriteAllBytes("output.pdf", Convert.FromBase64String(base64));
    }
}

' NuGet: Install-Package Microsoft.Web.WebView2.WinForms
Imports System
Imports System.IO
Imports System.Threading.Tasks
Imports Microsoft.Web.WebView2.WinForms
Imports Microsoft.Web.WebView2.Core

Module Program
    Async Function Main() As Task
        Dim webView As New WebView2()
        Await webView.EnsureCoreWebView2Async()

        Dim tcs As New TaskCompletionSource(Of Boolean)()
        AddHandler webView.CoreWebView2.NavigationCompleted, Sub(s, e) tcs.SetResult(True)

        webView.CoreWebView2.Navigate("https://example.com")
        Await tcs.Task
        Await Task.Delay(1000)

        Dim result As String = Await webView.CoreWebView2.CallDevToolsProtocolMethodAsync(
            "Page.printToPDF",
            "{""printBackground"": true}"
        )

        Dim base64 As String = System.Text.Json.JsonDocument.Parse(result).RootElement.GetProperty("data").GetString()
        File.WriteAllBytes("output.pdf", Convert.FromBase64String(base64))
    End Function
End Module

' NuGet: Install-Package Microsoft.Web.WebView2.WinForms
Imports System
Imports System.IO
Imports System.Threading.Tasks
Imports Microsoft.Web.WebView2.WinForms
Imports Microsoft.Web.WebView2.Core

Module Program
    Async Function Main() As Task
        Dim webView As New WebView2()
        Await webView.EnsureCoreWebView2Async()

        Dim tcs As New TaskCompletionSource(Of Boolean)()
        AddHandler webView.CoreWebView2.NavigationCompleted, Sub(s, e) tcs.SetResult(True)

        webView.CoreWebView2.Navigate("https://example.com")
        Await tcs.Task
        Await Task.Delay(1000)

        Dim result As String = Await webView.CoreWebView2.CallDevToolsProtocolMethodAsync(
            "Page.printToPDF",
            "{""printBackground"": true}"
        )

        Dim base64 As String = System.Text.Json.JsonDocument.Parse(result).RootElement.GetProperty("data").GetString()
        File.WriteAllBytes("output.pdf", Convert.FromBase64String(base64))
    End Function
End Module

Diese Implementierung erfordert die Erstellung eines TaskCompletionSource, um die Navigation zu verfolgen, das Abonnieren von NavigationCompleted Ereignissen, das Parsen von JSON-Antworten vom DevTools-Protokoll und das Handling des Base64-Decodings. Das zusätzliche Task.Delay(1000) nach Abschluss der Navigation versucht sicherzustellen, dass JavaScript die Ausführung beendet hat – ein weiteres unzuverlässiges Timing-Hack.

IronPDF Implementierung

IronPDF bietet direktes URL-Rendering mit einem einzigen Methodenaufruf:

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://example.com");
        pdf.SaveAs("output.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://example.com");
        pdf.SaveAs("output.pdf");
    }
}

Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderUrlAsPdf("https://example.com")
        pdf.SaveAs("output.pdf")
    End Sub
End Class

Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderUrlAsPdf("https://example.com")
        pdf.SaveAs("output.pdf")
    End Sub
End Class

Die RenderUrlAsPdf-Methode verwaltet intern die Navigation, die Ausführung von JavaScript und das Laden von Inhalten. Keine Ereignisabonnements, keine Zeiteinschätzungen, kein Base64-Parsing.

Benutzerdefinierte PDF-Einstellungen und Optionen

Durch die Konfiguration von Seitenabmessungen, Rändern und Ausrichtung lassen sich signifikante Unterschiede in der API-Nutzbarkeit feststellen.

WebView2 DevTools Protokoll Konfiguration

WebView2 erfordert JSON-Serialisierung und DevTools-Protokollparameter:

// NuGet: Install-Package Microsoft.Web.WebView2.WinForms
using System;
using System.IO;
using System.Threading.Tasks;
using System.Text.Json;
using Microsoft.Web.WebView2.WinForms;
using Microsoft.Web.WebView2.Core;

class Program
{
    static async Task Main()
    {
        var webView = new WebView2();
        await webView.EnsureCoreWebView2Async();
        
        var htmlPath = Path.GetFullPath("document.html");
        var tcs = new TaskCompletionSource<bool>();
        webView.CoreWebView2.NavigationCompleted += (s, e) => tcs.SetResult(true);
        
        webView.CoreWebView2.Navigate($"file:///{htmlPath}");
        await tcs.Task;
        await Task.Delay(1000);
        
        var options = new
        {
            landscape = false,
            printBackground = true,
            paperWidth = 8.5,
            paperHeight = 11,
            marginTop = 0.4,
            marginBottom = 0.4,
            marginLeft = 0.4,
            marginRight = 0.4
        };
        
        var result = await webView.CoreWebView2.CallDevToolsProtocolMethodAsync(
            "Page.printToPDF",
            JsonSerializer.Serialize(options)
        );
        
        var base64 = JsonDocument.Parse(result).RootElement.GetProperty("data").GetString();
        File.WriteAllBytes("output.pdf", Convert.FromBase64String(base64));
    }
}

// NuGet: Install-Package Microsoft.Web.WebView2.WinForms
using System;
using System.IO;
using System.Threading.Tasks;
using System.Text.Json;
using Microsoft.Web.WebView2.WinForms;
using Microsoft.Web.WebView2.Core;

class Program
{
    static async Task Main()
    {
        var webView = new WebView2();
        await webView.EnsureCoreWebView2Async();
        
        var htmlPath = Path.GetFullPath("document.html");
        var tcs = new TaskCompletionSource<bool>();
        webView.CoreWebView2.NavigationCompleted += (s, e) => tcs.SetResult(true);
        
        webView.CoreWebView2.Navigate($"file:///{htmlPath}");
        await tcs.Task;
        await Task.Delay(1000);
        
        var options = new
        {
            landscape = false,
            printBackground = true,
            paperWidth = 8.5,
            paperHeight = 11,
            marginTop = 0.4,
            marginBottom = 0.4,
            marginLeft = 0.4,
            marginRight = 0.4
        };
        
        var result = await webView.CoreWebView2.CallDevToolsProtocolMethodAsync(
            "Page.printToPDF",
            JsonSerializer.Serialize(options)
        );
        
        var base64 = JsonDocument.Parse(result).RootElement.GetProperty("data").GetString();
        File.WriteAllBytes("output.pdf", Convert.FromBase64String(base64));
    }
}

' NuGet: Install-Package Microsoft.Web.WebView2.WinForms
Imports System
Imports System.IO
Imports System.Threading.Tasks
Imports System.Text.Json
Imports Microsoft.Web.WebView2.WinForms
Imports Microsoft.Web.WebView2.Core

Module Program
    Async Function Main() As Task
        Dim webView As New WebView2()
        Await webView.EnsureCoreWebView2Async()
        
        Dim htmlPath = Path.GetFullPath("document.html")
        Dim tcs As New TaskCompletionSource(Of Boolean)()
        AddHandler webView.CoreWebView2.NavigationCompleted, Sub(s, e) tcs.SetResult(True)
        
        webView.CoreWebView2.Navigate($"file:///{htmlPath}")
        Await tcs.Task
        Await Task.Delay(1000)
        
        Dim options = New With {
            .landscape = False,
            .printBackground = True,
            .paperWidth = 8.5,
            .paperHeight = 11,
            .marginTop = 0.4,
            .marginBottom = 0.4,
            .marginLeft = 0.4,
            .marginRight = 0.4
        }
        
        Dim result = Await webView.CoreWebView2.CallDevToolsProtocolMethodAsync(
            "Page.printToPDF",
            JsonSerializer.Serialize(options)
        )
        
        Dim base64 = JsonDocument.Parse(result).RootElement.GetProperty("data").GetString()
        File.WriteAllBytes("output.pdf", Convert.FromBase64String(base64))
    End Function
End Module

' NuGet: Install-Package Microsoft.Web.WebView2.WinForms
Imports System
Imports System.IO
Imports System.Threading.Tasks
Imports System.Text.Json
Imports Microsoft.Web.WebView2.WinForms
Imports Microsoft.Web.WebView2.Core

Module Program
    Async Function Main() As Task
        Dim webView As New WebView2()
        Await webView.EnsureCoreWebView2Async()
        
        Dim htmlPath = Path.GetFullPath("document.html")
        Dim tcs As New TaskCompletionSource(Of Boolean)()
        AddHandler webView.CoreWebView2.NavigationCompleted, Sub(s, e) tcs.SetResult(True)
        
        webView.CoreWebView2.Navigate($"file:///{htmlPath}")
        Await tcs.Task
        Await Task.Delay(1000)
        
        Dim options = New With {
            .landscape = False,
            .printBackground = True,
            .paperWidth = 8.5,
            .paperHeight = 11,
            .marginTop = 0.4,
            .marginBottom = 0.4,
            .marginLeft = 0.4,
            .marginRight = 0.4
        }
        
        Dim result = Await webView.CoreWebView2.CallDevToolsProtocolMethodAsync(
            "Page.printToPDF",
            JsonSerializer.Serialize(options)
        )
        
        Dim base64 = JsonDocument.Parse(result).RootElement.GetProperty("data").GetString()
        File.WriteAllBytes("output.pdf", Convert.FromBase64String(base64))
    End Function
End Module

WebView2 verwendet Zoll für Dimensionen, benötigt anonyme Objekte und JSON-Serialisierung und pflegt den komplexen asynchronen Ablauf mit Event-Handlern und Zeitverzögerungen.

IronPDF RenderingOptions Konfiguration

IronPDF bietet eine stark typisierte Konfiguration über die Eigenschaft RenderingOptions:

// 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 = 40;
        renderer.RenderingOptions.MarginBottom = 40;
        renderer.RenderingOptions.MarginLeft = 40;
        renderer.RenderingOptions.MarginRight = 40;
        renderer.RenderingOptions.PrintHtmlBackgrounds = true;
        
        var pdf = renderer.RenderHtmlFileAsPdf("document.html");
        pdf.SaveAs("output.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 = 40;
        renderer.RenderingOptions.MarginBottom = 40;
        renderer.RenderingOptions.MarginLeft = 40;
        renderer.RenderingOptions.MarginRight = 40;
        renderer.RenderingOptions.PrintHtmlBackgrounds = true;
        
        var pdf = renderer.RenderHtmlFileAsPdf("document.html");
        pdf.SaveAs("output.pdf");
    }
}

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports IronPdf.Rendering

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter
        renderer.RenderingOptions.MarginTop = 40
        renderer.RenderingOptions.MarginBottom = 40
        renderer.RenderingOptions.MarginLeft = 40
        renderer.RenderingOptions.MarginRight = 40
        renderer.RenderingOptions.PrintHtmlBackgrounds = True

        Dim pdf = renderer.RenderHtmlFileAsPdf("document.html")
        pdf.SaveAs("output.pdf")
    End Sub
End Module

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports IronPdf.Rendering

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter
        renderer.RenderingOptions.MarginTop = 40
        renderer.RenderingOptions.MarginBottom = 40
        renderer.RenderingOptions.MarginLeft = 40
        renderer.RenderingOptions.MarginRight = 40
        renderer.RenderingOptions.PrintHtmlBackgrounds = True

        Dim pdf = renderer.RenderHtmlFileAsPdf("document.html")
        pdf.SaveAs("output.pdf")
    End Sub
End Module

IronPDF verwendet Millimeter für präzise Messungen, bietet PdfPaperSize Enums für Standardpapiergrößen und spezielle Methoden wie RenderHtmlFileAsPdf() für dateibasierte Inhalte.

HTML-Datei in PDF mit benutzerdefinierter Ausrichtung

Die Konvertierung von HTML-Dateien im Querformat demonstriert den PrintSettings-Ansatz gegenüber RenderingOptions.

WebView2 PrintSettings Ansatz

WebView2 bietet eine alternative PrintToPdfAsync Methode mit CoreWebView2PrintSettings:

// NuGet: Install-Package Microsoft.Web.WebView2.WinForms
using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.Web.WebView2.Core;
using Microsoft.Web.WebView2.WinForms;

class Program
{
    static async Task Main()
    {
        var webView = new WebView2();
        await webView.EnsureCoreWebView2Async();
        
        string htmlFile = Path.Combine(Directory.GetCurrentDirectory(), "input.html");
        webView.CoreWebView2.Navigate(htmlFile);
        
        await Task.Delay(3000);
        
        var printSettings = webView.CoreWebView2.Environment.CreatePrintSettings();
        printSettings.Orientation = CoreWebView2PrintOrientation.Landscape;
        printSettings.MarginTop = 0.5;
        printSettings.MarginBottom = 0.5;
        
        using (var stream = await webView.CoreWebView2.PrintToPdfAsync("custom.pdf", printSettings))
        {
            Console.WriteLine("Custom PDF created");
        }
    }
}

// NuGet: Install-Package Microsoft.Web.WebView2.WinForms
using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.Web.WebView2.Core;
using Microsoft.Web.WebView2.WinForms;

class Program
{
    static async Task Main()
    {
        var webView = new WebView2();
        await webView.EnsureCoreWebView2Async();
        
        string htmlFile = Path.Combine(Directory.GetCurrentDirectory(), "input.html");
        webView.CoreWebView2.Navigate(htmlFile);
        
        await Task.Delay(3000);
        
        var printSettings = webView.CoreWebView2.Environment.CreatePrintSettings();
        printSettings.Orientation = CoreWebView2PrintOrientation.Landscape;
        printSettings.MarginTop = 0.5;
        printSettings.MarginBottom = 0.5;
        
        using (var stream = await webView.CoreWebView2.PrintToPdfAsync("custom.pdf", printSettings))
        {
            Console.WriteLine("Custom PDF created");
        }
    }
}

' NuGet: Install-Package Microsoft.Web.WebView2.WinForms
Imports System
Imports System.IO
Imports System.Threading.Tasks
Imports Microsoft.Web.WebView2.Core
Imports Microsoft.Web.WebView2.WinForms

Module Program
    Async Function Main() As Task
        Dim webView As New WebView2()
        Await webView.EnsureCoreWebView2Async()

        Dim htmlFile As String = Path.Combine(Directory.GetCurrentDirectory(), "input.html")
        webView.CoreWebView2.Navigate(htmlFile)

        Await Task.Delay(3000)

        Dim printSettings = webView.CoreWebView2.Environment.CreatePrintSettings()
        printSettings.Orientation = CoreWebView2PrintOrientation.Landscape
        printSettings.MarginTop = 0.5
        printSettings.MarginBottom = 0.5

        Using stream = Await webView.CoreWebView2.PrintToPdfAsync("custom.pdf", printSettings)
            Console.WriteLine("Custom PDF created")
        End Using
    End Function
End Module

' NuGet: Install-Package Microsoft.Web.WebView2.WinForms
Imports System
Imports System.IO
Imports System.Threading.Tasks
Imports Microsoft.Web.WebView2.Core
Imports Microsoft.Web.WebView2.WinForms

Module Program
    Async Function Main() As Task
        Dim webView As New WebView2()
        Await webView.EnsureCoreWebView2Async()

        Dim htmlFile As String = Path.Combine(Directory.GetCurrentDirectory(), "input.html")
        webView.CoreWebView2.Navigate(htmlFile)

        Await Task.Delay(3000)

        Dim printSettings = webView.CoreWebView2.Environment.CreatePrintSettings()
        printSettings.Orientation = CoreWebView2PrintOrientation.Landscape
        printSettings.MarginTop = 0.5
        printSettings.MarginBottom = 0.5

        Using stream = Await webView.CoreWebView2.PrintToPdfAsync("custom.pdf", printSettings)
            Console.WriteLine("Custom PDF created")
        End Using
    End Function
End Module

Beachten Sie den 3-Sekunden-Task.Delay—ein noch längeres beliebiges Warten, um sicherzustellen, dass der Inhalt vor dem Drucken geladen wird.

IronPDF Vereinfachte Konfiguration

IronPDF erledigt dieselbe Aufgabe mit expliziten Einstellungen und ohne Zeitvorgaben:

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.MarginTop = 50;
        renderer.RenderingOptions.MarginBottom = 50;
        
        string htmlFile = Path.Combine(Directory.GetCurrentDirectory(), "input.html");
        var pdf = renderer.RenderHtmlFileAsPdf(htmlFile);
        pdf.SaveAs("custom.pdf");
        
        Console.WriteLine("Custom PDF created");
    }
}

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.MarginTop = 50;
        renderer.RenderingOptions.MarginBottom = 50;
        
        string htmlFile = Path.Combine(Directory.GetCurrentDirectory(), "input.html");
        var pdf = renderer.RenderHtmlFileAsPdf(htmlFile);
        pdf.SaveAs("custom.pdf");
        
        Console.WriteLine("Custom PDF created");
    }
}

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports IronPdf.Rendering
Imports System
Imports System.IO

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()

        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape
        renderer.RenderingOptions.MarginTop = 50
        renderer.RenderingOptions.MarginBottom = 50

        Dim htmlFile As String = Path.Combine(Directory.GetCurrentDirectory(), "input.html")
        Dim pdf = renderer.RenderHtmlFileAsPdf(htmlFile)
        pdf.SaveAs("custom.pdf")

        Console.WriteLine("Custom PDF created")
    End Sub
End Module

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports IronPdf.Rendering
Imports System
Imports System.IO

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()

        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape
        renderer.RenderingOptions.MarginTop = 50
        renderer.RenderingOptions.MarginBottom = 50

        Dim htmlFile As String = Path.Combine(Directory.GetCurrentDirectory(), "input.html")
        Dim pdf = renderer.RenderHtmlFileAsPdf(htmlFile)
        pdf.SaveAs("custom.pdf")

        Console.WriteLine("Custom PDF created")
    End Sub
End Module

API-Mapping-Referenz

Teams, die einen Wechsel von WebView2zu IronPDF erwägen, werden dieses Mapping hilfreich finden, um Konzeptäquivalenzen zu verstehen:

WebView2API	IronPDF-Äquivalent
`new WebView2()`	`new ChromePdfRenderer()`
`EnsureCoreWebView2Async()`	Nicht anwendbar
`NavigateToString(html)` + `PrintToPdfAsync()`	`RenderHtmlAsPdf(html)`
`Navigate(url)` + `PrintToPdfAsync()`	`RenderUrlAsPdf(url)`
`Navigate(file)` + `PrintToPdfAsync()`	`RenderHtmlFileAsPdf(file)`
`PrintSettings.PageWidth`	`RenderingOptions.PaperSize`
`PrintSettings.PageHeight`	`RenderingOptions.PaperSize`
`PrintSettings.MarginTop`	`RenderingOptions.MarginTop`
`PrintSettings.Orientation`	`RenderingOptions.PaperOrientation`
Navigation Ereignisse	`WaitFor.JavaScript()`
`printBackground: true`	`PrintHtmlBackgrounds = true`

Wenn Teams den Wechsel von WebView2 zu IronPDF erwägen

Es gibt mehrere Szenarien, die Entwicklerteams häufig dazu veranlassen,IronPDF als Alternative zu WebView2zu prüfen:

Plattformübergreifende Anforderungen

Da WebView2auf Windows beschränkt ist, eignet es sich nicht für Anwendungen, die auf Linux-Server, Docker-Container oder Cloud-Umgebungen ausgerichtet sind. Teams, die auf Azure, AWS, GCP oder einer containerisierten Infrastruktur arbeiten, können WebView2nicht für die PDF-Generierung verwenden.

Server-seitige PDF-Erzeugung

Da WebView2einen UI-Thread mit STA und Message Pump benötigt, ist es grundsätzlich nicht kompatibel mit ASP.NET Core, Hintergrunddiensten oder API-Endpunkten. Anwendungen, die eine PDF-Erzeugung als Reaktion auf Web-Anfragen erfordern, können WebView2nicht verwenden.

Bedenken der Speicherstabilität

Die von WebView2dokumentierten Speicherlecks in langlaufenden Prozessen führen in Produktionsumgebungen zu Serverabstürzen. Anwendungen, die den ganzen Tag über kontinuierlich PDFs generieren, akkumulieren so lange Speicher, bis der Speicherplatz erschöpft ist.

PDF-Funktionsanforderungen

Die PrintToPdfAsync von WebView2bietet nur einfache HTML-zu-PDF-Konvertierung. Teams, die Kopf- und Fußzeilen, Wasserzeichen, PDF-Zusammenführung/-aufteilung, digitale Signaturen, Passwortschutz oder PDF/A-Konformität benötigen, müssen sich anderweitig umsehen.

Vereinfachte Entwicklung

Der komplexe asynchrone Ablauf, der für WebView2erforderlich ist - Initialisierung, Navigationsereignisse, Rückrufe zur Vervollständigung, Zeitverzögerungen, JSON-Serialisierung, Base64-Dekodierung - führt zu einem erheblichen Entwicklungs- und Wartungsaufwand im Vergleich zu IronPDFs Single-Method-Ansatz.

Zusätzliche IronPDF-Fähigkeiten

IronPDF bietet neben der grundlegenden PDF-Erzeugung auch Funktionen zur Dokumentenbearbeitung, die WebView2nicht bieten kann:

Zusammenführung von PDFs: Kombinieren Sie mehrere Dokumente zu einer einzigen Datei
Aufteilung von Dokumenten: Extrahieren von Seitenbereichen in separate PDFs
Digitale Signaturen: Anwendung kryptografischer Signaturen für die Authentizität von Dokumenten
Wasserzeichen: Hinzufügen von Text- oder Bild-Wasserzeichen
PDF/A-Konformität: Generieren von Dokumenten nach Archivierungsstandard
Formularausfüllung: Programmgesteuertes Ausfüllen von PDF-Formularfeldern
Kopf- und Fußzeilen: Automatische Seitennummerierung und Branding
Passwortschutz: PDFs mit Benutzer- und Eigentümerpasswörtern verschlüsseln
Docker Deployment: Offizielle Container-Images für den Einsatz unter Linux

.NET-Kompatibilität und Zukunftsfähigkeit

Die reine Windows-Architektur von WebView2begrenzt seine Zukunft in einem zunehmend plattformübergreifenden .NET-Ökosystem.IronPDF wird aktiv weiterentwickelt und regelmäßig aktualisiert, um die Kompatibilität mit .NET 8, .NET 9 und zukünftigen Versionen, einschließlich .NET 10, das für 2026 erwartet wird, zu gewährleisten. Die async/await-Unterstützung in der gesamten API der Bibliothek entspricht den modernen C#-Entwicklungspraktiken, einschließlich der für C# 14 erwarteten Funktionen.

Abschluss

WebView2 und IronPDF stellen grundlegend unterschiedliche Ansätze zur PDF-Erzeugung in .NET dar. WebView2ist ein Steuerelement zur Browsereinbettung, das zufällig PDF-Druck unterstützt - eine sekundäre Funktion mit erheblichen Einschränkungen für den Produktionseinsatz. Die Beschränkung auf die Windows-Plattform, das Erfordernis eines UI-Threads, Probleme mit Speicherlecks und das Fehlen von PDF-spezifischen Funktionen machen es für ernsthafte PDF-Erzeugungsaufgaben ungeeignet.

IronPDF ist eine speziell für die Konvertierung von HTML in PDF entwickelte PDF-Bibliothek mit plattformübergreifender Unterstützung, serverseitigen Funktionen und umfassenden PDF-Manipulationsfunktionen. Die optimierte API macht die komplexen asynchronen Muster, die Ereignisbehandlung und die Timing-Hacks überflüssig, die WebView2erfordert.

Für Teams, die derzeit WebView2für die PDF-Generierung verwenden, ist es aufgrund der dokumentierten Stabilitätsprobleme, Plattformbeschränkungen und Funktionslücken unerlässlich, speziell entwickelte Alternativen zu evaluieren. Die API-Zuordnung zwischen WebView2und IronPDF ist einfach, wobei IronPDF durchweg weniger Code benötigt und die architektonischen Einschränkungen, die WebView2auferlegt, eliminiert.

Weitere Anleitungen zur Implementierung finden Sie in der IronPDF-Dokumentation und den Tutorials, die spezielle Anwendungsfälle und erweiterte Funktionen behandeln.

Hinweis:: WebView2 ist ein eingetragenes Warenzeichen seines jeweiligen Eigentümers. Diese Website steht in keiner Verbindung zu Microsoft und wird nicht von Microsoft unterstützt oder gesponsert. Alle Produktnamen, Logos und Marken sind Eigentum ihrer jeweiligen Eigentümer. Vergleiche dienen nur zu Informationszwecken und spiegeln öffentlich zugängliche Informationen zum Zeitpunkt des Schreibens wider.