Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. Migrationsleitfäden
  4. migration von wkhtmltopdf zu IronPDF
MIGRATIONSLEITFäDEN

Migrieren von wkhtmltopdf zu IronPDF in C#

Curtis Chau
Curtis Chau
Aktualisiert:

wkhtmltopdf ist ein weit verbreitetes Tool zur Konvertierung von HTML-Dokumenten in PDF mit Qt WebKit. Trotz seiner Beliebtheit bei Entwicklern aufgrund seiner Befehlszeilenfunktionen und der kostenlosen Lizenzierung birgt das Projekt inzwischen kritische Sicherheitsrisiken, die nicht mehr ignoriert werden können. Die Bibliothek wurde 2016-2017 offiziell aufgegeben, und eine Sicherheitslücke mit dem Schweregrad KRITISCH (CVE-2022-35583) bleibt dauerhaft ungepatched.

Dieses Handbuch bietet einen vollständigen Migrationspfad von wkhtmltopdf zu IronPDF mit schrittweisen Anleitungen, Codevergleichen und praktischen Beispielen für professionelle .NET-Entwickler, die dieses Sicherheitsrisiko aus ihren Anwendungen eliminieren müssen.

Kritische Sicherheitswarnung: CVE-2022-35583

wkhtmltopdf enthält eine kritische Sicherheitslücke, die nie behoben werden wird:

Problem Schweregrad Status
CVE-2022-35583 KRITISCH (9.8/10) UNPATCHED
SSRF-Schwachstelle Risiko der Infrastrukturübernahme UNPATCHED
Letzte Aktualisierung 2016-2017 Abgelehnt
WebKit Version 2015 (Qt WebKit) OBSOLETE
CSS-Grid-Unterstützung Keine Gebrochen
Flexbox-Unterstützung Teilweise Gebrochen
ES6+ JavaScript Keine Gebrochen

Wie der SSRF-Angriff funktioniert

Die Sicherheitslücke "Server-Side Request Forgery" ermöglicht es Angreifern, auf interne Dienste zuzugreifen, Anmeldeinformationen zu stehlen, Ihr internes Netzwerk zu scannen und sensible Daten über manipuliertes HTML zu exfiltrieren:


<iframe src="http://169.254.169.254/latest/meta-data/iam/security-credentials/"></iframe>
<img src="http://internal-database:5432/admin"/>

<iframe src="http://169.254.169.254/latest/meta-data/iam/security-credentials/"></iframe>
<img src="http://internal-database:5432/admin"/>
HTML

Wenn wkhtmltopdf dieses HTML rendert, holt es diese URLs aus dem Netzwerkkontext Ihres Servers und umgeht dabei Firewalls und Sicherheitskontrollen.

Betroffene Wrapper-Bibliotheken

Alle .NET-Wrapper für wkhtmltopdf erben diese Schwachstellen:

Wrapper-Bibliothek Status Sicherheitsrisiko
DinkToPdf Aufgegeben ⚠️ KRITISCH
Rotativa Aufgegeben ⚠️ KRITISCH
TuesPechkin Aufgegeben ⚠️ KRITISCH
WkHtmlToPdf-DotNet Aufgegeben ⚠️ KRITISCH
NReco.PdfGenerator Verwendet wkhtmltopdf ⚠️ KRITISCH

Wenn Sie eine dieser Bibliotheken verwenden, sind Sie anfällig für CVE-2022-35583.

IronPDF vs. wkhtmltopdf: Funktionsvergleich

Das Verständnis der architektonischen Unterschiede hilft technischen Entscheidungsträgern, die Investition in die Migration zu bewerten:

Feature wkhtmltopdf IronPDF
Lizenzierung LGPLv3 (Frei) Kommerziell
Rendering Engine Qt WebKit (2015) Aktuelle Chromium-Engine
Sicherheitsschwachstellen CVE-2022-35583, wichtige ungepatchte Probleme Keine bekannten CVEs
Aktive Wartung Abgebrochen, keine sinnvollen Aktualisierungen seit 2017 Aktive Pflege mit regelmäßigen Veröffentlichungen
Unterstützung für moderne Webstandards Eingeschränkt (Broken flexbox, kein CSS Grid) Unterstützt
Integration und Unterstützung Beschränkt auf Community-Foren Umfassende Dokumentation und engagierter Support
CSS Grid ❌ Nicht unterstützt ✅ Unterstützt
Flexbox ⚠️ Gebrochen ✅ Unterstützt
ES6+ JavaScript ❌ Nicht unterstützt ✅ Unterstützt
Async/Await ❌ Nicht unterstützt ✅ Unterstützt
PDF-Bearbeitung ❌ Nicht unterstützt ✅ Unterstützt
Digitale Signaturen ❌ Nicht unterstützt ✅ Unterstützt
PDF/A-Konformität ❌ Nicht unterstützt ✅ Unterstützt

Schnellstart: wkhtmltopdf zu IronPDF Migration

Mit diesen grundlegenden Schritten kann die Migration sofort beginnen.

Schritt 1: Entfernen von wkhtmltopdf-Paketen und -Binärdateien

Entfernen Sie alle wkhtmltopdf-Wrapper-Pakete:

# Remove wkhtmltopdf wrapper (whichever you're using)
dotnet remove package WkHtmlToPdf-DotNet
dotnet remove package DinkToPdf
dotnet remove package TuesPechkin
dotnet remove package Rotativa
dotnet remove package Rotativa.AspNetCore
dotnet remove package NReco.PdfGenerator

# Remove wkhtmltopdf binary from your deployment
# Delete wkhtmltopdf.exe, wkhtmltox.dll, etc.
# Remove wkhtmltopdf wrapper (whichever you're using)
dotnet remove package WkHtmlToPdf-DotNet
dotnet remove package DinkToPdf
dotnet remove package TuesPechkin
dotnet remove package Rotativa
dotnet remove package Rotativa.AspNetCore
dotnet remove package NReco.PdfGenerator

# Remove wkhtmltopdf binary from your deployment
# Delete wkhtmltopdf.exe, wkhtmltox.dll, etc.
SHELL

Schritt 2: IronPDF installieren

# Add IronPDF(secure, modern alternative)
dotnet add package IronPdf
# Add IronPDF(secure, modern alternative)
dotnet add package IronPdf
SHELL

Schritt 3: Namespaces aktualisieren

Ersetzen Sie die wkhtmltopdf-Namensräume durch den IronPDF-Namensraum:

// Before (wkhtmltopdf)
using WkHtmlToPdfDotNet;
using WkHtmlToPdfDotNet.Contracts;

// After (IronPDF)
using IronPdf;
// Before (wkhtmltopdf)
using WkHtmlToPdfDotNet;
using WkHtmlToPdfDotNet.Contracts;

// After (IronPDF)
using IronPdf;
' Before (wkhtmltopdf)
Imports WkHtmlToPdfDotNet
Imports WkHtmlToPdfDotNet.Contracts

' After (IronPDF)
Imports IronPdf
$vbLabelText   $csharpLabel

Schritt 4: Lizenz initialisieren

Hinzufügen der Lizenzinitialisierung beim Start der Anwendung:

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
$vbLabelText   $csharpLabel

Beispiele für die Code-Migration

Konvertierung von HTML in PDF

Der grundlegendste Vorgang offenbart den Komplexitätsunterschied zwischen diesen .NET-PDF-Ansätzen.

wkhtmltopdf-Ansatz:

// NuGet: Install-Package WkHtmlToPdf-DotNet
using WkHtmlToPdfDotNet;
using WkHtmlToPdfDotNet.Contracts;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new SynchronizedConverter(new PdfTools());
        var doc = new HtmlToPdfDocument()
        {
            GlobalSettings = {
                ColorMode = ColorMode.Color,
                Orientation = Orientation.Portrait,
                PaperSize = PaperKind.A4
            },
            Objects = {
                new ObjectSettings()
                {
                    HtmlContent = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>"
                }
            }
        };
        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("output.pdf", pdf);
    }
}
// NuGet: Install-Package WkHtmlToPdf-DotNet
using WkHtmlToPdfDotNet;
using WkHtmlToPdfDotNet.Contracts;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new SynchronizedConverter(new PdfTools());
        var doc = new HtmlToPdfDocument()
        {
            GlobalSettings = {
                ColorMode = ColorMode.Color,
                Orientation = Orientation.Portrait,
                PaperSize = PaperKind.A4
            },
            Objects = {
                new ObjectSettings()
                {
                    HtmlContent = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>"
                }
            }
        };
        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("output.pdf", pdf);
    }
}
' NuGet: Install-Package WkHtmlToPdf-DotNet
Imports WkHtmlToPdfDotNet
Imports WkHtmlToPdfDotNet.Contracts
Imports System.IO

Class Program
    Shared Sub Main()
        Dim converter = New SynchronizedConverter(New PdfTools())
        Dim doc = New HtmlToPdfDocument() With {
            .GlobalSettings = New GlobalSettings() With {
                .ColorMode = ColorMode.Color,
                .Orientation = Orientation.Portrait,
                .PaperSize = PaperKind.A4
            },
            .Objects = {
                New ObjectSettings() With {
                    .HtmlContent = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>"
                }
            }
        }
        Dim pdf As Byte() = converter.Convert(doc)
        File.WriteAllBytes("output.pdf", pdf)
    End Sub
End Class
$vbLabelText   $csharpLabel

IronPDF-Ansatz:

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1><p>This is a PDF from HTML.</p>");
        pdf.SaveAs("output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1><p>This is a PDF from HTML.</p>");
        pdf.SaveAs("output.pdf");
    }
}
Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1><p>This is a PDF from HTML.</p>")
        pdf.SaveAs("output.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

wkhtmltopdf erfordert das Erstellen eines SynchronizedConverter mit PdfTools, das Konstruieren eines HtmlToPdfDocument mit GlobalSettings und Objects, das Festlegen von Eigenschaften wie ColorMode, Orientation und PaperSize, den Aufruf von converter.Convert() zum Abrufen der Rohbytes und das manuelle Schreiben in eine Datei mit File.WriteAllBytes().

IronPDF macht diese Prozedur überflüssig – man erstellt ein ChromePdfRenderer, ruft RenderHtmlAsPdf() auf und verwendet die integrierte Methode SaveAs().

Für fortgeschrittene HTML-zu-PDF-Szenarien siehe den HTML-zu-PDF-Konvertierungsleitfaden.

Konvertierung von URLs zu PDF

Die URL-zu-PDF-Konvertierung weist ähnliche Komplexitätsmuster auf.

wkhtmltopdf-Ansatz:

// NuGet: Install-Package WkHtmlToPdf-DotNet
using WkHtmlToPdfDotNet;
using WkHtmlToPdfDotNet.Contracts;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new SynchronizedConverter(new PdfTools());
        var doc = new HtmlToPdfDocument()
        {
            GlobalSettings = {
                ColorMode = ColorMode.Color,
                Orientation = Orientation.Portrait,
                PaperSize = PaperKind.A4
            },
            Objects = {
                new ObjectSettings()
                {
                    Page = "https://www.example.com"
                }
            }
        };
        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("webpage.pdf", pdf);
    }
}
// NuGet: Install-Package WkHtmlToPdf-DotNet
using WkHtmlToPdfDotNet;
using WkHtmlToPdfDotNet.Contracts;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new SynchronizedConverter(new PdfTools());
        var doc = new HtmlToPdfDocument()
        {
            GlobalSettings = {
                ColorMode = ColorMode.Color,
                Orientation = Orientation.Portrait,
                PaperSize = PaperKind.A4
            },
            Objects = {
                new ObjectSettings()
                {
                    Page = "https://www.example.com"
                }
            }
        };
        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("webpage.pdf", pdf);
    }
}
' NuGet: Install-Package WkHtmlToPdf-DotNet
Imports WkHtmlToPdfDotNet
Imports WkHtmlToPdfDotNet.Contracts
Imports System.IO

Module Program
    Sub Main()
        Dim converter As New SynchronizedConverter(New PdfTools())
        Dim doc As New HtmlToPdfDocument() With {
            .GlobalSettings = New GlobalSettings() With {
                .ColorMode = ColorMode.Color,
                .Orientation = Orientation.Portrait,
                .PaperSize = PaperKind.A4
            },
            .Objects = {
                New ObjectSettings() With {
                    .Page = "https://www.example.com"
                }
            }
        }
        Dim pdf As Byte() = converter.Convert(doc)
        File.WriteAllBytes("webpage.pdf", pdf)
    End Sub
End Module
$vbLabelText   $csharpLabel

IronPDF-Ansatz:

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
        pdf.SaveAs("webpage.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System;

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

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderUrlAsPdf("https://www.example.com")
        pdf.SaveAs("webpage.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

wkhtmltopdf verwendet die Page Eigenschaft in ObjectSettings, um eine URL anzugeben, was das gleiche Dokumentkonstruktionsmuster erfordert.IronPDF bietet eine spezielle Methode RenderUrlAsPdf(), die die Absicht klar zum Ausdruck bringt.

In der URL zur PDF-Dokumentation finden Sie Informationen zur Authentifizierung und zu benutzerdefinierten Kopfzeilenoptionen.

Benutzerdefinierte Einstellungen: HTML-Dateien mit Seitenkonfiguration

Die Konfiguration von Ausrichtung, Rändern und Papiergröße erfordert unterschiedliche Ansätze.

wkhtmltopdf-Ansatz:

// NuGet: Install-Package WkHtmlToPdf-DotNet
using WkHtmlToPdfDotNet;
using WkHtmlToPdfDotNet.Contracts;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new SynchronizedConverter(new PdfTools());
        var doc = new HtmlToPdfDocument()
        {
            GlobalSettings = {
                ColorMode = ColorMode.Color,
                Orientation = Orientation.Landscape,
                PaperSize = PaperKind.A4,
                Margins = new MarginSettings() { Top = 10, Bottom = 10, Left = 10, Right = 10 }
            },
            Objects = {
                new ObjectSettings()
                {
                    Page = "input.html",
                    WebSettings = { DefaultEncoding = "utf-8" }
                }
            }
        };
        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("custom-output.pdf", pdf);
    }
}
// NuGet: Install-Package WkHtmlToPdf-DotNet
using WkHtmlToPdfDotNet;
using WkHtmlToPdfDotNet.Contracts;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new SynchronizedConverter(new PdfTools());
        var doc = new HtmlToPdfDocument()
        {
            GlobalSettings = {
                ColorMode = ColorMode.Color,
                Orientation = Orientation.Landscape,
                PaperSize = PaperKind.A4,
                Margins = new MarginSettings() { Top = 10, Bottom = 10, Left = 10, Right = 10 }
            },
            Objects = {
                new ObjectSettings()
                {
                    Page = "input.html",
                    WebSettings = { DefaultEncoding = "utf-8" }
                }
            }
        };
        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("custom-output.pdf", pdf);
    }
}
' NuGet: Install-Package WkHtmlToPdf-DotNet
Imports WkHtmlToPdfDotNet
Imports WkHtmlToPdfDotNet.Contracts
Imports System.IO

Class Program
    Shared Sub Main()
        Dim converter As New SynchronizedConverter(New PdfTools())
        Dim doc As New HtmlToPdfDocument() With {
            .GlobalSettings = New GlobalSettings() With {
                .ColorMode = ColorMode.Color,
                .Orientation = Orientation.Landscape,
                .PaperSize = PaperKind.A4,
                .Margins = New MarginSettings() With {.Top = 10, .Bottom = 10, .Left = 10, .Right = 10}
            },
            .Objects = {
                New ObjectSettings() With {
                    .Page = "input.html",
                    .WebSettings = New WebSettings() With {.DefaultEncoding = "utf-8"}
                }
            }
        }
        Dim pdf As Byte() = converter.Convert(doc)
        File.WriteAllBytes("custom-output.pdf", pdf)
    End Sub
End Class
$vbLabelText   $csharpLabel

IronPDF-Ansatz:

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.MarginTop = 10;
        renderer.RenderingOptions.MarginBottom = 10;
        renderer.RenderingOptions.MarginLeft = 10;
        renderer.RenderingOptions.MarginRight = 10;
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;

        var pdf = renderer.RenderHtmlFileAsPdf("input.html");
        pdf.SaveAs("custom-output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.MarginTop = 10;
        renderer.RenderingOptions.MarginBottom = 10;
        renderer.RenderingOptions.MarginLeft = 10;
        renderer.RenderingOptions.MarginRight = 10;
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;

        var pdf = renderer.RenderHtmlFileAsPdf("input.html");
        pdf.SaveAs("custom-output.pdf");
    }
}
Imports IronPdf
Imports IronPdf.Rendering
Imports System

Class Program
    Shared Sub Main()
        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape
        renderer.RenderingOptions.MarginTop = 10
        renderer.RenderingOptions.MarginBottom = 10
        renderer.RenderingOptions.MarginLeft = 10
        renderer.RenderingOptions.MarginRight = 10
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4

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

wkhtmltopdf verschachtelt Einstellungen in GlobalSettings und Objects, wobei MarginSettings ein separates Objekt ist.IronPDF bietet direkte RenderingOptions Eigenschaften mit klaren Namen wie PaperOrientation, MarginTop und PaperSize.

wkhtmltopdf API zu IronPDF Mapping-Referenz

Dieses Mapping beschleunigt die Migration, indem es direkte API-Entsprechungen aufzeigt:

CLI-zu-IronPDF-Zuordnung

wkhtmltopdf CLI-Option IronPDF-Äquivalent
wkhtmltopdf input.html output.pdf renderer.RenderHtmlFileAsPdf()
wkhtmltopdf URL output.pdf renderer.RenderUrlAsPdf()
--page-size A4 RenderingOptions.PaperSize = PdfPaperSize.A4
--page-size Letter RenderingOptions.PaperSize = PdfPaperSize.Letter
--orientation Landscape RenderingOptions.PaperOrientation = Landscape
--margin-top 10mm RenderingOptions.MarginTop = 10
--margin-bottom 10mm RenderingOptions.MarginBottom = 10
--margin-left 10mm RenderingOptions.MarginLeft = 10
--margin-right 10mm RenderingOptions.MarginRight = 10
--header-html header.html RenderingOptions.HtmlHeader
--footer-center "[page]" {page} Platzhalter
--footer-center "[toPage]" {total-pages} Platzhalter
--enable-javascript Standardmäßig aktiviert
--javascript-delay 500 RenderingOptions.WaitFor.RenderDelay = 500
--dpi 300 RenderingOptions.Dpi = 300
--grayscale RenderingOptions.GrayScale = true

C# Wrapper API-Mapping

wkhtmltopdf Wrapper IronPDF
SynchronizedConverter ChromePdfRenderer
HtmlToPdfDocument RenderingOptions
GlobalSettings.Out pdf.SaveAs()
GlobalSettings.PaperSize RenderingOptions.PaperSize
GlobalSettings.Orientation RenderingOptions.PaperOrientation
GlobalSettings.Margins RenderingOptions.Margin*
ObjectSettings.Page RenderHtmlFileAsPdf()
ObjectSettings.HtmlContent RenderHtmlAsPdf()
converter.Convert(doc) renderer.RenderHtmlAsPdf()

Migration der Platzhalter-Syntax

wkhtmltopdf Platzhalter IronPDF Platzhalter
[page] {page}
[toPage] {total-pages}
[date] {date}
[time] {time}
[title] {html-title}
[url] {url}

Gängige Migrationsprobleme und Lösungen

Aufgabe 1: Syntax von Kopf-/Fußzeilen-Platzhaltern

wkhtmltopdf: Verwendet die Syntax mit eckigen Klammern wie [page] und [toPage].

Lösung: Aktualisierung der Platzhalter für geschweifte Klammern in IronPDF:

// Before (wkhtmltopdf)
FooterSettings = { Left = "Page [page] of [toPage]" }

// After (IronPDF)
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    HtmlFragment = "<div style='text-align:left;'>Page {page} of {total-pages}</div>",
    MaxHeight = 25
};
// Before (wkhtmltopdf)
FooterSettings = { Left = "Page [page] of [toPage]" }

// After (IronPDF)
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    HtmlFragment = "<div style='text-align:left;'>Page {page} of {total-pages}</div>",
    MaxHeight = 25
};
' Before (wkhtmltopdf)
FooterSettings = New With {.Left = "Page [page] of [toPage]"}

' After (IronPDF)
renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter With {
    .HtmlFragment = "<div style='text-align:left;'>Page {page} of {total-pages}</div>",
    .MaxHeight = 25
}
$vbLabelText   $csharpLabel

Ausgabe 2: JavaScript-Verzögerungskonfiguration

wkhtmltopdf: Verwendet die JavaScriptDelay-Eigenschaft mit eingeschränkter Zuverlässigkeit.

Lösung:IronPDF bietet mehrere Möglichkeiten:

renderer.RenderingOptions.EnableJavaScript = true;

// Option 1: Fixed delay
renderer.RenderingOptions.WaitFor.RenderDelay(500);

// Option 2: Wait for specific element (more reliable)
renderer.RenderingOptions.WaitFor.HtmlElementById("content-loaded");

// Option 3: Wait for JavaScript condition
renderer.RenderingOptions.WaitFor.JavaScript("window.renderComplete === true");
renderer.RenderingOptions.EnableJavaScript = true;

// Option 1: Fixed delay
renderer.RenderingOptions.WaitFor.RenderDelay(500);

// Option 2: Wait for specific element (more reliable)
renderer.RenderingOptions.WaitFor.HtmlElementById("content-loaded");

// Option 3: Wait for JavaScript condition
renderer.RenderingOptions.WaitFor.JavaScript("window.renderComplete === true");
renderer.RenderingOptions.EnableJavaScript = True

' Option 1: Fixed delay
renderer.RenderingOptions.WaitFor.RenderDelay(500)

' Option 2: Wait for specific element (more reliable)
renderer.RenderingOptions.WaitFor.HtmlElementById("content-loaded")

' Option 3: Wait for JavaScript condition
renderer.RenderingOptions.WaitFor.JavaScript("window.renderComplete === true")
$vbLabelText   $csharpLabel

Ausgabe 3: Modernes CSS ohne Rendering

Symptom: CSS Grid- und Flexbox-Layouts werden in wkhtmltopdf falsch dargestellt.

Lösung: Die Chromium-Engine von IronPDF verarbeitet modernes CSS korrekt:

// This CSS now works with IronPDF
var html = @"
<style>
    .grid { display: grid; grid-template-columns: repeat(3, 1fr); gap: 10px; }
    .flex { display: flex; justify-content: space-between; align-items: center; }
</style>
<div class='grid'>
    <div>Column 1</div>
    <div>Column 2</div>
    <div>Column 3</div>
</div>";

var pdf = renderer.RenderHtmlAsPdf(html);
// This CSS now works with IronPDF
var html = @"
<style>
    .grid { display: grid; grid-template-columns: repeat(3, 1fr); gap: 10px; }
    .flex { display: flex; justify-content: space-between; align-items: center; }
</style>
<div class='grid'>
    <div>Column 1</div>
    <div>Column 2</div>
    <div>Column 3</div>
</div>";

var pdf = renderer.RenderHtmlAsPdf(html);
Dim html As String = "
<style>
    .grid { display: grid; grid-template-columns: repeat(3, 1fr); gap: 10px; }
    .flex { display: flex; justify-content: space-between; align-items: center; }
</style>
<div class='grid'>
    <div>Column 1</div>
    <div>Column 2</div>
    <div>Column 3</div>
</div>"

Dim pdf = renderer.RenderHtmlAsPdf(html)
$vbLabelText   $csharpLabel

Ausgabe 4: Synchrones vs. Asynchrones Rendering

wkhtmltopdf: Wrapper sind synchrone und Block-Threads.

Lösung:IronPDF unterstützt asynchrones Rendering:

public async Task<byte[]> GeneratePdfAsync(string html)
{
    var renderer = new ChromePdfRenderer();
    var pdf = await renderer.RenderHtmlAsPdfAsync(html);
    return pdf.BinaryData;
}
public async Task<byte[]> GeneratePdfAsync(string html)
{
    var renderer = new ChromePdfRenderer();
    var pdf = await renderer.RenderHtmlAsPdfAsync(html);
    return pdf.BinaryData;
}
Imports System.Threading.Tasks

Public Async Function GeneratePdfAsync(html As String) As Task(Of Byte())
    Dim renderer As New ChromePdfRenderer()
    Dim pdf = Await renderer.RenderHtmlAsPdfAsync(html)
    Return pdf.BinaryData
End Function
$vbLabelText   $csharpLabel

wkhtmltopdf Checkliste für die Migration

Vor der Migration anfallende Aufgaben

Überprüfen Sie Ihre Codebasis, um die Verwendung von wkhtmltopdf zu identifizieren:

# Find all wkhtmltopdf references
grep -r "WkHtmlToPdfDotNet\|DinkToPdf\|TuesPechkin\|Rotativa" --include="*.cs" .
grep -r "wkhtmltopdf" --include="*.yml" --include="*.yaml" --include="Dockerfile" .
# Find all wkhtmltopdf references
grep -r "WkHtmlToPdfDotNet\|DinkToPdf\|TuesPechkin\|Rotativa" --include="*.cs" .
grep -r "wkhtmltopdf" --include="*.yml" --include="*.yaml" --include="Dockerfile" .
SHELL

Auffinden und Dokumentieren von wkhtmltopdf-Binärdateien zur Entfernung. Aktuelle Einstellungen des Dokuments (Papierformat, Ränder, Kopf- und Fußzeilen).

Aufgaben der Code-Aktualisierung

  1. Alle wkhtmltopdf WrapperNuGet-Pakete entfernen
  2. Entfernen von wkhtmltopdf-Binärdateien (wkhtmltopdf.exe, wkhtmltox.dll)
  3. IronPDF NuGet-Paket installieren
  4. Namespace-Importe von WkHtmlToPdfDotNet auf IronPdf aktualisieren
  5. Ersetzen Sie SynchronizedConverter durch ChromePdfRenderer
  6. Konvertieren Sie HtmlToPdfDocument-Muster in direkte Rendering-Methoden.
  7. Aktualisieren Sie die Konfigurationen von GlobalSettings auf RenderingOptions
  8. Konvertieren Sie Randkonfigurationen von MarginSettings in einzelne Eigenschaften.
  9. Aktualisieren Sie die Platzhaltersyntax ([page] → {page}, [toPage] → {total-pages})
  10. IronPDF-Lizenzinitialisierung beim Start hinzufügen

Post-Migrationstests

Überprüfen Sie diese Aspekte nach der Migration:

  • Visueller Vergleich der PDF-Ausgabe (sollte mit moderner CSS-Unterstützung verbessert werden)
  • Überprüfung der modernen CSS-Darstellung (CSS Grid und Flexbox funktionieren jetzt)
  • Testen Sie JavaScript-lastige Seiten
  • Sicherheitsscan zur Bestätigung, dass keine wkhtmltopdf-Binärdateien mehr vorhanden sind
  • Lasttest für Leistungsvergleich

Sicherheitsüberprüfung

# Scan for any remaining wkhtmltopdf artifacts
find /var/www/ -name "*wkhtmlto*" 2>/dev/null
find /usr/local/bin/ -name "*wkhtmlto*" 2>/dev/null
docker images | grep wkhtmltopdf

# Check if any process is still using it
ps aux | grep wkhtmltopdf
# Scan for any remaining wkhtmltopdf artifacts
find /var/www/ -name "*wkhtmlto*" 2>/dev/null
find /usr/local/bin/ -name "*wkhtmlto*" 2>/dev/null
docker images | grep wkhtmltopdf

# Check if any process is still using it
ps aux | grep wkhtmltopdf
SHELL

Die wichtigsten Vorteile der Migration zu IronPDF

Der Wechsel von wkhtmltopdf zu IronPDF bietet mehrere entscheidende Vorteile:

Sicherheit: CVE-2022-35583 und alle wkhtmltopdf-Schwachstellen wurden behoben. IronPDF hat keine bekannten CVEs und erhält regelmäßig Sicherheitsupdates.

Moderne Rendering-Engine: IronPDF nutzt die aktuelle Chromium-Engine und gewährleistet so volle Unterstützung für CSS3, CSS Grid, Flexbox und ES6+ JavaScript . Moderne Frameworks werden korrekt wiedergegeben.

Vereinfachte API: Direkte Rendering-Methoden ersetzen die bisherigen Dokumentkonstruktionsmuster. Die integrierten SaveAs() Methoden eliminieren die manuelle Byte-Verarbeitung.

Erweiterte Funktionen: PDF-Manipulation, digitale Signaturen, PDF/A-Konformität, Wasserzeichen und Zusammenführungs-/Aufteilungsoperationen sind integrierte Funktionen, die wkhtmltopdf nicht bieten konnte.

Aktive Weiterentwicklung: Da die Verbreitung von .NET 10 und C# 14 bis 2026 zunimmt, gewährleisten die regelmäßigen Updates von IronPDF die Kompatibilität mit aktuellen und zukünftigen .NET Versionen.

Asynchrone Unterstützung: Verhindern Sie Thread-Blockierungen in stark ausgelasteten Webanwendungen durch native async/await-Unterstützung.

Curtis Chau
Curtis Chau
  Jetzt mit dem Ingenieurteam chatten
Technischer Autor

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

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen

Iron Support Team

Wir sind 24 Stunden am Tag, 5 Tage die Woche online.
Chat
E-Mail
Rufen Sie mich an