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. migration de dinktopdf vers IronPDF
VIDéOS

IronPDF 2021: Moteur de Rendu Chrome EAP - Un Changement de Jeu pour la Génération de PDFs !

Curtis Chau
Curtis Chau
Mis à jour:

DinkToPdf intègre wkhtmltopdf, héritant de toutes ses vulnérabilités en matière de sécurité et de ses limitations techniques. Il est essentiel de comprendre ces questions pour évaluer l'urgence de la migration.

Questions de sécurité critiques

DinkToPdf hérite d'avis de sécurité non corrigés de wkhtmltopdf :

  1. CVE-2022-35583 (SSRF) : Un avis de falsification de requête côté serveur contre wkhtmltopdf 0.12.6 (CVSS 9.8 dans NVD ; contesté par le projet en amont comme un problème de désinfection d'entrée côté application plutôt qu'un bug de la bibliothèque). Quoi qu'il en soit, il ne sera pas corrigé.
  2. Projet archivé : Le dépôt wkhtmltopdf/wkhtmltopdf a été archivé le 2 janvier 2023, et l'ensemble de l'organisation GitHub wkhtmltopdf a été archivée le 10 juillet 2024.
  3. Pas de futurs correctifs de sécurité : Toute vulnérabilité connue ou future ne sera pas corrigée en amont.

Problèmes techniques

Problème Impact
Sécurité des threads BasicConverter est uniquement monothread ; SynchronizedConverter sérialise les appels et peut toujours rencontrer des crashs côté natif sous charge
Binaires natifs Déploiement complexe avec des binaires libwkhtmltox spécifiques à la plateforme
Limites de CSS Ancien fork QtWebKit — pas de support moderne Flexbox/Grid
JavaScript Exécution incohérente, délais d'attente
Rendu Moteur QtWebKit obsolète (wkhtmltopdf 0.12.6, dernière sortie en juin 2020)
Maintenance DinkToPdf 1.0.8 dernière version publiée le 18 avril 2017 sur NuGet

Comparaison des architectures

Aspect DinkToPdf IronPDF
Sécurité CVE-2022-35583 (SSRF), non corrigé / contesté en amont Aucun CVE critique connu
Moteur de rendu Ancien fork QtWebKit (wkhtmltopdf 0.12.6) Chrome moderne
Sécurité des threads SynchronizedConverter sérialise les appels ; native-side crashes reported under load Sécurité des threads dès la conception
Dépendances natives Binaires libwkhtmltox spécifiques à la plateforme Paquet NuGet géré
Support CSS Pas de Flexbox/Grillemoderne CSS3complet
JavaScript Limitée, incohérente Prise en charge
Maintenance Dernière sortie de DinkToPdfavril 2017 ; organisation wkhtmltopdf archivée en juillet 2024 Maintenance active

Comparaison des fonctionnalités

Fonction DinkToPdf IronPDF
HTML vers PDF ✅(moteur obsolète) ✅(Chrome)
URL vers PDF ✅ ✅
Marges personnalisées ✅ ✅
En-têtes/Pieds de page ✅(limité) ✅(HTML complet)
CSS3 ❌Limited ✅Complet
Flexbox/Grille ❌ ✅
JavaScript ⚠ Limité ✅Complet
Manipulation PDF ❌ ✅
Remplissage de formulaires ❌ ✅
Signatures numériques ❌ ✅
Chiffrement ❌ ✅
Filigranes ❌ ✅
Fusionner/Séparer ❌ ✅

Préparation de la migration

Prérequis

Assurez-vous que votre environnement répond à ces exigences :

  • .NET Framework 4.6.2+, .NET Core 3.1+, or .NET 5/6/7/8/9/10
  • Visual Studio 2019+ ou VS Code avec l'extension C#
  • Accès au Package Manager NuGet
  • Clé de licence IronPDF(essai gratuit disponible sur ironpdf.com)

Audit de l'utilisation de DinkToPdf

Exécutez ces commandes dans le répertoire de votre solution pour identifier toutes les références à DinkToPdf:

# Find all DinkToPdfusages in your codebase
grep -r "using DinkToPdf" --include="*.cs" .
grep -r "SynchronizedConverter\|HtmlToPdfDocument\|ObjectSettings" --include="*.cs" .

# Find NuGet package references
grep -r "DinkToPdf" --include="*.csproj" .

# Find wkhtmltopdf binaries
find . -name "libwkhtmltox*"
# Find all DinkToPdfusages in your codebase
grep -r "using DinkToPdf" --include="*.cs" .
grep -r "SynchronizedConverter\|HtmlToPdfDocument\|ObjectSettings" --include="*.cs" .

# Find NuGet package references
grep -r "DinkToPdf" --include="*.csproj" .

# Find wkhtmltopdf binaries
find . -name "libwkhtmltox*"
SHELL

Modifications importantes à prévoir

Changement DinkToPdf IronPDF Impact
Convertisseur SynchronizedConverter(new PdfTools()) ChromePdfRenderer Instanciation plus simple
Document HtmlToPdfDocument Appel de méthode direct Pas d'objet de document
Paramètres GlobalSettings + ObjectSettings RenderingOptions Objet à options uniques
Type de retour byte[] PdfDocument Un objet plus puissant
Binaire libwkhtmltox.dll/so Aucun (géré) Supprimer les fichiers natifs
Sécurité des threads BasicConverter monothread ; SynchronizedConverter sérialise Sécurité thread par défaut Un code plus simple
DI Singleton requis Toute la durée de vie Flexible

Processus de migration étape par étape

Étape 1 : Mise à jour des paquets NuGet

Supprimez DinkToPdfet installez IronPDF:

# Remove DinkToPdf
dotnet remove package DinkToPdf

# Install IronPDF
dotnet add package IronPdf
# Remove DinkToPdf
dotnet remove package DinkToPdf

# Install IronPDF
dotnet add package IronPdf
SHELL

Étape 2 : suppression des binaires natifs

Supprimez ces fichiers spécifiques à la plate-forme de votre projet :

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

IronPDF n'a pas de dépendances natives - tout est du code géré.

Étape 3 : mise à jour des références aux espaces de noms

Remplacer les espaces de noms DinkToPdfpar IronPDF:

// Remove these
using DinkToPdf;
using DinkToPdf.Contracts;

// Add this
using IronPdf;
// Remove these
using DinkToPdf;
using DinkToPdf.Contracts;

// Add this
using IronPdf;
Imports IronPdf
$vbLabelText   $csharpLabel

Étape 4 : configuration de la licence

// Add at application startup (Program.cs or Global.asax)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
// Add at application startup (Program.cs or Global.asax)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
' Add at application startup (Program.vb or Global.asax)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
$vbLabelText   $csharpLabel

Référence complète de migration des API

Mappage des classes de base

DinkToPdf IronPDF
SynchronizedConverter ChromePdfRenderer
BasicConverter ChromePdfRenderer
PdfTools Pas nécessaire
HtmlToPdfDocument Pas nécessaire
GlobalSettings RenderingOptions
ObjectSettings RenderingOptions
MarginSettings Propriétés des marges individuelles

Mappage des paramètres globaux

DinkToPdfGlobalSettings Équivalent d'IronPDF
ColorMode = ColorMode.Color Défaut (toujours en couleur)
Orientation = Orientation.Portrait PaperOrientation = PdfPaperOrientation.Portrait
Orientation = Orientation.Landscape PaperOrientation = PdfPaperOrientation.Landscape
PaperSize = PaperKind.A4 PaperSize = PdfPaperSize.A4
Margins = new MarginSettings() Propriétés des marges individuelles

Mappage des paramètres de marge

Marges de DinkToPdf Équivalent d'IronPDF
Margins.Top = 10 MarginTop = 10
Margins.Bottom = 10 MarginBottom = 10
Margins.Left = 15 MarginLeft = 15
Margins.Right = 15 MarginRight = 15

Exemples de migration de code

Les bases du HTML au PDF

La conversion fondamentale démontre la simplification spectaculaire de la configuration verbeuse de DinkToPdfà l'API rationalisée d'IronPDF.

Mise en œuvre de 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 = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>",
                    WebSettings = { DefaultEncoding = "utf-8" }
                }
            }
        };
        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 = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>",
                    WebSettings = { DefaultEncoding = "utf-8" }
                }
            }
        };
        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 ObjectSettings() With {
                    .HtmlContent = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>",
                    .WebSettings = New WebSettings() With {
                        .DefaultEncoding = "utf-8"
                    }
                }
            }
        }
        Dim pdf As Byte() = converter.Convert(doc)
        File.WriteAllBytes("output.pdf", pdf)
    End Sub
End Module
$vbLabelText   $csharpLabel

Mise en œuvre d'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

IronPDF réduit une configuration DinkToPdfde 20 lignes à 4 lignes. Pas de SynchronizedConverter, pas de PdfTools, pas de HtmlToPdfDocument, pas de ObjectSettings—juste rendre et enregistrer. Pour plus d'options, consultez la documentation HTML vers PDF.

Conversion d'URL en PDF

Mise en œuvre de 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

Mise en œuvre d'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

Le RenderUrlAsPdf d'IronPDF remplace la configuration imbriquée ObjectSettings.Page par un appel de méthode direct. Pour plus d'options, consultez l'URL vers la documentation PDF.

Paramètres personnalisés avec paysage et marges

Mise en œuvre de 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.A4,
                Margins = new MarginSettings { Top = 10, Bottom = 10, Left = 15, Right = 15 }
            },
            Objects = {
                new ObjectSettings() {
                    HtmlContent = "<h1>Custom PDF</h1><p>Landscape orientation with custom margins.</p>",
                    WebSettings = { DefaultEncoding = "utf-8" }
                }
            }
        };
        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("custom.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.A4,
                Margins = new MarginSettings { Top = 10, Bottom = 10, Left = 15, Right = 15 }
            },
            Objects = {
                new ObjectSettings() {
                    HtmlContent = "<h1>Custom PDF</h1><p>Landscape orientation with custom margins.</p>",
                    WebSettings = { DefaultEncoding = "utf-8" }
                }
            }
        };
        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("custom.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.A4,
                .Margins = New MarginSettings() With {
                    .Top = 10,
                    .Bottom = 10,
                    .Left = 15,
                    .Right = 15
                }
            },
            .Objects = {
                New ObjectSettings() With {
                    .HtmlContent = "<h1>Custom PDF</h1><p>Landscape orientation with custom margins.</p>",
                    .WebSettings = New WebSettings() With {
                        .DefaultEncoding = "utf-8"
                    }
                }
            }
        }
        Dim pdf As Byte() = converter.Convert(doc)
        File.WriteAllBytes("custom.pdf", pdf)
    End Sub
End Module
$vbLabelText   $csharpLabel

Mise en œuvre d'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 = 15;
        renderer.RenderingOptions.MarginRight = 15;

        var pdf = renderer.RenderHtmlAsPdf("<h1>Custom PDF</h1><p>Landscape orientation with custom margins.</p>");
        pdf.SaveAs("custom.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 = 15;
        renderer.RenderingOptions.MarginRight = 15;

        var pdf = renderer.RenderHtmlAsPdf("<h1>Custom PDF</h1><p>Landscape orientation with custom margins.</p>");
        pdf.SaveAs("custom.pdf");
    }
}
Imports IronPdf
Imports IronPdf.Rendering
Imports System

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape
        renderer.RenderingOptions.MarginTop = 10
        renderer.RenderingOptions.MarginBottom = 10
        renderer.RenderingOptions.MarginLeft = 15
        renderer.RenderingOptions.MarginRight = 15

        Dim pdf = renderer.RenderHtmlAsPdf("<h1>Custom PDF</h1><p>Landscape orientation with custom margins.</p>")
        pdf.SaveAs("custom.pdf")
    End Sub
End Module
$vbLabelText   $csharpLabel

Le RenderingOptions d'IronPDF remplace à la fois GlobalSettings et MarginSettings par une API unifiée et fluide. Pour plus d'options de configuration, voir la documentation des options de rendu.

Notes de migration essentielles

Supprimer les binaires natifs

L'étape de nettoyage la plus importante consiste à supprimer les binaires natifs de wkhtmltopdf.IronPDF n'a pas de dépendances natives :

# Delete native binaries
rm libwkhtmltox.* 2>/dev/null
# Delete native binaries
rm libwkhtmltox.* 2>/dev/null
SHELL

Aucun Singleton requis

Les conseils documentés de DinkToPdfsont d'enregistrer SynchronizedConverter comme un singleton. Le ChromePdfRenderer d'IronPDF est thread-safe avec tout cycle de vie DI :

// DinkToPdf- typically registered as singleton
services.AddSingleton(typeof(IConverter), new SynchronizedConverter(new PdfTools()));

//IronPDF- any lifetime works
services.AddScoped<ChromePdfRenderer>();
// Or just create inline:
var renderer = new ChromePdfRenderer();
// DinkToPdf- typically registered as singleton
services.AddSingleton(typeof(IConverter), new SynchronizedConverter(new PdfTools()));

//IronPDF- any lifetime works
services.AddScoped<ChromePdfRenderer>();
// Or just create inline:
var renderer = new ChromePdfRenderer();
$vbLabelText   $csharpLabel

Richer le type de retour

DinkToPdf retourne byte[].IronPDF retourne PdfDocument avec des capacités de manipulation :

// DinkToPdfreturns byte[]
byte[] pdf = converter.Convert(doc);
File.WriteAllBytes("output.pdf", pdf);
return File(pdf, "application/pdf");

//IronPDF returns PdfDocument
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
return File(pdf.BinaryData, "application/pdf");
// DinkToPdfreturns byte[]
byte[] pdf = converter.Convert(doc);
File.WriteAllBytes("output.pdf", pdf);
return File(pdf, "application/pdf");

//IronPDF returns PdfDocument
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
return File(pdf.BinaryData, "application/pdf");
' DinkToPdf returns Byte()
Dim pdf As Byte() = converter.Convert(doc)
File.WriteAllBytes("output.pdf", pdf)
Return File(pdf, "application/pdf")

' IronPDF returns PdfDocument
Dim pdfDocument = renderer.RenderHtmlAsPdf(html)
pdfDocument.SaveAs("output.pdf")
Return File(pdfDocument.BinaryData, "application/pdf")
$vbLabelText   $csharpLabel

Support CSS3complet

Les mises en page modernes qui échouent dans DinkToPdffonctionnent parfaitement dans IronPDF:

// DinkToPdf- doesn't work (wkhtmltopdf uses 2015 WebKit)
var html = "<div style='display: flex;'>...</div>";  // Broken!

//IronPDF- full support (modern Chromium)
var html = @"
    <div style='display: flex; justify-content: space-between;'>
        <div>Left</div>
        <div>Right</div>
    </div>";
var pdf = renderer.RenderHtmlAsPdf(html);  // Works!
// DinkToPdf- doesn't work (wkhtmltopdf uses 2015 WebKit)
var html = "<div style='display: flex;'>...</div>";  // Broken!

//IronPDF- full support (modern Chromium)
var html = @"
    <div style='display: flex; justify-content: space-between;'>
        <div>Left</div>
        <div>Right</div>
    </div>";
var pdf = renderer.RenderHtmlAsPdf(html);  // Works!
' DinkToPdf- doesn't work (wkhtmltopdf uses 2015 WebKit)
Dim html As String = "<div style='display: flex;'>...</div>"  ' Broken!

' IronPDF- full support (modern Chromium)
Dim html As String = "
    <div style='display: flex; justify-content: space-between;'>
        <div>Left</div>
        <div>Right</div>
    </div>"
Dim pdf = renderer.RenderHtmlAsPdf(html)  ' Works!
$vbLabelText   $csharpLabel

Liste de contrôle post-migration

Après avoir effectué la migration du code, vérifiez les points suivants :

  • Exécutez tous les tests unitaires pour vérifier que la génération de PDF fonctionne correctement.
  • Testez les scénarios multithreads (le chemin SynchronizedConverter sérialise les appels et était sujet à des crashs côté natif sous charge)
  • Comparer la qualité de sortie PDF (le rendu Chromium d'IronPDF est meilleur)
  • Vérifier le rendu CSS (Flexbox/Grid fonctionne désormais)
  • Test d'exécution JavaScript(fiable avec IronPDF)
  • Mettre à jour les pipelines CI/CD pour supprimer l'installation de wkhtmltopdf
  • Vérifier que l'analyse de sécurité est réussie (plus aucun signalement CVE-2022-35583)
  • Supprimer le déploiement binaire natif des scripts Docker/de déploiement

Ressources supplémentaires

La migration de DinkToPdfvers IronPDF retire la surface d'attaque non corrigée wkhtmltopdf (CVE-2022-35583), le modèle de concurrence sérialisé SynchronizedConverter, le déploiement de binaires natifs, et le chemin de rendu plus ancien QtWebKit. La transition vers un moteur moderne Chromium offre un support complet CSS3, une exécution JavaScriptfiable et une bibliothèque activement maintenue.

(

Veuillez noterDinkToPdf et wkhtmltopdf sont des marques déposées de leurs propriétaires respectifs. Ce site n'est pas affilié à, approuvé par, ou sponsorisé par DinkToPdfou wkhtmltopdf. 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