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 du générateur de pdf nreco vers IronPDF
VIDéOS

Comment convertir RTF en PDF à l'aide de C#

Curtis Chau
Curtis Chau
Mis à jour:

Pourquoi passer de NReco PDF Generatorà IronPDF

Questions de sécurité critiques avec NReco PDF Generator

NReco PDF Generator entoure le binaire wkhtmltopdf, héritant de ses vulnérabilités de sécurité connues. La dernière version stable du projet wkhtmltopdf était 0.12.6 (juin 2020) et le dépôt amont a été archivé le 2 janvier 2023, donc aucun correctif n'arrive :

  • CVE-2020-21365 : Répertoire traversée / lecture de fichiers locaux via HTML fabriqué (faiblesse de la politique same-origin)
  • CVE-2022-35583 : Falsification de requête côté serveur (SSRF) via une injection <iframe> dans la version 0.12.6 (CVSS 9.8)

Limitations supplémentaires de NReco PDF Generator

  1. Friction de licence à grande échelle : Gratuit pour les déploiements en production unique serveur non-SaaS ; Les scénarios SaaS, multi-serveurs, ou de redistribution nécessitent le pack source entreprise à 199$ sur nrecosite.com.

  2. Moteur de rendu obsolète : WebKit Qt (environ 2012) avec support CSS3/JS limité :

    • Pas de grille CSS ni de Flexbox
    • Pas de JavaScriptmoderne (ES6+)
    • Mauvaise prise en charge des polices de caractères sur le web
    • Pas de variables CSS ni de propriétés personnalisées

  3. Dépendance externe binaire : Nécessite la gestion des binaires wkhtmltopdf par plateforme (wkhtmltopdf.exe, wkhtmltox.dll).

  4. Entretien arrêté : NReco.PdfGenerator 1.2.1 a été publié le 8 janvier 2023 et n'a eu aucune autre version sur nuget.org ; le moteur wkhtmltopdf sous-jacent n'est plus mis à jour.

  5. Prise en charge asynchrone limitée : l'API synchrone bloque les threads dans les applications Web.

NReco PDF Generatorvs IronPDF Comparaison

Aspect NReco PDF Generator IronPDF
Moteur de rendu WebKit Qt (2012) Chromium (actuel)
Sécurité Multiples CVEs non corrigées (par exemple, CVE-2020-21365, CVE-2022-35583) ; moteur archivé le 2 janvier 2023 Mises à jour de sécurité actives
Support CSS CSS2.1, CSS3 limité CSS3 complet, grille, Flexbox
JavaScript ES5 de base ES6+ complet, async/await
Dépendances Binaire externe wkhtmltopdf Autonome
Prise en charge de l'asynchronisme Synchrone uniquement Async/await complet
Polices de caractères Web Limité Polices Google complètes, @font-face
Licence d'utilisation Gratuit pour serveur unique non-SaaS; 199$ pack entreprise pour SaaS / multi-serveur Tarification commerciale transparente
Niveau gratuit Gratuit sous licence serveur unique non-SaaS Essai sans filigrane

Avant de commencer

Prérequis

  1. Environnement .NET : .NET Framework 4.6.2+ ou .NET Core 3.1+ / .NET 5/6/7/8/9+
  2. Accès à NuGet : possibilité d'installer des packages NuGet
  3. Licence IronPDF : Obtenez votre clé de licence sur IronPDF

Modifications du paquet NuGet

# Remove NReco.PdfGenerator
dotnet remove package NReco.PdfGenerator

# Install IronPDF
dotnet add package IronPdf
# Remove NReco.PdfGenerator
dotnet remove package NReco.PdfGenerator

# Install IronPDF
dotnet add package IronPdf
SHELL

Supprimez également les binaires wkhtmltopdf de votre déploiement :

  • Supprimez wkhtmltopdf.exe, wkhtmltox.dll du projet
  • Supprimer tous les scripts d'installation de wkhtmltopdf
  • Supprimer les dossiers binaires spécifiques à une plateforme

Configuration de la licence

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

Identifier l'utilisation du générateur de PDF NReco

# Find all NReco.PdfGenerator references
grep -r "NReco.PdfGenerator\|HtmlToPdfConverter\|GeneratePdf" --include="*.cs" .
# Find all NReco.PdfGenerator references
grep -r "NReco.PdfGenerator\|HtmlToPdfConverter\|GeneratePdf" --include="*.cs" .
SHELL

Référence API complète

Mappages de classes de base

NReco PDF Generator IronPDF
HtmlToPdfConverter ChromePdfRenderer
PageMargins Propriétés des marges individuelles
PageOrientation PdfPaperOrientation
PageSize PdfPaperSize

Mappages de méthodes de rendu

NReco PDF Generator IronPDF
GeneratePdf(html) RenderHtmlAsPdf(html)
GeneratePdfFromFile(url, output) RenderUrlAsPdf(url)
GeneratePdfFromFile(htmlPath, output) RenderHtmlFileAsPdf(path)
(async non pris en charge) RenderHtmlAsPdfAsync(html)
(async non pris en charge) RenderUrlAsPdfAsync(url)

Mappages de configuration de page

NReco PDF Generator IronPDF
PageWidth = 210 RenderingOptions.PaperSize = PdfPaperSize.A4
PageHeight = 297 RenderingOptions.SetCustomPaperSizeinMilimeters(w, h)
Orientation = PageOrientation.Landscape RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape
Size = PageSize.A4 RenderingOptions.PaperSize = PdfPaperSize.A4

Mise en correspondance des marges

NReco PDF Generator IronPDF
Margins.Top = 10 RenderingOptions.MarginTop = 10
Margins.Bottom = 10 RenderingOptions.MarginBottom = 10
Margins.Left = 10 RenderingOptions.MarginLeft = 10
Margins.Right = 10 RenderingOptions.MarginRight = 10
nouvelles marges de page { ... } Propriétés individuelles

Mappages des espaces réservés de l'en-tête et du pied de page

NReco PDF Generator(wkhtmltopdf) IronPDF
[page] {page}
[topage] {total-pages}
[date] {date}
[time] {time}
[title] {html-title}

Mappages de gestion des sorties

NReco PDF Generator IronPDF
byte[] pdfBytes = GeneratePdf(html) PdfDocument pdf = RenderHtmlAsPdf(html)
File.WriteAllBytes(path, bytes) pdf.SaveAs(path)
return pdfBytes return pdf.BinaryData
new MemoryStream(pdfBytes) new MemoryStream(pdf.BinaryData)

Exemples de migration de code

Exemple 1 : HTML de base vers PDF

Avant (NReco PDF Generator):

// 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);
    }
}
Imports NReco.PdfGenerator
Imports System.IO

Class Program
    Shared Sub Main()
        Dim htmlToPdf = New HtmlToPdfConverter()
        Dim htmlContent = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>"
        Dim pdfBytes = htmlToPdf.GeneratePdf(htmlContent)
        File.WriteAllBytes("output.pdf", pdfBytes)
    End Sub
End Class
$vbLabelText   $csharpLabel

Après (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");
    }
}
Imports IronPdf
Imports System.IO

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim htmlContent = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
        pdf.SaveAs("output.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

La différence fondamentale réside dans le type de retour et le modèle de sauvegarde. La méthode HtmlToPdfConverter.GeneratePdf() de NReco PDF Generatorretourne un byte[] que vous devez écrire manuellement sur le disque en utilisant File.WriteAllBytes(). La méthode ChromePdfRenderer.RenderHtmlAsPdf() d'IronPDF retourne un objet PdfDocument avec une méthode SaveAs() intégrée.

Cette approche orientée objet offre des avantages supplémentaires : vous pouvez manipuler le PDF (ajouter des filigranes, fusionner des documents, ajouter de la sécurité) avant de l'enregistrer. Si vous avez besoin des octets bruts pour la compatibilité avec le code existant, utilisez pdf.BinaryData. Voir la documentation HTML vers PDF pour des options de rendu supplémentaires.

Exemple 2 : Taille de page personnalisée avec marges

Avant (NReco PDF Generator):

// 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);
    }
}
Imports NReco.PdfGenerator
Imports System.IO

Class Program
    Shared Sub Main()
        Dim htmlToPdf = New HtmlToPdfConverter()
        htmlToPdf.PageWidth = 210
        htmlToPdf.PageHeight = 297
        htmlToPdf.Margins = New PageMargins With {.Top = 10, .Bottom = 10, .Left = 10, .Right = 10}
        Dim htmlContent = "<html><body><h1>Custom Page Size</h1><p>A4 size document with margins.</p></body></html>"
        Dim pdfBytes = htmlToPdf.GeneratePdf(htmlContent)
        File.WriteAllBytes("custom-size.pdf", pdfBytes)
    End Sub
End Class
$vbLabelText   $csharpLabel

Après (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");
    }
}
Imports IronPdf
Imports IronPdf.Rendering

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
        renderer.RenderingOptions.MarginTop = 10
        renderer.RenderingOptions.MarginBottom = 10
        renderer.RenderingOptions.MarginLeft = 10
        renderer.RenderingOptions.MarginRight = 10
        Dim htmlContent = "<html><body><h1>Custom Page Size</h1><p>A4 size document with margins.</p></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
        pdf.SaveAs("custom-size.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

NReco PDF Generator utilise des dimensions numériques (PageWidth = 210, PageHeight = 297) et un objet PageMargins.IronPDF utilise l'énumération PdfPaperSize (qui inclut des tailles standards telles que A4, Lettre, Légal) et des propriétés de marge individuelles sur l'objet RenderingOptions.

Les principaux changements liés à la migration :

  • PageHeight → RenderingOptions.PaperSize = PdfPaperSize.A4
  • new PageMargins { Top = 10, ... }→ Individual properties: RenderingOptions.MarginTop = 10

Pour les formats de papier personnalisés non couverts par l'énumération, utilisez RenderingOptions.SetCustomPaperSizeinMilimeters(width, height). En savoir plus sur les options de configuration des pages.

Exemple 3 : Conversion d'une URL en PDF

Avant (NReco PDF Generator):

// 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);
    }
}
Imports NReco.PdfGenerator
Imports System.IO

Class Program
    Shared Sub Main()
        Dim htmlToPdf As New HtmlToPdfConverter()
        Dim pdfBytes As Byte() = htmlToPdf.GeneratePdfFromFile("https://www.example.com", Nothing)
        File.WriteAllBytes("webpage.pdf", pdfBytes)
    End Sub
End Class
$vbLabelText   $csharpLabel

Après (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");
    }
}
Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderUrlAsPdf("https://www.example.com")
        pdf.SaveAs("webpage.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

NReco PDF Generator utilise la méthode GeneratePdfFromFile(), au nom confus, pour les fichiers locaux et les URLs, avec un second paramètre nullable.IronPDF fournit des méthodes dédiées : RenderUrlAsPdf() pour les URLs et RenderHtmlFileAsPdf() pour les fichiers HTML locaux.

L'approche d'IronPDF est plus propre et plus intuitive. Pour les applications web asynchrones, utilisez await renderer.RenderUrlAsPdfAsync(url) pour éviter de bloquer les threads — chose que NReco PDF Generatorne peut tout simplement pas faire.

Notes de migration essentielles

Conversion de la valeur du zoom

NReco PDF Generator utilise des valeurs flottantes (0,0-2,0), tandis qu'IronPDF utilise des nombres entiers en pourcentage :

// NReco PDF Generator: Zoom = 0.9f (90%)
// IronPDF: Zoom = 90

// Conversion formula:
int ironPdfZoom = (int)(nrecoZoom * 100);
// NReco PDF Generator: Zoom = 0.9f (90%)
// IronPDF: Zoom = 90

// Conversion formula:
int ironPdfZoom = (int)(nrecoZoom * 100);
' NReco PDF Generator: Zoom = 0.9F (90%)
' IronPDF: Zoom = 90

' Conversion formula:
Dim ironPdfZoom As Integer = CInt(nrecoZoom * 100)
$vbLabelText   $csharpLabel

Mise à jour de la syntaxe des espaces réservés

Tous les marqueurs d'en-tête et de pied de page doivent être mis à jour :

NReco PDF Generator IronPDF
[page] {page}
[topage] {total-pages}
[date] {date}
[title] {html-title} 
// NReco PDF Generator:
converter.PageFooterHtml = "<div>Page [page] of [topage]</div>";

// IronPDF:
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    HtmlFragment = "<div>Page {page} of {total-pages}</div>",
    MaxHeight = 20
};
// NReco PDF Generator:
converter.PageFooterHtml = "<div>Page [page] of [topage]</div>";

// IronPDF:
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    HtmlFragment = "<div>Page {page} of {total-pages}</div>",
    MaxHeight = 20
};
Imports NReco.PdfGenerator
Imports IronPdf

' NReco PDF Generator:
converter.PageFooterHtml = "<div>Page [page] of [topage]</div>"

' IronPDF:
renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter With {
    .HtmlFragment = "<div>Page {page} of {total-pages}</div>",
    .MaxHeight = 20
}
$vbLabelText   $csharpLabel

Changement de type de retour

NReco PDF Generator returns byte[] directly;IronPDF retourne PdfDocument :

// NReco PDF Generatorpattern:
byte[] pdfBytes = converter.GeneratePdf(html);
File.WriteAllBytes("output.pdf", pdfBytes);

//IronPDF pattern:
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

// Or if you need bytes:
byte[] pdfBytes = renderer.RenderHtmlAsPdf(html).BinaryData;
// NReco PDF Generatorpattern:
byte[] pdfBytes = converter.GeneratePdf(html);
File.WriteAllBytes("output.pdf", pdfBytes);

//IronPDF pattern:
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

// Or if you need bytes:
byte[] pdfBytes = renderer.RenderHtmlAsPdf(html).BinaryData;
' NReco PDF Generator pattern:
Dim pdfBytes As Byte() = converter.GeneratePdf(html)
File.WriteAllBytes("output.pdf", pdfBytes)

' IronPDF pattern:
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")

' Or if you need bytes:
Dim pdfBytes As Byte() = renderer.RenderHtmlAsPdf(html).BinaryData
$vbLabelText   $csharpLabel

Sécurité des threads et réutilisabilité

NReco PDF Generator crée généralement un nouveau convertisseur par appel. La méthode ChromePdfRenderer d'IronPDF est thread-safe et peut être réutilisée :

// NReco PDF Generatorpattern (creates new each time):
public byte[] Generate(string html)
{
    var converter = new HtmlToPdfConverter();
    return converter.GeneratePdf(html);
}

//IronPDF pattern (reuse renderer, thread-safe):
private readonly ChromePdfRenderer _renderer = new ChromePdfRenderer();

public byte[] Generate(string html)
{
    return _renderer.RenderHtmlAsPdf(html).BinaryData;
}
// NReco PDF Generatorpattern (creates new each time):
public byte[] Generate(string html)
{
    var converter = new HtmlToPdfConverter();
    return converter.GeneratePdf(html);
}

//IronPDF pattern (reuse renderer, thread-safe):
private readonly ChromePdfRenderer _renderer = new ChromePdfRenderer();

public byte[] Generate(string html)
{
    return _renderer.RenderHtmlAsPdf(html).BinaryData;
}
Imports NReco.PdfGenerator
Imports IronPdf

' NReco PDF Generator pattern (creates new each time):
Public Function Generate(html As String) As Byte()
    Dim converter As New HtmlToPdfConverter()
    Return converter.GeneratePdf(html)
End Function

' IronPDF pattern (reuse renderer, thread-safe):
Private ReadOnly _renderer As New ChromePdfRenderer()

Public Function Generate(html As String) As Byte()
    Return _renderer.RenderHtmlAsPdf(html).BinaryData
End Function
$vbLabelText   $csharpLabel

Support asynchrone (nouvelle capacité)

IronPDF prend en charge les modèles async/await que NReco PDF Generatorne peut pas fournir :

// NReco PDF Generator: No async support available

// IronPDF: Full async support
public async Task<byte[]> GenerateAsync(string html)
{
    var pdf = await _renderer.RenderHtmlAsPdfAsync(html);
    return pdf.BinaryData;
}
// NReco PDF Generator: No async support available

// IronPDF: Full async support
public async Task<byte[]> GenerateAsync(string html)
{
    var pdf = await _renderer.RenderHtmlAsPdfAsync(html);
    return pdf.BinaryData;
}
Imports System.Threading.Tasks

' NReco PDF Generator: No async support available

' IronPDF: Full async support
Public Async Function GenerateAsync(html As String) As Task(Of Byte())
    Dim pdf = Await _renderer.RenderHtmlAsPdfAsync(html)
    Return pdf.BinaryData
End Function
$vbLabelText   $csharpLabel

Dépannage

Édition 1 : HtmlToPdfConverter introuvable

Problème : La classe HtmlToPdfConverter n'existe pas dans IronPDF.

Solution: Use ChromePdfRenderer:

// NReco PDF Generator
var converter = new HtmlToPdfConverter();

// IronPDF
var renderer = new ChromePdfRenderer();
// NReco PDF Generator
var converter = new HtmlToPdfConverter();

// IronPDF
var renderer = new ChromePdfRenderer();
' NReco PDF Generator
Dim converter As New HtmlToPdfConverter()

' IronPDF
Dim renderer As New ChromePdfRenderer()
$vbLabelText   $csharpLabel

Sujet 2 : GeneratePdf renvoie un type erroné

Problème : Le code attend byte[] mais obtient PdfDocument.

Solution : Accédez à la propriété .BinaryData :

// NReco PDF Generator
byte[] pdfBytes = converter.GeneratePdf(html);

// IronPDF
byte[] pdfBytes = renderer.RenderHtmlAsPdf(html).BinaryData;
// NReco PDF Generator
byte[] pdfBytes = converter.GeneratePdf(html);

// IronPDF
byte[] pdfBytes = renderer.RenderHtmlAsPdf(html).BinaryData;
' NReco PDF Generator
Dim pdfBytes As Byte() = converter.GeneratePdf(html)

' IronPDF
Dim pdfBytes As Byte() = renderer.RenderHtmlAsPdf(html).BinaryData
$vbLabelText   $csharpLabel

Sujet 3 : Objet PageMargins introuvable

Problème : La classe PageMargins n'existe pas dans IronPDF.

Solution : Utiliser les propriétés de marge individuelles :

// NReco PDF Generator
converter.Margins = new PageMargins { Top = 10, Bottom = 10, Left = 10, Right = 10 };

// IronPDF
renderer.RenderingOptions.MarginTop = 10;
renderer.RenderingOptions.MarginBottom = 10;
renderer.RenderingOptions.MarginLeft = 10;
renderer.RenderingOptions.MarginRight = 10;
// NReco PDF Generator
converter.Margins = new PageMargins { Top = 10, Bottom = 10, Left = 10, Right = 10 };

// IronPDF
renderer.RenderingOptions.MarginTop = 10;
renderer.RenderingOptions.MarginBottom = 10;
renderer.RenderingOptions.MarginLeft = 10;
renderer.RenderingOptions.MarginRight = 10;
' NReco PDF Generator
converter.Margins = New PageMargins With {.Top = 10, .Bottom = 10, .Left = 10, .Right = 10}

' IronPDF
renderer.RenderingOptions.MarginTop = 10
renderer.RenderingOptions.MarginBottom = 10
renderer.RenderingOptions.MarginLeft = 10
renderer.RenderingOptions.MarginRight = 10
$vbLabelText   $csharpLabel

Sujet 4 : Les numéros de page n'apparaissent pas

Problème : Les espaces réservés [page] et [topage] ne fonctionnent pas.

Solution : Mise à jour de la syntaxe des espaces réservés IronPDF :

// NReco PDF Generator
converter.PageFooterHtml = "<div>Page [page] of [topage]</div>";

// IronPDF
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    HtmlFragment = "<div>Page {page} of {total-pages}</div>",
    MaxHeight = 20
};
// NReco PDF Generator
converter.PageFooterHtml = "<div>Page [page] of [topage]</div>";

// IronPDF
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    HtmlFragment = "<div>Page {page} of {total-pages}</div>",
    MaxHeight = 20
};
Imports NReco.PdfGenerator
Imports IronPdf

converter.PageFooterHtml = "<div>Page [page] of [topage]</div>"

renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter With {
    .HtmlFragment = "<div>Page {page} of {total-pages}</div>",
    .MaxHeight = 20
}
$vbLabelText   $csharpLabel

Liste de contrôle de la migration

Pré-migration

  • Répertoriez toutes les utilisations de NReco.PdfGenerator dans le code
  • Documentez toutes les valeurs CustomWkHtmlArgs et CustomWkHtmlPageArgs
  • Lister tous les modèles HTML d'en-tête/de pied de page avec espaces réservés
  • Identifier les exigences asynchrones (contrôleurs web, services)
  • Vérifier les paramètres de Zoom et de marge
  • Sauvegarder les fichiers PDF existants à des fins de comparaison
  • Obtenir une clé de licence IronPDF

Modifications du paquet

  • Supprimez le package NuGet NReco.PdfGenerator
  • Installez le package NuGet IronPdf : dotnet add package IronPdf
  • Mettez à jour les imports de namespace de using NReco.PdfGenerator; à using IronPdf;

Modifications du code

  • Ajouter la configuration de la clé de licence au démarrage
  • Remplacez HtmlToPdfConverter par ChromePdfRenderer
  • Remplacez GeneratePdf(html) par RenderHtmlAsPdf(html)
  • Remplacez GeneratePdfFromFile(url, null) par RenderUrlAsPdf(url)
  • Convertissez l'objet PageMargins en propriétés de marge individuelles
  • Mettre à jour les valeurs de Zoom , qui sont désormais converties en pourcentages.
  • Mettez à jour la syntaxe des espaces réservés : [page] → {page}, [topage] → {total-pages}
  • Remplacez File.WriteAllBytes() par pdf.SaveAs()
  • Convertir les appels synchrones en appels asynchrones lorsque cela s'avère utile

Après la migration

  • Supprimer les fichiers binaires wkhtmltopdf du projet/déploiement
  • Mettez à jour les fichiers Docker pour supprimer l'installation de wkhtmltopdf
  • Effectuer des tests de régression comparant les résultats PDF
  • Vérifier que les espaces réservés à l'en-tête et au pied de page s'affichent correctement
  • Testé sur toutes les plateformes cibles (Windows, Linux, macOS)
  • Mettre à jour le pipeline CI/CD pour supprimer les étapes wkhtmltopdf
  • Mettre à jour l'analyse de sécurité pour confirmer la suppression des CVE

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

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