PORóWNANIE

WebView2 vs IronPDF: Przewodnik porównania technicznego

Zaktualizowano:

Gdy programiści .NET muszą przekonwertować zawartość HTML do formatu PDF, kontrolkaWebView2firmy Microsoft czasami wydaje się potencjalnym rozwiązaniem ze względu na silnik renderujący oparty na Chromium. JednakWebView2jest zasadniczo kontrolką osadzającą przeglądarkę, zaprojektowaną dla aplikacji UI, a nie biblioteką do generowania plików PDF. W niniejszym porównaniu technicznym przeanalizowanoWebView2oraz IronPDF, aby pomóc architektom i programistom zrozumieć kluczowe różnice między osadzeniem kontrolki przeglądarki do generowania plików PDF a wykorzystaniem specjalnie zaprojektowanej biblioteki PDF.

Zrozumienie WebView2

WebView2 (Microsoft Edge) to wszechstronny, osadzalny kontrolka przeglądarki, która integruje silnik Edge/Chromium z natywnymi aplikacjami systemu Windows. Ten element sterujący wspiera przeglądanie w przeglądarce Microsoft Edge w ramach ograniczonego ekosystemu, zapewniając zgodność z nowoczesnymi standardami internetowymi w zakresie wyświetlania treści HTML5, CSS3 i JavaScript.

Zdolność generowania PDF przezWebView2istnieje dzięki metodzie PrintToPdfAsync i integracji z DevTools Protocol. Jednak ta funkcjonalność stanowi raczej dodatek niż podstawową funkcję:

  • Architektura Browser Control: Zaprojektowana do osadzania treści internetowych w aplikacjach UI, a nie do generowania plików PDF po stronie serwera
  • Platforma wyłącznie dla systemu Windows: brak wsparcia dla systemów Linux, macOS, Docker lub środowisk chmurowych
  • Wymagania dotyczące wątku interfejsu użytkownika: Musi działać na wątku STA z pompą komunikatów — nie może działać na serwerach internetowych ani w interfejsach API
  • Zależność środowiska uruchomieniowego Edge: Wymaga zainstalowania środowiska uruchomieniowego EdgeWebView2na komputerach docelowych
  • Brak trybu bezinterfejsu: zawsze tworzy elementy interfejsu użytkownika, nawet gdy są ukryte

OgraniczeniaWebView2dotyczące generowania plików PDF

Dokumentacja przewodnika migracji wskazuje na krytyczne problemy związane z użyciemWebView2do generowania plików PDF:

ProblemWpływWaga
Wycieki pamięciWWebView2odnotowano wycieki pamięci w długotrwałych procesachKLUCZOWE
Tylko dla systemu WindowsBrak obsługi systemów Linux, macOS, Docker lub środowisk chmurowychKLUCZOWE
Wymagany wątek dotyczący interfejsu użytkownikaMusi działać na wątku STA z pompą komunikatówKLUCZOWE
Nieprzeznaczone do plików PDFPrintToPdfAsync jest dodatkiem, o którym pomyślano późniejHIGH
Niestabilne w usługachAwarie i zawieszanie się, typowe dla usług systemu WindowsHIGH
Złożony przepływ asynchronicznyZdarzenia nawigacyjne, wywołania zwrotne po zakończeniu, warunki wyściguHIGH
Zależność środowiska uruchomieniowego EdgeWymaga środowiska uruchomieniowego EdgeWebView2na komputerze docelowymMEDIUM
Brak trybu bezinterfejsowegoZawsze tworzy elementy interfejsu użytkownika, nawet gdy są ukryteMEDIUM

Zrozumienie IronPDF

IronPDF to specjalnie zaprojektowana biblioteka PDF przeznaczona do generowania plików PDF z treści HTML i internetowych. W przeciwieństwie do podejściaWebView2polegającego na osadzaniu przeglądarki, IronPDF zapewnia dedykowany silnik generowania plików PDF z obsługą wielu platform i możliwościami po stronie serwera.

Kluczowe cechy obejmują:

  • Biblioteka PDF stworzona specjalnie do tego celu: zaprojektowana od podstaw do generowania plików PDF, a nie do osadzania w interfejsie użytkownika
  • Obsługa wielu platform: Windows, Linux, macOS, Docker, iOS i Android
  • Obsługa dowolnych wątków: brak wymagań dotyczących wątków STA lub pompy komunikatów
  • Gotowość do pracy na serwerze/w chmurze: Obsługa platform ASP.NET Core, Azure, AWS, GCP i Docker
  • Brak zależności zewnętrznych: Samodzielne rozwiązanie, nie wymaga instalacji środowiska uruchomieniowego
  • Kompleksowe funkcje PDF: nagłówki/stopki, znaki wodne, scałanie/dzielenie, podpisy cyfrowe, zgodność z PDF/A

Porównanie funkcji

Poniższa tabela przedstawia podstawowe różnice międzyWebView2a IronPDF:

FunkcjaWebView2IronPDF
CelSterowanie przeglądarką (UI)Biblioteka PDF (przeznaczona dla formatu PDF)
Gotowe do produkcjiNIETAK
Zarządzanie pamięciąWycieki w długotrwałychStabilny, prawidłowo usunięty
Obsługa platformTylko dla systemu WindowsWindows, Linux, macOS, Docker
Wymagania dotyczące wątkuSTA + Message PumpKażdy wątek
Serwer/ChmuraNieobsługiwaneObsługiwane
Azure/AWS/GCPProblematyczneDziała idealnie
DockerNiemożliweDostępne są oficjalne zdjęcia
ASP.NET CoreNie mogę pracowaćWsparcie na najwyższym poziomie
Usługi w tleNiestabilnyStabilny
Aplikacje konsoloweZłożone trikiTak
WinForms/WPFTakTak
Nagłówki/stopkiNIETak (HTML)
Znaki wodneNIETak
Łączenie plików PDFNIETak
Podział plików PDFNIETak
Podpisy cyfroweNIETak
Ochrona hasłemNIETak
Zgodność z PDF/ANIETak
Wypełnianie formularzyNIETak
Profesjonalne wsparcieBrak dla plików PDFTak
DokumentacjaOgraniczone dokumenty PDFObszerne

Różnice w architekturze API

Różnice architektoniczne międzyWebView2aIronPDFstają się natychmiast widoczne, gdy przyjrzymy się, w jaki sposób każde z tych rozwiązań radzi sobie z generowaniem plików PDF.

Złożony wzorzec asynchroniczny WebView2

WebView2 wymaga wieloetapowego procesu asynchronicznego obejmującego inicjalizację przeglądarki, nawigację, obsługę zdarzeń oraz wywołania protokołu DevTools:

// 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",
            "{}"
        );
    }
}
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
$vbLabelText   $csharpLabel

Ten kod demonstruje kilka złożoności związanych z WebView2: jawna inicjalizacja za pomocą EnsureCoreWebView2Async(), nawigacja przy użyciu NavigateToString(), dowolne opóźnienia w oczekiwaniu na załadowanie treści oraz wywołania niskiego poziomu DevTools Protocol. Task.Delay reprezentuje niepewne przypuszczenie, kiedy treść jest gotowa—sytuacja wyścigu czekająca, aby się wydarzyć.

Uproszczone podejście IronPDF

IronPDF eliminuje tę złożoność dzięki prostemu podejściu opartemu na jednej metodzie:

// 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
$vbLabelText   $csharpLabel

Klasa ChromePdfRenderer wewnętrznie obsługuje wszystkie złożone operacje renderowania. Bez ceremonii inicjalizacji, bez zdarzeń nawigacyjnych, bez zgadywania czasu. Aby uzyskać wyczerpujące wskazówki dotyczące konwersji HTML, zapoznaj się z samouczkiem dotyczącym konwersji HTML do PDF.

Konwersja adresów URL do formatu PDF

Konwersja stron internetowych do dokumentów PDF pokazuje różnicę w złożoności międzyWebView2a IronPDF.

Wdrożenie WebView2

WebView2 wymaga obsługi zdarzeń nawigacyjnych, wywołań zwrotnych po zakończeniu oraz ręcznego wyodrębniania plików PDF:

// 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));
    }
}
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
$vbLabelText   $csharpLabel

Ta implementacja wymaga stworzenia TaskCompletionSource do śledzenia nawigacji, subskrypcji zdarzeń NavigationCompleted, parsowania odpowiedzi JSON z DevTools Protocol oraz obsługi dekodowania Base64. Dodatkowy Task.Delay(1000) po zakończeniu nawigacji próbuje zapewnić, że wykonywanie JavaScript się zakończyło—kolejny niepewny trik czasowy.

Wdrożenie IronPDF

IronPDF zapewnia bezpośrednie renderowanie adresów URL za pomocą jednego wywołania metody:

// 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
$vbLabelText   $csharpLabel

Metoda RenderUrlAsPdf wewnętrznie obsługuje nawigację, wykonywanie kodu JavaScript oraz ładowanie treści. Żadnych subskrypcji zdarzeń, żadnych domysłów dotyczących czasu, żadnego parsowania Base64.

Niestandardowe ustawienia i opcje plików PDF

Konfiguracja wymiarów strony, marginesów i orientacji ujawnia znaczące różnice w użyteczności API.

Konfiguracja protokołuWebView2DevTools

WebView2 wymaga serializacji JSON i parametrów protokołu DevTools:

// 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));
    }
}
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 As String = 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 As String = Await webView.CoreWebView2.CallDevToolsProtocolMethodAsync(
            "Page.printToPDF",
            JsonSerializer.Serialize(options)
        )

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

WebView2 używa cali jako jednostek wymiarów, wymaga obiektów anonimowych i serializacji JSON oraz obsługuje złożony przepływ asynchroniczny z obsługą zdarzeń i opóźnieniami czasowymi.

Konfiguracja opcji renderowania IronPDF

IronPDF zapewnia silnie typowaną konfigurację poprzez właściwość 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");
    }
}
Imports IronPdf
Imports IronPdf.Rendering

Class Program
    Shared Sub Main()
        Dim 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

        Dim pdf = renderer.RenderHtmlFileAsPdf("document.html")
        pdf.SaveAs("output.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

IronPDF używa milimetrów dla precyzyjnych pomiarów, dostarcza PdfPaperSize wyliczenia dla standardowych rozmiarów papieru oraz oferuje dedykowane metody, takie jak RenderHtmlFileAsPdf() dla treści opartej na plikach.

Plik HTML do PDF z niestandardową orientacją

Konwersja plików HTML w orientacji poziomej ilustruje podejście PrintSettings w porównaniu z RenderingOptions.

PodejścieWebView2PrintSettings

WebView2 oferuje alternatywną metodę PrintToPdfAsync z 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");
        }
    }
}
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
$vbLabelText   $csharpLabel

Zwróć uwagę na 3-sekundowy Task.Delay—jeszcze dłuższe, dowolne oczekiwanie próbujące zapewnić, że treść załaduje się przed drukowaniem.

Uproszczona konfiguracja IronPDF

IronPDF radzi sobie z tym samym zadaniem przy użyciu jasnych ustawień i bez zgadywania co do czasu:

// 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");
    }
}
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
$vbLabelText   $csharpLabel

Przewodnik po mapowaniu API

Zespoły rozważające przejście zWebView2naIronPDFuznają to mapowanie za pomocne w zrozumieniu równoważności koncepcji:

Interfejs APIWebView2OdpowiednikIronPDF
new WebView2()new ChromePdfRenderer()
EnsureCoreWebView2Async()Nie dotyczy
NavigateToString(html) + PrintToPdfAsync()RenderHtmlAsPdf(html)
Navigate(url) + PrintToPdfAsync()RenderUrlAsPdf(url)
Navigate(file) + PrintToPdfAsync()RenderHtmlFileAsPdf(file)
PrintSettings.PageWidthRenderingOptions.PaperSize
PrintSettings.PageHeightRenderingOptions.PaperSize
PrintSettings.MarginTopRenderingOptions.MarginTop
PrintSettings.OrientationRenderingOptions.PaperOrientation
Zdarzenia nawigacyjneWaitFor.JavaScript()
printBackground: truePrintHtmlBackgrounds = true

Kiedy zespoły rozważają przejście zWebView2na IronPDF

Istnieje kilka scenariuszy, w których zespoły programistów często rozważająIronPDFjako alternatywę dla WebView2:

Wymagania dotyczące wielopłatformowości

OgraniczenieWebView2do systemu Windows sprawia, że nie nadaje się on do aplikacji przeznaczonych dla serwerów Linux, kontenerów Docker lub środowisk chmurowych. Zespoły wdrażające rozwiązania w Azure, AWS, GCP lub infrastrukturze kontenerowej nie mogą używaćWebView2do generowania plików PDF.

Generowanie plików PDF po stronie serwera

WymaganiaWebView2dotyczące wątku interfejsu użytkownika w połączeniu z STA i pompą komunikatów sprawiają, że jest on zasadniczo niekompatybilny z .NET Core, usługami działającymi w tle lub punktami końcowymi API. Aplikacje wymagające generowania plików PDF w odpowiedzi na żądania internetowe nie mogą korzystać z WebView2.

Obawy dotyczące stabilności pamięci

Udokumentówane wycieki pamięciWebView2w długotrwałych procesach powodują awarie serwerów w środowiskach produkcyjnych. Aplikacje generujące pliki PDF w sposób ciągły przez cały dzień gromadzą pamięć, aż do wystąpienia sytuacji braku pamięci.

Wymagania dotyczące funkcji pliku PDF

WebView2's PrintToPdfAsync zapewnia jedynie podstawową konwersję HTML do PDF. Zespoły wymagające nagłówków/stopek, znaków wodnych, łączenia/dzielenia plików PDF, podpisów cyfrowych, ochrony hasłem lub zgodności z formatem PDF/A muszą poszukać innego rozwiązania.

Uproszczone tworzenie oprogramowania

Złożony przepływ asynchroniczny wymagany przezWebView2— inicjalizacja, zdarzenia nawigacyjne, wywołania zwrotne zakończenia, opóźnienia czasowe, serializacja JSON, dekodowanie Base64 — powoduje znaczne obciążenie związane z programowaniem i utrzymaniem w porównaniu z podejściem opartym na jednej metodzie stosowanym w IronPDF.

Dodatkowe możliwości IronPDF

Oprócz podstawowego generowania plików PDF,IronPDFoferuje funkcje edycji dokumentów, którychWebView2nie jest w stanie zapewnić:

Zgodność z platformą .NET i gotowość na przyszłość

ArchitekturaWebView2przeznaczona wyłącznie dla systemu Windows ogranicza jego przyszłość w coraz bardziej wielopłatformowym ekosystemie .NET.IronPDFjest aktywnie rozwijany i regularnie aktualizowany, co zapewnia kompatybilność z .NET 8, .NET 9 oraz przyszłymi wersjami, w tym .NET 10, którego premiera przewidziana jest na 2026 rok. Obsługa async/await w całym API biblioteki jest zgodna z nowoczesnymi praktykami programistycznymi w języku C#, w tym z funkcjami przewidzianymi w C# 14.

Wnioski

WebView2 iIronPDFreprezentują zasadniczo różne podejścia do generowania plików PDF w środowisku .NET.WebView2to kontrolka do osadzania przeglądarki, która obsługuje drukowanie plików PDF — jest to funkcja dodatkowa o znacznych ograniczeniach w zastosowaniach produkcyjnych. Ograniczenie platformy wyłącznie do systemu Windows, wymóg wątku interfejsu użytkownika, problemy z wyciekami pamięci oraz brak funkcji specyficznych dla formatu PDF sprawiają, że nie nadaje się on do poważnych zadań związanych z generowaniem plików PDF.

IronPDF to specjalnie zaprojektowana biblioteka PDF przeznaczona do konwersji HTML na PDF, oferująca obsługę wielu platform, funkcje po stronie serwera oraz kompleksowe możliwości edycji plików PDF. Jego uproszczony interfejs API eliminuje złożone wzorce asynchroniczne, obsługę zdarzeń i triki związane z synchronizacją, których wymaga WebView2.

Dla zespołów korzystających obecnie zWebView2do generowania plików PDF udokumentówane problemy ze stabilnością, ograniczenia platformy i braki w funkcjonalności sprawiają, że ocena specjalnie zaprojektowanych alternatyw jest niezbędna. Mapowanie API międzyWebView2aIronPDFjest proste, aIronPDFkonsekwentnie wymaga mniejszego nakładu kodu i eliminuje ograniczenia architektoniczne narzucane przez WebView2.

Aby uzyskać dodatkowe wskazówki dotyczące wdrażania, zapoznaj się z dokumentacją IronPDF oraz samouczkami obejmującymi konkretne przypadki użycia i zaawansowane funkcje.

Zwróć uwagęWebView2 jest zarejestrowanym znakiem towarowym jego właściciela. Ta strona nie jest powiązana z firmą Microsoft, nie jest przez nią promowana ani sponsorowana. Wszystkie nazwy produktów, logo i marki są własnością ich odpowiednich właścicieli. Porównania mają charakter wyłącznie informacyjny i odzwierciedlają informacje dostępne publicznie w momencie pisania.