Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. Guides de migration
  4. migration de wkhtmltopdf vers IronPDF
GUIDES DE MIGRATION

Comment migrer de wkhtmltopdf vers IronPDF en C#

Curtis Chau
Curtis Chau
Mis à jour:

wkhtmltopdf est un outil largement utilisé pour convertir des documents HTML en PDF à l'aide de Qt WebKit. Malgré sa popularité auprès des développeurs pour ses fonctionnalités en ligne de commande et sa licence gratuite, le projet présente aujourd'hui des risques de sécurité critiques qui ne peuvent plus être ignorés. La bibliothèque a été officiellement abandonnée en 2016-2017, et une vulnérabilité de gravité CRITICAL (CVE-2022-35583) n'a toujours pas été corrigée.

Ce guide fournit un chemin de migration complet dewkhtmltopdfvers IronPDF, avec des instructions étape par étape, des comparaisons de code et des exemples pratiques pour les développeurs professionnels .NET qui ont besoin d'éliminer ce risque de sécurité de leurs applications.

Avertissement de sécurité critique : CVE-2022-35583

wkhtmltopdf contient une faille de sécurité critique qui ne sera jamais corrigée :

Problème Sévérité Statut
CVE-2022-35583 CRITIQUE (9,8/10) UNPATCHED
Vulnérabilité SSRF Risque de reprise de l'infrastructure UNPATCHED
Dernière mise à jour 2016-2017 ABANDONNÉ
Version WebKit 2015 (Qt WebKit) OBSOLETE
Support de la grille CSS Aucun Rupture
Support Flexbox Partiel Rupture
ES6+ JavaScript Aucun Rupture

Comment fonctionne l'attaque du SSRF

La vulnérabilité Server-Side Request Forgery permet aux attaquants d'accéder à des services internes, de voler des informations d'identification, de scanner votre réseau interne et d'exfiltrer des données sensibles par le biais d'un code HTML élaboré :


<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

Lorsquewkhtmltopdfrend ce HTML, il récupère ces URL à partir du contexte réseau de votre serveur, en contournant les pare-feux et les contrôles de sécurité.

Bibliothèques Wrapper affectées

Tous les wrappers .NET pourwkhtmltopdfhéritent de ces vulnérabilités :

Bibliothèque Wrapper Statut Risque de sécurité
DinkToPdf Abandonné ⚠️ CRITIQUE
Rotativa Abandonné ⚠️ CRITIQUE
TuesPechkin Abandonné ⚠️ CRITIQUE
WkHtmlToPdf-DotNet Abandonné ⚠️ CRITIQUE
NReco.PdfGenerator Utilise wkhtmltopdf ⚠️ CRITIQUE

Si vous utilisez l'une de ces bibliothèques, vous êtes vulnérable à la CVE-2022-35583.

IronPDF vswkhtmltopdf: Comparaison des fonctionnalités

La compréhension des différences architecturales aide les décideurs techniques à évaluer l'investissement dans la migration :

Fonction wkhtmltopdf IronPDF
Licence LGPLv3 (Gratuit) Commercial
Moteur de rendu Qt WebKit (2015) Moteur Chromium actuel
Vulnérabilités de sécurité CVE-2022-35583, problèmes majeurs non corrigés Aucun CVE connu
Maintenance active Abandonné, aucune mise à jour significative depuis 2017 Mise à jour active avec des versions régulières
Soutien aux normes Web modernes Limité (flexbox cassé, pas de grille CSS) Prise en charge
Intégration et support Limité aux forums communautaires Documentation complète et assistance dédiée
CSS Grid ❌ Non pris en charge ✅ Pris en charge
Flexbox ⚠️ Cassé ✅ Pris en charge
ES6+ JavaScript ❌ Non pris en charge ✅ Pris en charge
Async/Await ❌ Non pris en charge ✅ Pris en charge
Manipulation de PDF ❌ Non pris en charge ✅ Pris en charge
Signatures numériques ❌ Non pris en charge ✅ Pris en charge
Conformité PDF/A ❌ Non pris en charge ✅ Pris en charge

Démarrage rapide : migration dewkhtmltopdfvers IronPDF

La migration peut commencer immédiatement grâce à ces étapes fondamentales.

Étape 1 : Supprimer les paquets et les binaires de wkhtmltopdf

Supprimez tous les paquets wrapperwkhtmltopdf:

# Removewkhtmltopdfwrapper (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

# Removewkhtmltopdfbinary from your deployment
# Delete wkhtmltopdf.exe, wkhtmltox.dll, etc.
# Removewkhtmltopdfwrapper (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

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

Étape 2 : Installer IronPDF

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

Étape 3 : Mise à jour des espaces de noms

Remplacer les espaces de nomswkhtmltopdfpar l'espace de nomsIronPDF:

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

Étape 4 : initialisation de la licence

Ajouter l'initialisation de la licence au démarrage de l'application :

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

Exemples de migration de code

Conversion de HTML en PDF

L'opération la plus fondamentale révèle la différence de complexité entre ces approches PDF .NET.

wkhtmltopdf Approche:

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

Approche IronPDF:

// 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 nécessite la création d'un SynchronizedConverter avec PdfTools, la construction d'un HtmlToPdfDocument avec GlobalSettings et Objects, la définition de propriétés telles que ColorMode, Orientation et PaperSize, l'appel de converter.Convert() pour obtenir des octets bruts et l'écriture manuelle dans un fichier avec File.WriteAllBytes().

IronPDF élimine complètement cette cérémonie : créez un ChromePdfRenderer, appelez RenderHtmlAsPdf() et utilisez la méthode intégrée SaveAs().

Pour les scénarios avancés de conversion de HTML en PDF, voir le guide de conversion de HTML en PDF.

Conversion des URL en PDF

La conversion d'URL en PDF présente des schémas de complexité similaires.

wkhtmltopdf Approche:

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

Approche IronPDF:

// 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 utilise la propriété Page dans ObjectSettings pour spécifier une URL, nécessitant le même modèle de construction de document.IronPDFfournit une méthode dédiée RenderUrlAsPdf() qui exprime clairement l'intention.

Explorez la URL vers la documentation PDF pour l'authentification et les options d'en-tête personnalisées.

Paramètres personnalisés : Fichiers HTML avec configuration de la page

La configuration de l'orientation, des marges et de la taille du papier nécessite différentes approches.

wkhtmltopdf Approche:

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

Approche IronPDF:

// 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 imbrique les paramètres à l'intérieur de GlobalSettings et Objects, avec MarginSettings comme un objet séparé.IronPDFfournit des propriétés directes RenderingOptions avec des noms clairs comme PaperOrientation, MarginTop et PaperSize.

Référence de mappage de l'API wkhtmltopdf vers IronPDF

Cette cartographie accélère la migration en indiquant les équivalents directs des API :

Mappage CLI vers IronPDF

option CLI de wkhtmltopdf Équivalent d'IronPDF
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} espace réservé
--footer-center "[toPage]" {total-pages} espace réservé
--enable-javascript Activé par défaut
--javascript-delay 500 RenderingOptions.WaitFor.RenderDelay = 500
--dpi 300 RenderingOptions.Dpi = 300
--grayscale RenderingOptions.GrayScale = true

Mappage de l'API du wrapper C

wkhtmltopdfWrapper 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 de la syntaxe des espaces réservés

wkhtmltopdfPlaceholder IronPDFPlaceholder
[page] {page}
[toPage] {total-pages}
[date] {date}
[time] {time}
[title] {html-title}
[url] {url}

Problèmes de migration courants et solutions

Enjeu 1 : Syntaxe de l'en-tête/du pied de page

wkhtmltopdf : Utilise la syntaxe des crochets comme [page] et [toPage].

Solution: Mise à jour des caractères de remplacement des accolades d'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

Edition 2 : Configuration du délai JavaScript

wkhtmltopdf : Utilise la propriété JavaScriptDelay avec une fiabilité limitée.

Solution:IronPDFpropose plusieurs options :

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

Édition 3 : CSS moderne sans rendu

Symptôme: Les mises en page CSS Grid et Flexbox s'affichent de manière incorrecte dans wkhtmltopdf.

Solution:Le moteur Chromium d'IronPDF gère correctement les feuilles de style CSS modernes :

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

Edition 4 : Rendu synchrone ou asynchrone

wkhtmltopdf: Les wrappers sont synchrones et bloquent les threads.

Solution:IronPDFprend en charge le rendu asynchrone :

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

wkhtmltopdfListe de contrôle pour la migration

Tâches préalables à la migration

Auditez votre base de code pour identifier toute utilisation dewkhtmltopdf:

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

Localiser et documenter les fichiers binaireswkhtmltopdfpour les supprimer. Documenter les paramètres actuels (taille du papier, marges, en-têtes/pieds de page).

Tâches de mise à jour du code

  1. Supprimer tous les paquets NuGet de wrapper wkhtmltopdf
  2. Supprimer les binaires dewkhtmltopdf(wkhtmltopdf.exe, wkhtmltox.dll)
  3. Installer le paquet NuGet IronPDF
  4. Mettez à jour les importations d'espace de noms de WkHtmlToPdfDotNet à IronPdf
  5. Remplacez SynchronizedConverter par ChromePdfRenderer
  6. Convertir les modèles HtmlToPdfDocument en méthodes de rendu direct
  7. Mettez à jour les configurations GlobalSettings vers RenderingOptions
  8. Convertissez les configurations de marge de MarginSettings en propriétés individuelles
  9. Mettre à jour la syntaxe des espaces réservés ([page] → {page}, [toPage] → {total-pages})
  10. Ajouter l'initialisation de la licenceIronPDFau démarrage

Test de post-migration

Après la migration, vérifiez ces aspects :

  • Comparaison visuelle de la sortie PDF (devrait s'améliorer avec un support CSS moderne)
  • Vérifier le rendu CSS moderne (CSS Grid et Flexbox fonctionnent désormais)
  • Tester les pages à forte teneur en JavaScript
  • Analyse de sécurité pour confirmer qu'il ne reste plus de binaires wkhtmltopdf
  • Test de charge pour la comparaison des performances

Vérification de sécurité

# Scan for any remainingwkhtmltopdfartifacts
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 remainingwkhtmltopdfartifacts
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

Avantages clés de la migration vers IronPDF

Le passage dewkhtmltopdfàIronPDFprésente plusieurs avantages décisifs :

Sécurité : La vulnérabilité CVE-2022-35583 et toutes les vulnérabilitéswkhtmltopdfont été éliminées.IronPDFn'a pas de CVE connu et reçoit régulièrement des mises à jour de sécurité.

Moteur de rendu moderne :IronPDFutilise le moteur Chromium actuel, garantissant une prise en charge complète de CSS3, CSS Grid, Flexbox et JavaScript ES6+. Les frameworks modernes sont correctement restitués.

API simplifiée : les méthodes de rendu direct remplacent les modèles de construction de documents. Les méthodes intégrées SaveAs() éliminent la gestion manuelle des octets.

Fonctionnalités étendues : la manipulation de fichiers PDF, les signatures numériques, la conformité PDF/A, les filigranes et les opérations de fusion/séparation sont des fonctionnalités intégrées quewkhtmltopdfne pouvait pas fournir.

Développement actif : Avec l'adoption croissante de .NET 10 et C# 14 jusqu'en 2026, les mises à jour régulières d'IronPDF garantissent la compatibilité avec les versions actuelles et futures de .NET .

Prise en charge asynchrone : évitez le blocage des threads dans les applications Web à forte charge grâce à la prise en charge native d'async/await.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit

Équipe de soutien Iron

Nous sommes en ligne 24 heures sur 24, 5 jours sur 7.
Chat
Email
Appelez-moi