Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. Migrationsleitfäden
  4. migration von nreco pdf generator zu IronPDF
MIGRATIONSLEITFäDEN

Wie man von NReco PDF Generator zu IronPDF in C# migriert

Curtis Chau
Curtis Chau
Aktualisiert:

Warum von NReco PDF Generatorzu IronPDF migrieren

Kritische Sicherheitsprobleme mit NReco PDF Generator

NReco PDF Generator umschließt das wkhtmltopdf-Binärpaket und erbt dessen bekannte Sicherheitsanfälligkeiten. Die letzte stabile Veröffentlichung des wkhtmltopdf-Projekts war 0.12.6 (Juni 2020), und das Upstream-Repository wurde am 2. Januar 2023 archiviert, sodass keine Patches kommen:

  • CVE-2020-21365: Verzeichnis-Traversal / lokale Dateilesung über präpariertes HTML (Schwachstelle beim Same-Origin-Policy)
  • CVE-2022-35583: Server-seitige Anforderungsfälschung (SSRF) durch injizierten <iframe> in 0.12.6 (CVSS 9.8)

Zusätzliche NReco PDF GeneratorEinschränkungen

  1. Lizenzierungs-Reibung im großen Maßstab: Kostenlos für Non-SaaS Einzelserver-Produktionsbereitstellungen; SaaS-, Mehrserver- oder Verteilungsszenarien erfordern das $199 Enterprise-Source-Code-Paket von nrecosite.com.

  2. Abgekündigte Rendering-Engine: WebKit Qt (circa 2012) mit begrenzter CSS3/JS-Unterstützung:

    • Kein CSS-Gitter oder Flexbox
    • Kein modernes JavaScript(ES6+)
    • Schlechte Unterstützung von Webfonts
    • Keine CSS-Variablen oder benutzerdefinierten Eigenschaften

  3. Externe Binärabhängigkeit: Erfordert die Verwaltung von wkhtmltopdf-Binärdateien pro Plattform (wkhtmltopdf.exe, wkhtmltox.dll).

  4. Gestockte Wartung: NReco.PdfGenerator 1.2.1 wurde am 8. Januar 2023 veröffentlicht und hat keine weiteren Veröffentlichungen auf nuget.org gehabt; die zugrundeliegende wkhtmltopdf-Engine wird nicht mehr aktualisiert.

  5. Eingeschränkte Unterstützung für asynchrone Prozesse: Die synchrone API blockiert Threads in Webanwendungen.

NReco PDF Generatorvs IronPDF Vergleich

Aspekt NReco PDF Generator IronPDF
Rendering-Engine WebKit Qt (2012) Chromium (aktuell)
Sicherheit Mehrere ungepatchte CVEs (z.B. CVE-2020-21365, CVE-2022-35583); Engine archiviert am 2. Januar 2023 Aktive Sicherheitsupdates
CSS-Unterstützung CSS2.1, eingeschränkt CSS3 Vollständig CSS3, Grid, Flexbox
JavaScript Grundlegende ES5 Vollständig ES6+, async/await
Abhängigkeiten Externe wkhtmltopdf-Binärdatei In sich geschlossen
Async-Unterstützung Nur synchron Vollständig async/await
Web-Schriftarten Beschränkt Vollständige Google-Schriftarten, @font-face
Lizenzierung Kostenlos für Non-SaaS Einzelserver; $199 Enterprise-Paket für SaaS / Mehrserver Transparente kommerzielle Preisgestaltung
Freie Stufe Kostenlos unter Non-SaaS Einzelserver-Lizenz Test erfordert kein Wasserzeichen

Bevor Sie beginnen

Voraussetzungen

  1. .NET -Umgebung: .NET Framework 4.6.2+ oder .NET Core 3.1+ / .NET 5/6/7/8/9+
  2. NuGet -Zugriff: Möglichkeit zur Installation von NuGet -Paketen
  3. IronPDF -Lizenz: Ihren Lizenzschlüssel erhalten Sie unter IronPDF.

NuGet-Paketänderungen

# 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

Entfernen Sie auch die wkhtmltopdf-Binärdateien aus Ihrer Bereitstellung:

  • Löschen Sie wkhtmltopdf.exe, wkhtmltox.dll aus dem Projekt
  • Entfernen Sie alle wkhtmltopdf-Installationsskripte
  • Löschen von plattformspezifischen Binärordnern

Lizenz-Konfiguration

// 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

NReco PDF Generator-Verwendung identifizieren

# 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

Komplette API-Referenz

Kernklassen-Zuordnungen

NReco PDF Generator IronPDF
HtmlToPdfConverter ChromePdfRenderer
PageMargins Einzelne Randeigenschaften
PageOrientation PdfPaperOrientation
PageSize PdfPaperSize

Zuordnungen von Rendering-Methoden

NReco PDF Generator IronPDF
GeneratePdf(html) RenderHtmlAsPdf(html)
GeneratePdfFromFile(url, output) RenderUrlAsPdf(url)
GeneratePdfFromFile(htmlPath, output) RenderHtmlFileAsPdf(path)
(async nicht unterstützt) RenderHtmlAsPdfAsync(html)
(async nicht unterstützt) RenderUrlAsPdfAsync(url)

Zuordnungen der Seitenkonfiguration

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

Randzuordnungen

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
new PageMargins { ... } Einzelne Eigenschaften

Kopf-/Fußzeilen-Platzhalter-Zuordnungen

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

Zuordnungen für die Ausgabeverarbeitung

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)

Beispiele für die Code-Migration

Beispiel 1: Grundlegendes HTML zu PDF

Vor (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

Nach (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

Der grundlegende Unterschied liegt im Rückgabetyp und im Speichermuster. Der HtmlToPdfConverter.GeneratePdf() von NReco PDF Generatorgibt einen byte[] zurück, den Sie manuell auf die Festplatte schreiben müssen, indem Sie File.WriteAllBytes() verwenden. IronPDFs ChromePdfRenderer.RenderHtmlAsPdf() gibt ein PdfDocument-Objekt mit einer eingebauten SaveAs()-Methode zurück.

Dieser objektorientierte Ansatz bietet zusätzliche Vorteile: Sie können die PDF-Datei vor dem Speichern manipulieren (Wasserzeichen hinzufügen, Dokumente zusammenführen, Sicherheit hinzufügen). Wenn Sie die Rohbytes für die Kompatibilität mit bestehendem Code benötigen, verwenden Sie pdf.BinaryData. Weitere Rendering-Optionen finden Sie in der HTML to PDF Dokumentation.

Beispiel 2: Benutzerdefinierte Seitengröße mit Rändern

Vor (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

Nach (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 verwendet numerische Dimensionen (PageWidth = 210, PageHeight = 297) und ein PageMargins-Objekt.IronPDF verwendet das PdfPaperSize-Enum (das Standardgrößen wie A4, Brief, Legal umfasst) und einzelne Randeigenschaften im RenderingOptions-Objekt.

Die wichtigsten Migrationsänderungen:

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

Für benutzerdefinierte Papiergrößen, die nicht vom Enum abgedeckt werden, verwenden Sie RenderingOptions.SetCustomPaperSizeinMilimeters(width, height). Erfahren Sie mehr über Seitenkonfigurationsoptionen.

Beispiel 3: Konvertierung einer URL in eine PDF-Datei

Vor (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

Nach (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 verwendet die verwirrend benannte Methode GeneratePdfFromFile() sowohl für lokale Dateien als auch für URLs, mit einem nullable zweiten Parameter.IronPDF bietet dedizierte Methoden: RenderUrlAsPdf() für URLs und RenderHtmlFileAsPdf() für lokale HTML-Dateien.

Der Ansatz von IronPDF ist sauberer und intuitiver. Für asynchrone Webanwendungen verwenden Sie await renderer.RenderUrlAsPdfAsync(url), um das Blockieren von Threads zu vermeiden—etwas, das NReco PDF Generatoreinfach nicht kann.

Kritische Hinweise zur Migration

Zoom-Wert-Umwandlung

NReco PDF Generator verwendet Fließkommazahlen (0,0-2,0), während IronPDF prozentuale Ganzzahlen verwendet:

// 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

Aktualisierung der Platzhalter-Syntax

Alle Kopf-/Fußzeilen-Platzhalter müssen aktualisiert werden:

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

Rückgabetyp ändern

NReco PDF Generator gibt byte[] direkt zurück;IronPDF gibt PdfDocument zurück:

// 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

Thread-Sicherheit und Wiederverwendbarkeit

NReco PDF Generator erstellt in der Regel einen neuen Konverter pro Aufruf. IronPDFs ChromePdfRenderer ist threadsicher und kann wiederverwendet werden:

// 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

Async-Unterstützung (neue Funktion)

IronPDF unterstützt async/await-Muster, die NReco PDF Generatornicht bieten kann:

// 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

Fehlerbehebung

Ausgabe 1: HtmlToPdfConverter nicht gefunden

Problem: Die Klasse HtmlToPdfConverter existiert nicht in IronPDF.

Lösung: Verwenden Sie 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

Problem 2: GeneratePdf liefert den falschen Typ

Problem: Der Code erwartet byte[], erhält jedoch PdfDocument.

Lösung: Greifen Sie auf die Eigenschaft .BinaryData zu:

// 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

Ausgabe 3: PageMargins Objekt nicht gefunden

Problem: Die Klasse PageMargins existiert nicht in IronPDF.

Lösung: Verwenden Sie individuelle Randeigenschaften:

// 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

Problem 4: Nicht angezeigte Seitenzahlen

Problem: Die Platzhalter [page] und [topage] funktionieren nicht.

Lösung: Aktualisierung der IronPDF Platzhaltersyntax:

// 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

Migrations-Checkliste

Vor der Migration

  • Inventarisieren Sie alle NReco.PdfGenerator-Verwendungen im Codebestand
  • Dokumentieren Sie alle CustomWkHtmlArgs- und CustomWkHtmlPageArgs-Werte
  • Liste aller Header-/Footer-HTML-Vorlagen mit Platzhaltern
  • Asynchrone Anforderungen identifizieren (Web-Controller, Dienste)
  • Überprüfen Sie die Zoom und Randeinstellungen
  • Vorhandene PDF-Ausgaben zum Vergleich sichern -IronPDF-Lizenzschlüssel erhalten

Paketänderungen

  • Entfernen Sie das NuGet-Paket NReco.PdfGenerator
  • Installieren Sie das NuGet-Paket IronPdf: dotnet add package IronPdf
  • Aktualisieren Sie die Namespace-Importe von using NReco.PdfGenerator; auf using IronPdf;

Code-Änderungen

  • Lizenzschlüsselkonfiguration beim Start hinzufügen
  • Ersetzen Sie HtmlToPdfConverter durch ChromePdfRenderer
  • Ersetzen Sie GeneratePdf(html) durch RenderHtmlAsPdf(html)
  • Ersetzen Sie GeneratePdfFromFile(url, null) durch RenderUrlAsPdf(url)
  • Konvertieren Sie das PageMargins-Objekt in einzelne Randeigenschaften
  • Zoom von Gleitkommazahlen in Prozentwerte umrechnen
  • Aktualisieren Sie die Platzhaltersyntax: [page] → {page}, [topage] → {total-pages}
  • Ersetzen Sie File.WriteAllBytes() durch pdf.SaveAs()
  • Synchrone Aufrufe gegebenenfalls in asynchrone Aufrufe umwandeln.

Nach der Migration

  • Entfernen Sie die wkhtmltopdf-Binärdateien aus dem Projekt/Bereitstellungsbereich.
  • Docker-Dateien aktualisieren, um die wkhtmltopdf-Installation zu entfernen
  • Führen Sie Regressionstests durch, um die PDF-Ausgabe zu vergleichen.
  • Überprüfen Sie, ob die Platzhalter für Kopf- und Fußzeilen korrekt dargestellt werden.
  • Test auf allen Zielplattformen (Windows, Linux, macOS)
  • CI/CD-Pipeline aktualisieren, um die wkhtmltopdf-Schritte zu entfernen
  • Sicherheitsüberprüfung aktualisieren, um die Entfernung von CVEs zu bestätigen

Hinweis:NReco und wkhtmltopdf sind eingetragene Marken ihrer jeweiligen Eigentümer. Diese Website ist weder mit NReco noch mit wkhtmltopdf verbunden, genehmigt oder gesponsert. Alle Produktnamen, Logos und Marken sind Eigentum ihrer jeweiligen Eigentümer. Vergleiche dienen nur zu Informationszwecken und spiegeln öffentlich zugängliche Informationen zum Zeitpunkt des Schreibens wider.

Curtis Chau
Curtis Chau
  Jetzt mit dem Ingenieurteam chatten
Technischer Autor

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen

Iron-Support-Team

Wir sind 24 Stunden am Tag, 5 Tage die Woche online.
Chat
E-Mail
Rufen Sie mich an