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
GUIDES DE MIGRATION

Comment migrer de DinkToPdf vers IronPDF en C#

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 des vulnérabilités de sécurité critiques non corrigées de wkhtmltopdf :

  1. CVE-2022-35583 (SSRF) : Falsification de requête côté serveur permettant aux attaquants d'accéder aux ressources du réseau interne.
  2. Projet abandonné : wkhtmltopdf n'est plus maintenu depuis 2020.
  3. Absence de correctifs de sécurité : les vulnérabilités connues ne seront jamais corrigées.

Problèmes techniques

Problème Impact
Sécurité des threads SynchronizedConverter se plante toujours en production sous une charge concurrente
Binaires natifs Déploiement complexe avec des binaires libwkhtmltox spécifiques à la plateforme
Limites de CSS Pas de prise en charge de Flexbox, Grid ou CSS moderne
JavaScript Exécution incohérente, délais d'attente
Rendu Moteur WebKit obsolète (circa 2015)
Maintenance Dernière mise à jour : 2018

Comparaison des architectures

Aspect DinkToPdf IronPDF
Sécurité CVE-2022-35583 (SSRF), non corrigé Aucune vulnérabilité connue
Moteur de rendu WebKit dépassé (2015) Chrome moderne
Sécurité des threads Crashes en cas d'utilisation simultanée Entièrement sécurisé
Dépendances natives Binaires spécifiques à une plateforme Paquet NuGet pur
Support CSS Pas de Flexbox/Grid CSS3complet
JavaScript Limitée, incohérente Prise en charge
Maintenance Abandonné (2018) 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 ⚠️ Limited ✅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+ ou .NET Core 3.1 / .NET 5-9
  • Visual Studio 2019+ ou VS Code avec l'extension C#
  • Accès au Package Manager NuGet
  • Clé de licenceIronPDF(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 SynchronizedConverter requis 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 installezIronPDF:

# 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 DinkToPdfparIronPDF:

// 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—il suffit de générer et d'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

IronPDF's RenderUrlAsPdf 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

IronPDF's RenderingOptions 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.IronPDFn'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

Le fichier SynchronizedConverter de DinkToPdfa dû être enregistré comme singleton pour éviter les plantages. IronPDF's ChromePdfRenderer is thread-safe with any DI lifetime:

// DinkToPdf- MUST be 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- MUST be 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- MUST be singleton
services.AddSingleton(GetType(IConverter), New SynchronizedConverter(New PdfTools()))

' IronPDF- any lifetime works
services.AddScoped(Of ChromePdfRenderer)()
' Or just create inline:
Dim renderer As New ChromePdfRenderer()
$vbLabelText   $csharpLabel

Richer le type de retour

DinkToPdf renvoie byte[].IronPDFrenvoie PdfDocument avec des capacités de manipulation :

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

//IronPDFreturns 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");

//IronPDFreturns 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 dansIronPDF:

// 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.
  • Test des scénarios multithread (ceux-ci ont planté avec DinkToPdf)
  • 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

Protéger l'avenir de votre infrastructure PDF

Avec .NET 10 à l'horizon et C# 14 qui introduit de nouvelles fonctionnalités de langage, le choix d'une bibliothèque PDF activement maintenue garantit une compatibilité à long terme. Le moteur moderne Chromium d'IronPDF reçoit des mises à jour régulières, tandis que le wkhtmltopdf abandonné de DinkToPdfreste figé aux capacités de 2015 - un écart croissant qui ne fera que se creuser au fur et à mesure de l'évolution des standards du web jusqu'en 2025 et 2026.

Ressources supplémentaires

La migration de DinkToPdfversIronPDFélimine les vulnérabilités de sécurité critiques (CVE-2022-35583), les plantages liés à la sécurité des threads, la complexité du déploiement des binaires natifs et le rendu CSS obsolète. La transition vers un moteur Chromium moderne offre une prise en charge complète de CSS3, une exécution fiable de JavaScriptet la tranquillité d'esprit que procure une bibliothèque activement maintenue.

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