Didn’t find what you were looking for?
Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. Guides de migration
  4. Haukcode.DinkToPdf à IronPDF
VIDéOS

Comment convertir des fichiers DOCX en PDF en utilisant C#

Curtis Chau
Curtis Chau
Mis à jour:

Haukcode.DinkToPdf est un fork communautaire de l'ancienne bibliothèque DinkToPdf, qui encapsule le binaire wkhtmltopdf pour convertir le HTML en PDF pour les applications .NET. Le fork a été renommé plus tard en Haukcode.WkHtmlToPdfDotNet, avec la dernière version 1.5.95 publiée le 22 octobre 2024 sous LGPL-3.0-ou-plus. Bien que le fork ait maintenu le package vivant sur NuGet après que l'original DinkToPdf (1.0.8, 18 avril 2017) ait été abandonné, il se lie toujours au même binaire wkhtmltopdf archivé que son parent. Le dépôt wkhtmltopdf/wkhtmltopdf a été archivé le 2 janvier 2023, et l'ensemble de l'organisation GitHub wkhtmltopdf a été archivé le 10 juillet 2024, les problèmes en amont ne seront donc pas corrigés.

Ce guide offre un chemin de migration de Haukcode.DinkToPdf / Haukcode.WkHtmlToPdfDotNet vers IronPDF, comprenant des instructions étape par étape, des comparaisons de code et des exemples pratiques pour les développeurs .NET cherchant à se débarrasser du binaire wkhtmltopdf archivé.

Conseil de sécurité : CVE-2022-35583

Haukcode.DinkToPdf hérite d'une alerte de sécurité lancée contre son binaire wkhtmltopdf amont :

CVE-2022-35583 — Alerte SSRF contre wkhtmltopdf 0.12.6

Une alerte Server-Side Request Forgery a été publiée contre wkhtmltopdf 0.12.6 (CVSS 9.8 dans NVD ; contestée par le projet wkhtmltopdf amont, qui la considère comme un problème de sanitisation d'entrée côté application plutôt qu'un bogue de la bibliothèque). Quoi qu'il en soit, cela ne sera pas corrigé — l'amont est archivé. Les motifs d'exposition typiques signalés dans la discussion publique incluent :

  • Vector d'attaque : Le contenu HTML non fiable peut inciter le moteur de rendu à récupérer des ressources internes pendant la conversion
  • Métadonnées AWS : Les requêtes vers http://169.254.169.254 peuvent renvoyer des métadonnées d'instance si le renderer s'exécute sur EC2.
  • Accès au réseau interne : Les services internes peuvent être accessibles depuis l'hôte de rendu
  • Inclusion de fichier local : Les fichiers locaux peuvent être lisibles via le protocole file://.

Aucun correctif amont n'est attendu — le dépôt wkhtmltopdf a été archivé le 2 janvier 2023, avec la dernière version (0.12.6) en juin 2020.

IronPDF vs Haukcode.DinkToPdf : Comparaison des fonctionnalités

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

Aspect Haukcode.DinkToPdf IronPDF
Moteur sous-jacent wkhtmltopdf (fork QtWebKit, environ 2015) Chrome moderne
État de la sécurité Alerte CVE-2022-35583 (non corrigée / contestée en amont) Aucun CVE critique connu
Statut du projet Fork communautaire; wkhtmltopdf amont archivé Maintenance active
HTML5/CSS3 Pas de Flexbox/Grid moderne CSS3 complet
JavaScript Limitée, incohérente Prise en charge complète
Binaires natifs libwkhtmltox.dll/.so/.dylib par plateforme Paquet NuGet géré
Sécurité des threads SynchronizedConverter sérialise les appels Sécurité des threads dès la conception
Support Communauté Support professionnel
Mises à jour Dernière version du fork 1.5.95 (22 oct. 2024); wkhtmltopdf amont 0.12.6 (juin 2020) Publications régulières
Licence LGPL-3.0-or-later (fork) / MIT (DinkToPdf original) Commercial avec essai gratuit

Démarrage rapide : Migration de Haukcode.DinkToPdf vers IronPDF

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

Étape 1 : Supprimer DinkToPdf et les binaires natifs

Supprimer les paquets NuGet de Haukcode.DinkToPdf :

# Remove NuGet packages
dotnet remove package DinkToPdf
dotnet remove package Haukcode.DinkToPdf
dotnet remove package Haukcode.WkHtmlToPdf-DotNet
# Remove NuGet packages
dotnet remove package DinkToPdf
dotnet remove package Haukcode.DinkToPdf
dotnet remove package Haukcode.WkHtmlToPdf-DotNet
SHELL

Supprimer les binaires natifs de votre projet:

  • libwkhtmltox.dll (Windows)
  • libwkhtmltox.so (Linux)
  • libwkhtmltox.dylib (macOS)

Étape 2 : Installer IronPDF

# Install IronPDF
dotnet add package IronPdf
# Install IronPDF
dotnet add package IronPdf
SHELL

Étape 3 : Mise à jour des espaces de noms

Remplacer les espaces de noms DinkToPdf par IronPDF:

// Before (Haukcode.DinkToPdf)
using DinkToPdf;
using DinkToPdf.Contracts;

// After (IronPDF)
using IronPdf;
using IronPdf.Rendering;  // For RenderingOptions
// Before (Haukcode.DinkToPdf)
using DinkToPdf;
using DinkToPdf.Contracts;

// After (IronPDF)
using IronPdf;
using IronPdf.Rendering;  // For RenderingOptions
Imports IronPdf
Imports IronPdf.Rendering
$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 basique de HTML en PDF

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

Approche de Haukcode.DinkToPdf :

// NuGet: Install-Package DinkToPdf
using DinkToPdf;
using DinkToPdf.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 = "<html><body><h1>Hello World</h1></body></html>",
                }
            }
        };

        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("output.pdf", pdf);
    }
}
// NuGet: Install-Package DinkToPdf
using DinkToPdf;
using DinkToPdf.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 = "<html><body><h1>Hello World</h1></body></html>",
                }
            }
        };

        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("output.pdf", pdf);
    }
}
Imports DinkToPdf
Imports DinkToPdf.Contracts
Imports System.IO

Module Program
    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 List(Of ObjectSettings) From {
                New ObjectSettings() With {
                    .HtmlContent = "<html><body><h1>Hello World</h1></body></html>"
                }
            }
        }

        Dim pdf As Byte() = converter.Convert(doc)
        File.WriteAllBytes("output.pdf", pdf)
    End Sub
End Module
$vbLabelText   $csharpLabel

Approche IronPDF:

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

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;
using System.IO;

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
Imports System.IO

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

Haukcode.DinkToPdf nécessite de créer un SynchronizedConverter avec PdfTools, de construire un HtmlToPdfDocument avec des GlobalSettings et Objects imbriqués, d'ajouter un ObjectSettings avec HtmlContent, d'appeler converter.Convert() pour obtenir les octets bruts et d'écrire manuellement dans un fichier avec File.WriteAllBytes().

IronPDF simplifie cela en trois lignes : créer un ChromePdfRenderer, appeler RenderHtmlAsPdf(), et utiliser 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 différences de modèles similaires.

Approche de Haukcode.DinkToPdf :

// NuGet: Install-Package DinkToPdf
using DinkToPdf;
using DinkToPdf.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 DinkToPdf
using DinkToPdf;
using DinkToPdf.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);
    }
}
Imports DinkToPdf
Imports DinkToPdf.Contracts
Imports System.IO

Module Program
    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 List(Of ObjectSettings) From {
                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

Haukcode.DinkToPdf utilise le même modèle de construction de document avec ObjectSettings.Page pour les URL.IronPDF fournit une méthode RenderUrlAsPdf() dédiée 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 de page personnalisés

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

Approche de Haukcode.DinkToPdf :

// NuGet: Install-Package DinkToPdf
using DinkToPdf;
using DinkToPdf.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.Letter,
                Margins = new MarginSettings() { Top = 10, Bottom = 10, Left = 10, Right = 10 }
            },
            Objects = {
                new ObjectSettings() {
                    HtmlContent = "<html><body><h1>Landscape Document</h1><p>Custom page settings</p></body></html>",
                }
            }
        };

        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("landscape.pdf", pdf);
    }
}
// NuGet: Install-Package DinkToPdf
using DinkToPdf;
using DinkToPdf.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.Letter,
                Margins = new MarginSettings() { Top = 10, Bottom = 10, Left = 10, Right = 10 }
            },
            Objects = {
                new ObjectSettings() {
                    HtmlContent = "<html><body><h1>Landscape Document</h1><p>Custom page settings</p></body></html>",
                }
            }
        };

        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("landscape.pdf", pdf);
    }
}
Imports DinkToPdf
Imports DinkToPdf.Contracts
Imports System.IO

Module Program
    Sub Main()
        Dim converter = New SynchronizedConverter(New PdfTools())

        Dim doc = New HtmlToPdfDocument() With {
            .GlobalSettings = New GlobalSettings() With {
                .ColorMode = ColorMode.Color,
                .Orientation = Orientation.Landscape,
                .PaperSize = PaperKind.Letter,
                .Margins = New MarginSettings() With {.Top = 10, .Bottom = 10, .Left = 10, .Right = 10}
            },
            .Objects = {
                New ObjectSettings() With {
                    .HtmlContent = "<html><body><h1>Landscape Document</h1><p>Custom page settings</p></body></html>"
                }
            }
        }

        Dim pdf As Byte() = converter.Convert(doc)
        File.WriteAllBytes("landscape.pdf", pdf)
    End Sub
End Module
$vbLabelText   $csharpLabel

Approche IronPDF:

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.MarginTop = 10;
        renderer.RenderingOptions.MarginBottom = 10;
        renderer.RenderingOptions.MarginLeft = 10;
        renderer.RenderingOptions.MarginRight = 10;

        var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Landscape Document</h1><p>Custom page settings</p></body></html>");

        pdf.SaveAs("landscape.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.PaperOrientation = PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.MarginTop = 10;
        renderer.RenderingOptions.MarginBottom = 10;
        renderer.RenderingOptions.MarginLeft = 10;
        renderer.RenderingOptions.MarginRight = 10;

        var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Landscape Document</h1><p>Custom page settings</p></body></html>");

        pdf.SaveAs("landscape.pdf");
    }
}
Imports IronPdf
Imports IronPdf.Rendering

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()

        renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape
        renderer.RenderingOptions.MarginTop = 10
        renderer.RenderingOptions.MarginBottom = 10
        renderer.RenderingOptions.MarginLeft = 10
        renderer.RenderingOptions.MarginRight = 10

        Dim pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Landscape Document</h1><p>Custom page settings</p></body></html>")

        pdf.SaveAs("landscape.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

Haukcode.DinkToPdf imbrique les paramètres à l'intérieur de GlobalSettings avec un objet MarginSettings séparé.IronPDF fournit des propriétés RenderingOptions directes avec des noms clairs tels que PaperSize, PaperOrientation, et des propriétés de marge individuelles.

Haukcode.DinkToPdf API to IronPDF Mapping Reference (Référence de mappage de l'API DinkToPdf vers IronPDF)

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

Mise en correspondance des classes de convertisseurs

Haukcode.DinkToPdf IronPDF
SynchronizedConverter ChromePdfRenderer
BasicConverter ChromePdfRenderer
PdfTools N/A
IConverter N/A

Mise en correspondance de la configuration des documents

Haukcode.DinkToPdf IronPDF
HtmlToPdfDocument Appel de méthode
GlobalSettings RenderingOptions
ObjectSettings RenderingOptions
converter.Convert(doc) renderer.RenderHtmlAsPdf(html)

Mappage des propriétés de GlobalSettings

Propriété GlobalSettings Propriété d'IronPDF
ColorMode RenderingOptions.GrayScale
Orientation RenderingOptions.PaperOrientation
PaperSize RenderingOptions.PaperSize
Margins.Top RenderingOptions.MarginTop
Margins.Bottom RenderingOptions.MarginBottom
Margins.Left RenderingOptions.MarginLeft
Margins.Right RenderingOptions.MarginRight

Mappage des propriétés d'ObjectSettings

Propriété ObjectSettings Équivalent d'IronPDF
HtmlContent Premier paramètre à RenderHtmlAsPdf()
Page (URL) renderer.RenderUrlAsPdf(url)
HeaderSettings.Right = "[page]" {page} à l'intérieur de HtmlHeader.HtmlFragment

Migration de la syntaxe des espaces réservés

Haukcode.DinkToPdf IronPDF
[page] {page}
[toPage] {total-pages}
[date] {date}

Problèmes de migration courants et solutions

Enjeu 1 : Exigence Singleton

Haukcode.DinkToPdf : Nécessite SynchronizedConverter en tant que singleton en raison des problèmes de sécurité des threads avec le binaire natif wkhtmltopdf.

Solution : ChromePdfRenderer d'IronPDF est sécurisé pour les threads par conception—aucun singleton requis :

// Before (DinkToPdf) - MUST be singleton
services.AddSingleton(typeof(IConverter), new SynchronizedConverter(new PdfTools()));

// After (IronPDF) - Can be singleton or transient (both work)
services.AddSingleton<IPdfService, IronPdfService>();
// Or services.AddTransient<IPdfService, IronPdfService>() - both are safe!
// Before (DinkToPdf) - MUST be singleton
services.AddSingleton(typeof(IConverter), new SynchronizedConverter(new PdfTools()));

// After (IronPDF) - Can be singleton or transient (both work)
services.AddSingleton<IPdfService, IronPdfService>();
// Or services.AddTransient<IPdfService, IronPdfService>() - both are safe!
' Before (DinkToPdf) - MUST be singleton
services.AddSingleton(GetType(IConverter), New SynchronizedConverter(New PdfTools()))

' After (IronPDF) - Can be singleton or transient (both work)
services.AddSingleton(Of IPdfService, IronPdfService)()
' Or services.AddTransient(Of IPdfService, IronPdfService)() - both are safe!
$vbLabelText   $csharpLabel

Édition 2 : Dépendances binaires natives

Haukcode.DinkToPdf: Requiert des bibliothèques natives spécifiques à la plateforme (libwkhtmltox.dll/so/dylib).

Solution:IronPDF est autonome et ne présente aucune dépendance binaire native. Supprimez ces fichiers après la migration :

  • libwkhtmltox.dll (Windows)
  • libwkhtmltox.so (Linux)
  • libwkhtmltox.dylib (macOS)

Édition 3 : Différences de type de retour

Haukcode.DinkToPdf: converter.Convert() returns byte[] directly.

Solution :IronPDF retourne un objet PdfDocument avec plusieurs options de sortie :

var pdf = renderer.RenderHtmlAsPdf(html);
byte[] bytes = pdf.BinaryData;  // Get bytes
pdf.SaveAs("output.pdf");       // Or save directly
var pdf = renderer.RenderHtmlAsPdf(html);
byte[] bytes = pdf.BinaryData;  // Get bytes
pdf.SaveAs("output.pdf");       // Or save directly
Dim pdf = renderer.RenderHtmlAsPdf(html)
Dim bytes As Byte() = pdf.BinaryData  ' Get bytes
pdf.SaveAs("output.pdf")  ' Or save directly
$vbLabelText   $csharpLabel

Edition 4 : Syntaxe des espaces réservés dans l'en-tête et le pied de page

Haukcode.DinkToPdf : Utilise la syntaxe de crochet carré comme [page] et [toPage].

Solution: Mise à jour des caractères de remplacement des accolades d'IronPDF :

// Before (DinkToPdf)
HeaderSettings = { Right = "Page [page] of [toPage]" }

// After (IronPDF)
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    HtmlFragment = "<span style='float:right'>Page {page} of {total-pages}</span>"
};
// Before (DinkToPdf)
HeaderSettings = { Right = "Page [page] of [toPage]" }

// After (IronPDF)
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    HtmlFragment = "<span style='float:right'>Page {page} of {total-pages}</span>"
};
' Before (DinkToPdf)
HeaderSettings = New With {.Right = "Page [page] of [toPage]"}

' After (IronPDF)
renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter With {
    .HtmlFragment = "<span style='float:right'>Page {page} of {total-pages}</span>"
}
$vbLabelText   $csharpLabel

Liste de contrôle pour la migration vers DinkToPdf

Tâches préalables à la migration

Auditez votre base de code pour identifier toute utilisation de DinkToPdf :

# Find DinkToPdf namespace usage
grep -r "using DinkToPdf\|using Haukcode" --include="*.cs" .

# Find converter usage
grep -r "SynchronizedConverter\|BasicConverter\|HtmlToPdfDocument" --include="*.cs" .

# Find native library loading
grep -r "wkhtmltopdf\|libwkhtmltox" --include="*.cs" --include="*.csproj" .

# Find GlobalSettings/ObjectSettings usage
grep -r "GlobalSettings\|ObjectSettings\|MarginSettings" --include="*.cs" .
# Find DinkToPdf namespace usage
grep -r "using DinkToPdf\|using Haukcode" --include="*.cs" .

# Find converter usage
grep -r "SynchronizedConverter\|BasicConverter\|HtmlToPdfDocument" --include="*.cs" .

# Find native library loading
grep -r "wkhtmltopdf\|libwkhtmltox" --include="*.cs" --include="*.csproj" .

# Find GlobalSettings/ObjectSettings usage
grep -r "GlobalSettings\|ObjectSettings\|MarginSettings" --include="*.cs" .
SHELL

Documenter les configurations actuelles GlobalSettings et ObjectSettings. Identifiez tout code de chargement de bibliothèque natif pouvant être supprimé.

Tâches de mise à jour du code

  1. Supprimer les paquets NuGet de DinkToPdf
  2. Installez le package NuGet IronPDF
  3. Mettre à jour les imports de l'espace de noms de DinkToPdf à IronPdf
  4. Remplacer SynchronizedConverter par ChromePdfRenderer
  5. Convertir les modèles HtmlToPdfDocument en appels de méthodes directs
  6. Convertir GlobalSettings en RenderingOptions
  7. Convertir ObjectSettings en RenderingOptions
  8. Mettre à jour la syntaxe des espaces réservés ([page] → {page}, [toPage] → {total-pages})
  9. Ajouter l'initialisation de la licence IronPDF au démarrage

Tâches de nettoyage de l'infrastructure

  1. Supprimer les binaires natifs (libwkhtmltox.*)
  2. Supprimer le code de chargement de la bibliothèque native
  3. Supprimer CustomAssemblyLoadContext s'il est présent
  4. Mise à jour de l'injection de dépendance (le singleton n'est plus nécessaire)
  5. Suppression du code de détection de plate-forme pour les binaires natifs

Test de post-migration

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

  • Tester la conversion de HTML en PDF
  • Test de conversion d'URL en PDF
  • Vérifier les paramètres de la page (taille, orientation, marges)
  • Vérifier les en-têtes et les pieds de page avec des espaces réservés
  • Test avec des modèles HTML réels
  • Test de performance sous charge

Avantages clés de la migration vers IronPDF

Le passage de Haukcode.DinkToPdf à IronPDF présente plusieurs avantages décisifs :

Sécurité : Élimine la vulnérabilité CVE-2022-35583 (SSRF) et d'autres vulnérabilités de wkhtmltopdf qui ne seront jamais corrigées.

Moteur de rendu moderne : utilise Chromium, régulièrement mis à jour, au lieu de Qt WebKit, abandonné depuis 2015. Prise en charge complète de HTML5, CSS3 et JavaScript .

Aucun binaire natif : bibliothèque autonome sans DLL spécifiques à la plateforme à gérer. Simplifie le déploiement sur Windows, Linux et macOS.

Sécurité des threads : Pas besoin de singleton—utilisez ChromePdfRenderer librement dans n'importe quel modèle incluant l'instanciation par demande.

API plus simple : Appels de méthode directs (RenderHtmlAsPdf(), RenderUrlAsPdf()) au lieu de constructions complexes d'objets de document.

Développement actif : La cadence de sortie régulière de IronPDF le maintient compatible avec les versions actuelles de .NET, y compris .NET Framework 4.6.2+, .NET Core 3.1+, et .NET 5/6/7/8/9/10.

Veuillez noterDinkToPdf, Haukcode.DinkToPdf, Haukcode.WkHtmlToPdfDotNet, et wkhtmltopdf sont des marques ou des noms de produits de leurs propriétaires respectifs. Ce site n'est affilié ni approuvé ni sponsorisé par l'un de ces projets. Tous les noms de produits, logos et marques sont la propriété de leurs propriétaires respectifs. Les comparaisons sont à titre informatif uniquement et reflètent les informations publiquement disponibles au moment de l'écriture.

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

Mis à jour

Comment définir des tailles de papier personnalisées pour les PDF en utilisant C# | IronPDF

Découvrez comment rendre des fichiers PDF avec des tailles de papier personnalisées en utilisant C# et IronPDF. Cette vidéo vous guide à travers la génération de PDF adaptés à des modèles non standards, idéale pour créer des documents personnalisés tels que des invitations, des affiches ou des rapports personnalisés. Améliorez votre processus de création de documents avec facilité.

Lire la suite
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