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

Comment migrer d'un générateur de PDF NReco vers IronPDF en 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 intègre le binaire déprécié wkhtmltopdf, héritant ainsi de toutes ses vulnérabilités en matière de sécurité. Il ne s'agit pas d'un problème théorique : il existe plus de 20 CVE documentés sans aucun correctif disponible depuis l'abandon de wkhtmltopdf en 2020 :

  • CVE-2020-21365 : Falsification de requête côté serveur (SSRF)
  • CVE-2022-35583 : Lecture de fichiers locaux via injection HTML
  • CVE-2022-35580 : Potentiel d'exécution de code à distance

Ces vulnérabilités ne peuvent pas être corrigées car le projet wkhtmltopdf sous-jacent n'est plus maintenu.

Limitations supplémentaires de NReco PDF Generator

  1. Version gratuite avec filigrane : L'utilisation en production nécessite une licence payante dont le prix est opaque et qui requiert de contacter le service commercial.

  2. Moteur de rendu obsolète : WebKit Qt (environ 2012) offre une prise en charge web moderne limitée :

    • 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 binaire externe : Nécessite la gestion des binaires wkhtmltopdf par plateforme (wkhtmltopdf.exe, wkhtmltox.dll).

  4. Aucun développement actif : le wrapper bénéficie d'une maintenance sans mises à jour du moteur sous-jacent.

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

NReco PDF GeneratorvsIronPDFComparaison

Aspect NReco PDF Generator IronPDF
Moteur de rendu WebKit Qt (2012) Chromium (actuel)
Sécurité plus de 20 CVE, pas de correctifs 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 Prix opaques, contacter les ventes Tarification transparente
Essai gratuit En filigrane Fonctionnalité complète

Pour les équipes qui prévoient l'adoption de .NET 10 et C# 14 jusqu'en 2025 et 2026,IronPDFconstitue une base à l'épreuve du temps avec un développement actif et des capacités de rendu modernes.

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 :

  • Supprimer 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) pdf.Stream

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. Le générateur PDF NReco HtmlToPdfConverter.GeneratePdf() renvoie un byte[] que vous devez écrire manuellement sur le disque en utilisant File.WriteAllBytes().IronPDFrenvoie un objet avec une méthode 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.IronPDFutilise l'énumération PdfPaperSize (qui comprend des tailles standard comme A4, Letter, Legal) 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 au nom déroutant GeneratePdfFromFile() pour les fichiers locaux et les URL, avec un deuxième paramètre pouvant être nul.IronPDFfournit des méthodes dédiées : RenderUrlAsPdf() pour les URL et RenderHtmlFileAsPdf() pour les fichiers HTML locaux.

L'approcheIronPDFest plus simple et plus intuitive. Pour les applications web asynchrones, utilisez await renderer.RenderUrlAsPdfAsync(url) afin d'éviter le blocage des threads — une fonctionnalité que NReco PDF Generatorne propose pas.

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 renvoie directement byte[] ;IronPDFrenvoie PdfDocument:

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

//IronPDFpattern:
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);

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

// Or if you need bytes:
byte[] pdfBytes = renderer.RenderHtmlAsPdf(html).BinaryData;
Imports System.IO

' 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. Le code ChromePdfRenderer d'IronPDF est sûr pour les threads et peut être réutilisé :

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

//IronPDFpattern (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);
}

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

public byte[] Generate(string html)
{
    return _renderer.RenderHtmlAsPdf(html).BinaryData;
}
' 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 : HtmlToPdfConverter classe n'existe pas dans IronPDF.

Solution : Utilisez 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

  • Inventaire de toutes les utilisations de NReco.PdfGenerator dans le code source
  • 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

  • Supprimer le package NuGet NReco.PdfGenerator
  • Installez le package NuGet IronPdf : dotnet add package IronPdf
  • Mettre à jour les importations d'espace de noms 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)
  • Convertir l'objet PageMargins en propriétés de marge individuelles
  • Mettre à jour les valeurs de Zoom , qui sont désormais converties en pourcentages.
  • Mise à jour de 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
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