Iron Suite for .NET

10 bibliothèques .NET. Une suite de documents complète.

Découvrez Iron Suite

IRONPDF

IRONWORD

IRONXL

IRONPPT

IRONOCR

IRONBARCODE

IRONQR

IRONPRINT

IRONZIP

IRONWEBSCRAPER

COMPARAISON

CraftMyPDF vs IronPDF : Guide de comparaison technique

Curtis Chau

Updated: 28 juin 2026

Lorsque les développeurs .NET examinent les options de génération de PDF, Haukcode.DinkToPdf se distingue comme une continuation du projet DinkToPdf, qui a été abandonné et qui utilise le binaire wkhtmltopdf. Bien que Haukcode.DinkToPdf offre une conversion HTML-PDF de base, il comporte des risques de sécurité importants provenant de wkhtmltopdf qui ne seront jamais corrigés en raison de l'abandon du projet.IronPDF présente une option différente : une bibliothèque activement entretenue utilisant un moteur Chromium moderne avec des mises à jour de sécurité régulières.

Cette comparaison passe en revue les deux bibliothèques sur des aspects techniques pertinents afin d'aider les développeurs et les architectes à faire des choix éclairés pour leurs besoins en matière de PDF .NET.

Explorer Haukcode.DinkToPdf

Haukcode.DinkToPdf est une continuation de la bibliothèque DinkToPdf, construite sur le binaire wkhtmltopdf, aujourd'hui disparu. La bibliothèque vise à rester compatible avec .NET Core tout en offrant une conversion HTML vers PDF. En tant que continuation d'un projet abandonné, Haukcode.DinkToPdf a des limitations notables.

Haukcode.DinkToPdf utilise SynchronizedConverter avec PdfTools pour la conversion. La configuration est gérée à l'aide d'objets HtmlToPdfDocument contenant GlobalSettings pour les options de page (ColorMode, Orientation, PaperSize, Margins) et ObjectSettings pour le contenu (HtmlContent pour les chaînes HTML, Page pour les URL). La méthode converter.Convert(doc) retourne les données brutes byte[].

La bibliothèque nécessite des binaires natifs spécifiques à la plateforme : libwkhtmltox.dll (Windows), libwkhtmltox.so (Linux), et libwkhtmltox.dylib (macOS). La sécurité des threads nécessite l'utilisation de SynchronizedConverter dans un modèle singleton en raison des limitations de wkhtmltopdf.

Explorer IronPDF

IronPDF est une bibliothèque .NET développée indépendamment qui utilise un moteur de rendu moderne Chromium. La bibliothèque est activement maintenue avec des mises à jour régulières, un support professionnel et des correctifs de sécurité continus.

IronPDF utilise ChromePdfRenderer comme sa classe de rendu principale avec configuration via des propriétés RenderingOptions. Des méthodes comme RenderHtmlAsPdf() et RenderUrlAsPdf() retournent des objets PdfDocument qui peuvent être sauvegardés avec SaveAs() ou accessibles comme BinaryData. La bibliothèque est autonome et ne nécessite pas de binaires natifs externes. Elle est conçue pour être à l'abri des threads et ne nécessite pas de modèles de singleton.

La considération critique en matière de sécurité

La différence la plus importante entre ces bibliothèques concerne la sécurité. Haukcode.DinkToPdf hérite de CVE-2022-35583, une vulnérabilité critique de type SSRF (Server-Side Request Forgery) avec un score CVSS de 9,8.

CVE-2022-35583 Vecteurs d'attaque:

Un contenu HTML malveillant peut amener le serveur à rechercher des ressources internes
Les attaques de métadonnées AWS peuvent accéder à http://169.254.169.254 pour voler des identifiants
Analyse du réseau interne et accès aux services internes
Inclusion de fichiers locaux via le protocole file://
Potentiel de prise en charge complète de l'infrastructure

Il n'y a pas de correctif pour cette vulnérabilité car wkhtmltopdf est abandonné (archivé depuis janvier 2023, la dernière version étant la 0.12.6 en 2020).

Aspectsécurité	Haukcode.DinkToPdf	IronPDF
CVEs critiques	CVE-2022-35583 (CVSS 9.8, non corrigeable)	Activement patché
Moteur sous-jacent	wkhtmltopdf (Qt WebKit ~2015)	Chromium (régulièrement mis à jour)
Statut du projet	Fork d'un projet abandonné	Développé activement
Mises à jour de sécurité	Aucune attente	Publications régulières
Support	Communauté uniquement	Support professionnel

Architecture et comparaison des moteurs

Les différences architecturales fondamentales affectent la qualité du rendu, la prise en charge des normes web modernes et la complexité du déploiement.

Aspect	Haukcode.DinkToPdf	IronPDF
Moteur de rendu	Qt WebKit (~2015)	Chromium (actuel)
HTML5/CSS3	Limité	Prise en charge
JavaScript	Limité, peu sûr	Moteur V8 complet
Binaires natifs	Exigences (spécifiques à la plate-forme)	Autonome
Sécurité des threads	Requiert le modèle singleton	Sécurité des threads dès la conception
Mises à jour	Aucune attente	Publications régulières

La dépendance de Haukcode.DinkToPdf à l'égard du moteur Qt WebKit obsolète signifie qu'il manque des années de correctifs de sécurité et que la prise en charge des normes web modernes est limitée. Le moteur Chromium d'IronPDF offre une prise en charge des normes web actuelles avec des mises à jour régulières.

Code Comparaison : Opérations PDF courantes

Conversion HTML en PDF

L'opération la plus fondamentale démontre les différences de conception des API.

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);
    }
}

' NuGet: Install-Package DinkToPdf
Imports DinkToPdf
Imports DinkToPdf.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() {
                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 Class

' NuGet: Install-Package DinkToPdf
Imports DinkToPdf
Imports DinkToPdf.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() {
                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 Class

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");
    }
}

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports System.IO

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()

        Dim pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1></body></html>")

        pdf.SaveAs("output.pdf")
    End Sub
End Module

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports System.IO

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()

        Dim pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1></body></html>")

        pdf.SaveAs("output.pdf")
    End Sub
End Module

Haukcode.DinkToPdf nécessite la création d'un SynchronizedConverter avec PdfTools, la construction d'un HtmlToPdfDocument avec des objets imbriqués GlobalSettings et ObjectSettings, l'appel de Convert() pour obtenir les octets bruts, puis l'écriture manuelle sur le disque avec File.WriteAllBytes().

IronPDF crée un ChromePdfRenderer, appelle RenderHtmlAsPdf() avec la chaîne HTML directement, et sauvegarde avec SaveAs(). L'opération est nettement plus concise grâce à une conception moderne de l'API.

Pour des options de rendu HTML avancées, explorez le guide de conversion du HTML en PDF.

Conversion d'URL en PDF

La conversion de pages web montre les différentes approches du traitement du contenu externe.

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);
    }
}

' NuGet: Install-Package DinkToPdf
Imports DinkToPdf
Imports DinkToPdf.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 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

' NuGet: Install-Package DinkToPdf
Imports DinkToPdf
Imports DinkToPdf.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 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

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");
    }
}

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports System

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()

        Dim pdf = renderer.RenderUrlAsPdf("https://www.example.com")

        pdf.SaveAs("webpage.pdf")
    End Sub
End Module

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports System

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()

        Dim pdf = renderer.RenderUrlAsPdf("https://www.example.com")

        pdf.SaveAs("webpage.pdf")
    End Sub
End Module

Haukcode.DinkToPdf utilise la même structure HtmlToPdfDocument avec la propriété ObjectSettings.Page pour la spécification d'URL.IronPDF fournit une méthode dédiée RenderUrlAsPdf() qui accepte l'URL directement, une API plus claire pour ce cas d'utilisation spécifique.

Notez que le rendu d'URL avec Haukcode.DinkToPdf comporte le risque de vulnérabilité CVE-2022-35583 SSRF, car des URL ou des redirections malveillantes pourraient exploiter le serveur.

Paramètres de page personnalisés

La configuration de la page présente les différents modèles de configuration.

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);
    }
}

' NuGet: Install-Package DinkToPdf
Imports DinkToPdf
Imports DinkToPdf.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.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

' NuGet: Install-Package DinkToPdf
Imports DinkToPdf
Imports DinkToPdf.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.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

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");
    }
}

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports IronPdf.Rendering

Module Program
    Sub Main()
        Dim renderer As 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 Module

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports IronPdf.Rendering

Module Program
    Sub Main()
        Dim renderer As 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 Module

Haukcode.DinkToPdf configure les paramètres de la page via GlobalSettings avec des objets imbriqués MarginSettings. Les propriétés utilisent des enums comme Orientation.Landscape et PaperKind.Letter.

IronPDF utilise les propriétés RenderingOptions directement sur le rendu. Les propriétés sont définies individuellement (PaperSize, PaperOrientation, MarginTop, etc.) avec des enums typés (PdfPaperSize.Letter, PdfPaperOrientation.Landscape). Les deux langues utilisent le millimètre comme unité de mesure.

Pour en savoir plus sur la configuration du rendu, consultez les tutoriels IronPDF.

Référence de mappage d'API

Pour les développeurs qui évaluent la migration Haukcode.DinkToPdf ou qui comparent les capacités, ce mappage montre les opérations équivalentes :

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 pour `RenderHtmlAsPdf()`
`Page` (URL)	`renderer.RenderUrlAsPdf(url)`
`HeaderSettings.Right = "[page]"`	`TextHeader.RightText = "{page}"`

Différences de syntaxe des espaces réservés

Les espaces réservés de l'en-tête et du pied de page utilisent une syntaxe différente selon les bibliothèques :

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

Sécurité des threads et injection de dépendance

Haukcode.DinkToPdf nécessite une manipulation prudente en raison des limitations de sécurité des threads héritées de wkhtmltopdf.

Haukcode.DinkToPdf (Singleton requis):

// Startup.cs - MUST be singleton due to thread safety issues
public void ConfigureServices(IServiceCollection services)
{
    services.AddSingleton(typeof(IConverter), new SynchronizedConverter(new PdfTools()));
}

// Startup.cs - MUST be singleton due to thread safety issues
public void ConfigureServices(IServiceCollection services)
{
    services.AddSingleton(typeof(IConverter), new SynchronizedConverter(new PdfTools()));
}

' Startup.vb - MUST be singleton due to thread safety issues
Public Sub ConfigureServices(services As IServiceCollection)
    services.AddSingleton(GetType(IConverter), New SynchronizedConverter(New PdfTools()))
End Sub

' Startup.vb - MUST be singleton due to thread safety issues
Public Sub ConfigureServices(services As IServiceCollection)
    services.AddSingleton(GetType(IConverter), New SynchronizedConverter(New PdfTools()))
End Sub

IronPDF (Flexible) :

// Startup.cs - Can be singleton or transient (both work)
public void ConfigureServices(IServiceCollection services)
{
    IronPdf.License.LicenseKey = Configuration["IronPdf:LicenseKey"];
    services.AddSingleton<IPdfService, IronPdfService>();
    // Or services.AddTransient<IPdfService, IronPdfService>() - both are safe!
}

// Startup.cs - Can be singleton or transient (both work)
public void ConfigureServices(IServiceCollection services)
{
    IronPdf.License.LicenseKey = Configuration["IronPdf:LicenseKey"];
    services.AddSingleton<IPdfService, IronPdfService>();
    // Or services.AddTransient<IPdfService, IronPdfService>() - both are safe!
}

Imports Microsoft.Extensions.DependencyInjection

Public Sub ConfigureServices(services As IServiceCollection)
    IronPdf.License.LicenseKey = Configuration("IronPdf:LicenseKey")
    services.AddSingleton(Of IPdfService, IronPdfService)()
    ' Or services.AddTransient(Of IPdfService, IronPdfService) - both are safe!
End Sub

Imports Microsoft.Extensions.DependencyInjection

Public Sub ConfigureServices(services As IServiceCollection)
    IronPdf.License.LicenseKey = Configuration("IronPdf:LicenseKey")
    services.AddSingleton(Of IPdfService, IronPdfService)()
    ' Or services.AddTransient(Of IPdfService, IronPdfService) - both are safe!
End Sub

IronPDF est thread-safe par conception, permettant des modèles d'injection de dépendance flexibles sans l'exigence de singleton.

Résumé de la comparaison des fonctionnalités

Fonction	Haukcode.DinkToPdf	IronPDF
Origine de la source	Fork d'un projet abandonné	Développement indépendant
Sécurité	CVEs hérités de l'amont (non corrigeables)	Des correctifs proactifs et sécurisés
Communauté et assistance	Petit et sporadique	Une équipe nombreuse, active et dévouée
Caractéristiques et mises à jour	Limité et sporadique	Régulier avec un développement actif
Support multithreading	Requiert le modèle singleton	Entièrement pris en charge et optimisé
Binaires natifs	Exigences (spécifiques à la plate-forme)	Autonome
HTML5/CSS3	Limité	Prise en charge
JavaScript	Limité	Moteur V8 complet
Licence	MIT (gratuit)	Commercial avec essai gratuit

Quand les équipes envisagent de passer de Haukcode.DinkToPdf à IronPDF

Les équipes de développement évaluent la transition de Haukcode.DinkToPdf vers IronPDF pour plusieurs raisons :

Vulnérabilités de sécurité critiques: CVE-2022-35583 (SSRF) est une vulnérabilité critique avec CVSS 9.8 qui ne sera jamais corrigée. Pour les applications traitant du HTML fourni par l'utilisateur ou rendant des URL externes, cette vulnérabilité permet le vol d'identifiants AWS, l'accès au réseau interne et des attaques par inclusion de fichiers locaux.

Technologie sous-jacente abandonnée: wkhtmltopdf est abandonné (archivé en janvier 2023, dernière version 2020). Haukcode.DinkToPdf en tant que suite ne peut pas aborder les questions fondamentales de la technologie sous-jacente. Le moteur Qt WebKit (~2015), obsolète, ne bénéficie pas de correctifs de sécurité depuis des années.

Gestion des binaires natifs : Haukcode.DinkToPdf nécessite la distribution de binaires spécifiques à la plateforme (libwkhtmltox.dll, libwkhtmltox.so, libwkhtmltox.dylib). Cela complique le déploiement, les pipelines CI/CD et la conteneurisation.IronPDF est autonome et ne contient pas de binaires externes.

Limitations de la sécurité des threads : Le modèle singleton requis SynchronizedConverter limite la flexibilité architecturale et peut créer des goulets d'étranglement sous charge.IronPDF est de par sa conception à l'épreuve des threads, ce qui permet des instances par demande.

Normes Web modernes: La prise en charge limitée de HTML5/CSS3 et l'exécution non sécurisée de JavaScript limitent les capacités de rendu du contenu Web moderne. Le moteur Chromium d'IronPDF assure la prise en charge des normes web actuelles.

Viabilité à long terme : La dépendance à l'égard d'une technologie abandonnée crée une dette technique qui s'alourdit avec le temps. À mesure que les projets évoluent vers .NET 10 et C# 14 jusqu'en 2026, le maintien de la dépendance à l'égard des wrappers wkhtmltopdf non maintenus devient de plus en plus problématique.

Forces et considérations

Haukcode.DinkToPdf Points forts

Gratuit et Open Source: Licence MIT sans frais de licence
Fonctionnalité de base: Prise en charge de la conversion fondamentale de HTML en PDF
Base de code existante : Familière aux équipes qui utilisent déjà DinkToPdf

Considérations de Haukcode.DinkToPdf

Vulnérabilités de sécurité critiques: CVE-2022-35583 n'est pas corrigeable
Technologie abandonnée: Construit sur une technologie abandonnée wkhtmltopdf
Dépendance binaire native: DLL spécifiques à la plateforme requises
Questions de sécurité des threads: Modèle Singleton requis
Normes Web limitées: Moteur Qt WebKit dépassé
Aucune assistance professionnelle: Assistance communautaire uniquement
Dette technique: La dépendance à l'égard d'un projet abandonné augmente les risques

Les points forts d'IronPDF

Active Security Patching: Des mises à jour régulières corrigent les vulnérabilités
Modern Chromium Engine: Les normes web actuelles prennent en charge
Autonome: Pas de dépendances binaires natives
Conception sécurisée: Modèles de déploiement flexibles
HTML5/CSS3/JavaScript : Capacités de rendu modernes
Support professionnel : Support technique dédié
Ressources complètes : Des tutoriels et documentation très complets

Considérations relatives à IronPDF

Licence commerciale: Requise pour une utilisation en production

Conclusion

Haukcode.DinkToPdf et IronPDF représentent des approches fondamentalement différentes de la génération de PDF dans les applications .NET. Haukcode.DinkToPdf, en tant que continuation du projet abandonné DinkToPdf enveloppant le binaire abandonné wkhtmltopdf, comporte des vulnérabilités de sécurité critiques (CVE-2022-35583) qui ne seront jamais corrigées. La bibliothèque nécessite une distribution binaire native, des modèles singleton pour la sécurité des threads, et offre une prise en charge limitée des normes web modernes.

IronPDF constitue une alternative activement maintenue avec un moteur Chromium moderne, des mises à jour de sécurité régulières et une architecture thread-safe. La bibliothèque autonome élimine la gestion des binaires natifs tout en offrant un support HTML5/CSS3/JavaScript complet.

Alors que les organisations planifient pour .NET 10, C# 14 et le développement d'applications jusqu'en 2026, le choix entre le maintien de la dépendance à une technologie abandonnée avec des vulnérabilités critiques non corrigibles et l'adoption d'une solution activement maintenue avec des capacités modernes a un impact significatif à la fois sur la posture de sécurité et la vitesse de développement. Les équipes qui ont besoin d'une génération sécurisée de PDF, d'un rendu moderne ou d'un déploiement simplifié trouveront qu'IronPDF répond efficacement à ces exigences.

Commencez à évaluer IronPDF avec un essai gratuit et explorez la documentation complète pour évaluer l'adéquation à vos besoins spécifiques.

(

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