COMPARAISON

NReco.PdfGenerator vs IronPDF : Guide de comparaison technique

Publié:

Présentation de NReco.PdfGenerator

NReco.PdfGenerator est une bibliothèque C# qui convertit les documents HTML en PDF en utilisant l'outil en ligne de commande wkhtmltopdf. Elle offre une API simple via sa classe HtmlToPdfConverter , qui fait appel à wkhtmltopdf pour le rendu.

L'outil wkhtmltopdf utilise WebKit Qt comme moteur de rendu, une version datant d'environ 2012. Bien qu'il soit largement utilisé, le développement de wkhtmltopdf a cessé en 2020, le laissant sans mises à jour de sécurité ni nouvelles fonctionnalités. Cela pose des défis aux équipes qui développent des applications modernes répondant aux exigences actuelles en matière de CSS et de JavaScript.

La version gratuite de NReco.PdfGenerator inclut des filigranes sur les PDF générés, ce qui nécessite une licence commerciale pour une utilisation en production. Pour obtenir le prix de ces licences, il faut contacter le service commercial, ce qui peut compliquer les processus d'approvisionnement.

Introduction à IronPDF

IronPDF est une bibliothèque .NET qui utilise un moteur de rendu moderne basé sur Chromium pour convertir HTML, CSS et JavaScript en documents PDF. La classe ChromePdfRenderer sert d'interface principale pour la conversion HTML vers PDF, offrant de nombreuses options de configuration via la propriété RenderingOptions .

Contrairement aux wrappers wkhtmltopdf, le moteur de rendu d'IronPDF reçoit des mises à jour régulières pour la sécurité et la compatibilité. La bibliothèque est autonome, ce qui élimine la nécessité de gérer des dépendances binaires externes sur différentes plateformes.

IronPDF offre une période d'essai avec toutes les fonctionnalités (sans filigrane), permettant aux équipes d'évaluer les capacités avant l'achat. Les licences commerciales utilisent des prix publiés et transparents.

Comparaison des moteurs de rendu

La principale différence entre ces bibliothèques réside dans leurs moteurs de rendu, ce qui a un impact sur la sécurité et la compatibilité CSS.

Aspect NReco.PdfGenerator IronPDF
Moteur de rendu WebKit Qt (2012) Chromium (actuel)
Sécurité 20+ CVEs, abandonnés Mises à jour de sécurité actives
Support CSS CSS2.1, CSS3 limité CSS3 complet, grille, Flexbox
JavaScript ES5 de base ES6+ complet
Dépendances Binaire externe wkhtmltopdf Autonome
Support asynchrone Synchrone uniquement Async/await complet
Fontes Web Limité Polices Google complètes, @font-face
Essai gratuit En filigrane Fonctionnalité complète
Transparence des prix Opaque, contacter le service commercial Prix publiés

NReco.PdfGenerator hérite de toutes les vulnérabilités de sécurité de wkhtmltopdf, y compris les CVE documentées pour la falsification des requêtes côté serveur, les vulnérabilités de lecture de fichier local et l'exécution potentielle de code à distance. Wkhtmltopdf étant abandonné depuis 2020, aucun correctif n'est disponible pour ces problèmes.

Le moteur Chromium d'IronPDF assure la prise en charge des normes web actuelles, permettant l'utilisation de fonctionnalités CSS modernes telles que les mises en page Grid et Flexbox, les variables CSS et les propriétés personnalisées. L'exécution JavaScript prend en charge la syntaxe ES6+, y compris les modèles async/await.

Conversion basique de HTML en PDF

Les deux bibliothèques gèrent la conversion de base de HTML en PDF, bien qu'avec des modèles d'API différents.

L'approche deNReco.PdfGenerator:

// NuGet: Install-Package NReco.PdfGenerator
using NReco.PdfGenerator;
using System.IO;

class Program
{
    static void Main()
    {
        var htmlToPdf = new HtmlToPdfConverter();
        var htmlContent = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";
        var pdfBytes = htmlToPdf.GeneratePdf(htmlContent);
        File.WriteAllBytes("output.pdf", pdfBytes);
    }
}
// NuGet: Install-Package NReco.PdfGenerator
using NReco.PdfGenerator;
using System.IO;

class Program
{
    static void Main()
    {
        var htmlToPdf = new HtmlToPdfConverter();
        var htmlContent = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";
        var pdfBytes = htmlToPdf.GeneratePdf(htmlContent);
        File.WriteAllBytes("output.pdf", pdfBytes);
    }
}
$vbLabelText   $csharpLabel

L'approche d'IronPDF :

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var htmlContent = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System.IO;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var htmlContent = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("output.pdf");
    }
}
$vbLabelText   $csharpLabel

Les deux bibliothèques nécessitent un minimum de code pour les conversions de base. NReco.PdfGenerator renvoie un tableau byte[] nécessitant des opérations manuelles sur les fichiers, tandis qu'IronPDF renvoie un objet PdfDocument avec des méthodes pratiques comme SaveAs(). L'objetIronPDFpermet également d'accéder à BinaryData pour l'accès aux tableaux d'octets et à Stream pour les opérations basées sur les flux.

Pour les développeurs familiarisés avec le flux de travail conversion de HTML en PDF, l'API d'IronPDF semblera intuitive tout en offrant des capacités supplémentaires au-delà de la conversion de base.

Conversion d'URL en PDF

La conversion de pages web en documents PDF révèle les différences d'API dans la dénomination et la sémantique des méthodes.

Conversion d'URL NReco.PdfGenerator :

// NuGet: Install-Package NReco.PdfGenerator
using NReco.PdfGenerator;
using System.IO;

class Program
{
    static void Main()
    {
        var htmlToPdf = new HtmlToPdfConverter();
        var pdfBytes = htmlToPdf.GeneratePdfFromFile("https://www.example.com", null);
        File.WriteAllBytes("webpage.pdf", pdfBytes);
    }
}
// NuGet: Install-Package NReco.PdfGenerator
using NReco.PdfGenerator;
using System.IO;

class Program
{
    static void Main()
    {
        var htmlToPdf = new HtmlToPdfConverter();
        var pdfBytes = htmlToPdf.GeneratePdfFromFile("https://www.example.com", null);
        File.WriteAllBytes("webpage.pdf", pdfBytes);
    }
}
$vbLabelText   $csharpLabel

Conversion d'URL IronPDF:

// NuGet: Install-Package IronPdf
using IronPdf;

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;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
        pdf.SaveAs("webpage.pdf");
    }
}
$vbLabelText   $csharpLabel

NReco.PdfGenerator utilise GeneratePdfFromFile() pour les chemins d'accès aux fichiers et les URL, ce qui peut prêter à confusion sur le plan sémantique.IronPDFfournit une méthode RenderUrlAsPdf dédiée qui indique clairement l'opération effectuée.

Personnalisation de la taille des pages et des marges

Les documents professionnels exigent souvent des dimensions de page et des configurations de marge spécifiques. Les deux bibliothèques prennent en charge ces personnalisations avec différents modèles de configuration.

Configuration de la pageNReco.PdfGenerator:

// NuGet: Install-Package NReco.PdfGenerator
using NReco.PdfGenerator;
using System.IO;

class Program
{
    static void Main()
    {
        var htmlToPdf = new HtmlToPdfConverter();
        htmlToPdf.PageWidth = 210;
        htmlToPdf.PageHeight = 297;
        htmlToPdf.Margins = new PageMargins { Top = 10, Bottom = 10, Left = 10, Right = 10 };
        var htmlContent = "<html><body><h1>Custom Page Size</h1><p>A4 size document with margins.</p></body></html>";
        var pdfBytes = htmlToPdf.GeneratePdf(htmlContent);
        File.WriteAllBytes("custom-size.pdf", pdfBytes);
    }
}
// NuGet: Install-Package NReco.PdfGenerator
using NReco.PdfGenerator;
using System.IO;

class Program
{
    static void Main()
    {
        var htmlToPdf = new HtmlToPdfConverter();
        htmlToPdf.PageWidth = 210;
        htmlToPdf.PageHeight = 297;
        htmlToPdf.Margins = new PageMargins { Top = 10, Bottom = 10, Left = 10, Right = 10 };
        var htmlContent = "<html><body><h1>Custom Page Size</h1><p>A4 size document with margins.</p></body></html>";
        var pdfBytes = htmlToPdf.GeneratePdf(htmlContent);
        File.WriteAllBytes("custom-size.pdf", pdfBytes);
    }
}
$vbLabelText   $csharpLabel

Configuration des pages IronPDF:

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.MarginTop = 10;
        renderer.RenderingOptions.MarginBottom = 10;
        renderer.RenderingOptions.MarginLeft = 10;
        renderer.RenderingOptions.MarginRight = 10;
        var htmlContent = "<html><body><h1>Custom Page Size</h1><p>A4 size document with margins.</p></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("custom-size.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.MarginTop = 10;
        renderer.RenderingOptions.MarginBottom = 10;
        renderer.RenderingOptions.MarginLeft = 10;
        renderer.RenderingOptions.MarginRight = 10;
        var htmlContent = "<html><body><h1>Custom Page Size</h1><p>A4 size document with margins.</p></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("custom-size.pdf");
    }
}
$vbLabelText   $csharpLabel

NReco.PdfGenerator nécessite de spécifier les dimensions de la page en millimètres (210×297 pour A4) et utilise un objet PageMargins.IronPDFutilise l'enum PdfPaperSize pour les tailles standard et fournit des propriétés de marge individuelles via RenderingOptions. La classe RenderingOptions centralise toute la configuration de la page, rendant les paramètres accessibles par le biais de l'autocomplétion de l'IDE.

Référence de mappage API

Pour les équipes qui envisagent la migration de NReco.PdfGenerator vers IronPDF, la compréhension des mappages d'API permet d'estimer l'effort et de planifier la transition.

Correspondances des méthodes principales

NReco.PdfGenerator IronPDF
new HtmlToPdfConverter() new ChromePdfRenderer()
GénérerPdf(html) RenderHtmlAsPdf(html)
GeneratePdfFromFile(url, output) RenderUrlAsPdf(url)
GeneratePdfFromFile(path, output) RenderHtmlFileAsPdf(path)
(non pris en charge)(non pris en charge)(non pris en charge)(non pris en charge) RenderHtmlAsPdfAsync(html)

Mappages des propriétés de configuration

NReco.PdfGenerator IronPDF
Orientation = PageOrientation.Landscape RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape
Taille = PageSize.A4 RenderingOptions.PaperSize = PdfPaperSize.A4
Margins.Top = 10 RenderingOptions.MarginTop = 10
Zoom = 0.9f RenderingOptions.Zoom = 90
PageHeaderHtml = "..." RenderingOptions.HtmlHeader
PageFooterHtml = "..." RenderingOptions.HtmlFooter

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

Les en-têtes et les pieds de page comprennent souvent un contenu dynamique comme les numéros de page. La syntaxe des espaces réservés diffère d'une bibliothèque à l'autre :

NReco.PdfGenerator IronPDF Objectif
[page] {page} Numéro de page actuel
[topage] {total-pages} Nombre total de pages
[date] {date} Date actuelle
[time] {heure} Heure actuelle
[titre] {html-title} Titre du document
[page web] {url} URL de la source

Les équipes qui migrent depuis NReco.PdfGenerator doivent mettre à jour tous les modèles d'en-tête et de pied de page avec la nouvelle syntaxe des espaces réservés.

Conversion de la valeur du zoom

NReco.PdfGenerator utilise des valeurs flottantes (0,0-2,0) pour le zoom, tandis qu'IronPDF utilise des valeurs en pourcentage :

// NReco: Zoom = 0.75f means 75%
// IronPDF: Zoom = 75 means 75%
int ironPdfZoom = (int)(nrecoZoom * 100);
// NReco: Zoom = 0.75f means 75%
// IronPDF: Zoom = 75 means 75%
int ironPdfZoom = (int)(nrecoZoom * 100);
$vbLabelText   $csharpLabel

Comparaison de la prise en charge asynchrone

Les applications web modernes bénéficient d'opérations asynchrones qui ne bloquent pas les threads. Cela est particulièrement important dans les applications ASP .NET Core qui gèrent des requêtes simultanées.

NReco.PdfGenerator fournit des opérations synchrones uniquement, ce qui peut bloquer les threads du serveur web pendant la génération du PDF :

// NReco.PdfGenerator - synchronous only
var pdfBytes = converter.GeneratePdf(html);  // Blocks thread
// NReco.PdfGenerator - synchronous only
var pdfBytes = converter.GeneratePdf(html);  // Blocks thread
$vbLabelText   $csharpLabel

IronPDF prend en charge l'intégralité des modèles async/await :

//IronPDF- async support
var pdf = await renderer.RenderHtmlAsPdfAsync(html);  // Non-blocking
await pdf.SaveAsAsync("output.pdf");
//IronPDF- async support
var pdf = await renderer.RenderHtmlAsPdfAsync(html);  // Non-blocking
await pdf.SaveAsAsync("output.pdf");
$vbLabelText   $csharpLabel

Pour les applications générant des PDF en réponse à des requêtes HTTP, la prise en charge asynchrone d'IronPDF améliore l'évolutivité en libérant des threads pendant le processus de rendu.

Différences de dépendance et de déploiement

NReco.PdfGenerator nécessite que le binaire wkhtmltopdf soit disponible sur le système. Cela pose des problèmes de déploiement :

  • Les binaires spécifiques à la plate-forme doivent être gérés (Windows .exe, Linux .so, macOS .dylib)
  • Les images Docker nécessitent l'installation de wkhtmltopdf
  • Les pipelines CI/CD ont besoin d'étapes de provisionnement binaires
  • Les scanners de sécurité signalent les CVE connus

IronPDF est autonome en tant que package NuGet :

#IronPDFinstallation - complete
dotnet add package IronPdf

# NReco.PdfGenerator installation - plus binary management
dotnet add package NReco.PdfGenerator
# Plus: install wkhtmltopdf per platform
#IronPDFinstallation - complete
dotnet add package IronPdf

# NReco.PdfGenerator installation - plus binary management
dotnet add package NReco.PdfGenerator
# Plus: install wkhtmltopdf per platform
SHELL

Les équipes qui migrent depuis NReco.PdfGenerator peuvent supprimer les binaires wkhtmltopdf et simplifier leur processus de déploiement.

Quand les équipes envisagent de passer de NReco.PdfGenerator à IronPDF

Plusieurs facteurs poussent les équipes à évaluerIronPDFcomme alternative à NReco.PdfGenerator :

Conformité en matière de sécurité : Les organisations soumises à des exigences de sécurité rencontrent des difficultés lorsque les scanners de vulnérabilités identifient des CVE wkhtmltopdf. Puisque wkhtmltopdf est abandonné, ces vulnérabilités n'ont pas de voie de remédiation au sein de NReco.PdfGenerator. Le moteur Chromium d'IronPDF, activement entretenu, reçoit des mises à jour de sécurité.

Exigences CSS modernes : Les projets nécessitant CSS Grid, Flexbox, les variables CSS ou d'autres fonctionnalités CSS modernes ne peuvent pas utiliser le moteur WebKit de wkhtmltopdf (datant de 2012). Les concepteurs web produisent souvent des mises en page qui s'affichent incorrectement, voire pas du tout, dans NReco.PdfGenerator.

Compatibilité JavaScript : les applications générant des PDF avec du contenu rendu en JavaScript (graphiques, tableaux dynamiques, valeurs calculées) nécessitent une prise en charge moderne de JavaScript. la limitation ES5 de wkhtmltopdf empêche l'utilisation de bibliothèques JavaScript contemporaines.

Architecture d'application asynchrone : les applications ASP.NET Core bénéficient de la génération asynchrone de PDF pour maintenir l'efficacité des threads. L'API synchrone de NReco.PdfGenerator peut créer des goulets d'étranglement au niveau de l'évolutivité.

Simplification du déploiement : la gestion des binaires wkhtmltopdf spécifiques à chaque plateforme dans les environnements de développement, de préproduction et de production ajoute de la complexité opérationnelle. Les équipes recherchent des solutions autonomes qui simplifient les pipelines CI/CD.

Clarté des prix : La planification budgétaire nécessite des coûts prévisibles. La tarification opaque de NReco.PdfGenerator (contacter le service commercial) complique l'approvisionnement, tandis que la tarification publiée d'IronPDF permet une budgétisation directe.

Comparaison des installations

Installation deNReco.PdfGenerator:

Install-Package NReco.PdfGenerator
Install-Package NReco.PdfGenerator
SHELL

Plus l'installation et la gestion des binaires wkhtmltopdf spécifiques à la plateforme.

Installation d'IronPDF:

Install-Package IronPdf
Install-Package IronPdf
SHELL

IronPDF nécessite la configuration d'une clé de licence au démarrage de l'application :

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

Les deux bibliothèques prennent en charge .NET Framework 4.6.2+ et .NET Core/.NET 5+, ce qui les rend compatibles avec le développement .NET moderne ciblant .NET 10 et C# 14.

Considérations de performance

Le moteur Chromium d'IronPDF a un coût d'initialisation lors de la première utilisation (environ 1,5 seconde pour le démarrage de Chromium). Les rendus ultérieurs sont nettement plus rapides. Pour les applications dont les exigences de démarrage sont sensibles à la latence, le réchauffement du moteur de rendu lors de l'initialisation de l'application permet d'éviter que ce retard n'affecte les opérations en contact avec l'utilisateur :

// Warm up at startup
new ChromePdfRenderer().RenderHtmlAsPdf("<html></html>");
// Warm up at startup
new ChromePdfRenderer().RenderHtmlAsPdf("<html></html>");
$vbLabelText   $csharpLabel

NReco.PdfGenerator a également une surcharge d'initialisation lors du lancement du processus wkhtmltopdf, ainsi qu'une surcharge de mémoire permanente due à la gestion des processus externes.

Prendre la décision

Le choix entre NReco.PdfGenerator etIronPDFdépend de vos besoins spécifiques :

Envisagez NReco.PdfGenerator si : vous disposez de flux de travail wkhtmltopdf existants qui fonctionnent correctement, les résultats de l'analyseur de sécurité sont acceptables dans votre environnement, vous n'avez pas besoin de fonctionnalités CSS ou JavaScript modernes et vous pouvez gérer le déploiement binaire spécifique à la plateforme.

Optez pourIronPDFsi : la conformité en matière de sécurité exige la prise en compte des CVE de wkhtmltopdf, vos conceptions utilisent des fonctionnalités CSS modernes comme Grid ou Flexbox, vous avez besoin de la prise en charge async/await pour les applications Web, vous souhaitez simplifier le déploiement en éliminant les binaires externes ou vous préférez une licence et une tarification transparentes.

Pour les équipes qui créent des applications .NET modernes en 2025 et qui prévoient 2026, le moteur Chromium d'IronPDF, activement entretenu, constitue une base pour la compatibilité actuelle et future avec les normes du web.

Commencer avec IronPDF

Pour évaluerIronPDFpour vos besoins en matière de génération de PDF :

  1. Installez le paquet NuGet IronPDF : Install-Package IronPdf
  2. Consultez le tutoriel du HTML au PDF pour connaître les modèles de conversion de base
  3. Explorez la conversion d'URL en PDF pour la capture de pages web
  4. Configurer les en-têtes et pieds de page pour des documents professionnels

Les tutoriels IronPDF fournissent des exemples complets pour des scénarios courants, et la référence API documente toutes les classes et méthodes disponibles.

Réflexions Finales

NReco.PdfGenerator etIronPDFreprésentent différentes époques de la technologie de génération de PDF. NReco.PdfGenerator intègre le moteur WebKit 2012 de wkhtmltopdf, reprenant à la fois son API familière, ses vulnérabilités en matière de sécurité et ses limitations en matière de rendu.IronPDFutilise un moteur Chromium moderne avec une maintenance active, une prise en charge des normes web actuelles et des capacités asynchrones.

Pour les équipes préoccupées par la conformité en matière de sécurité, les exigences modernes en matière de CSS/JavaScript ou la complexité du déploiement,IronPDFoffre une voie à suivre sans la dette technique des dépendances abandonnées. La transition nécessite la mise à jour des appels API et de la syntaxe des espaces réservés, mais élimine la nécessité de gérer des binaires externes et résout les vulnérabilités de sécurité documentées.

Évaluez les deux options en fonction de vos besoins spécifiques en matière de sécurité, de fidélité du rendu, de prise en charge asynchrone et de simplicité de déploiement. Comprendre les différences architecturales décrites dans cette comparaison vous aidera à prendre une décision éclairée qui correspond à vos besoins en matière de génération de PDF et à vos objectifs de modernisation.