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 umhüllt die veraltete wkhtmltopdf-Binärdatei und erbt alle ihre Sicherheitslücken. Dies ist kein theoretisches Problem - es gibt mehr als 20 dokumentierte CVEs, für die keine Patches verfügbar sind, seit wkhtmltopdf im Jahr 2020 aufgegeben wurde:

  • CVE-2020-21365: Serverseitige Anforderungsfälschung (SSRF)
  • CVE-2022-35583: Lokale Datei durch HTML-Injection auslesen
  • CVE-2022-35580: Potenzial zur Remotecodeausführung

Diese Schwachstellen können nicht gepatcht werden, da das zugrunde liegende wkhtmltopdf-Projekt nicht mehr gepflegt wird.

Zusätzliche NReco PDF GeneratorEinschränkungen

  1. Kostenlose Version mit Wasserzeichen: Für die Nutzung in der Produktion ist eine kostenpflichtige Lizenz mit intransparenter Preisgestaltung erforderlich, für die der Vertrieb kontaktiert werden muss.

  2. Veraltete Rendering-Engine: WebKit Qt (ca. 2012) bietet nur eingeschränkte Unterstützung für moderne Webanwendungen:

    • 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. Keine aktive Entwicklung: Der Wrapper wird gewartet, ohne dass die zugrundeliegende Engine aktualisiert wird.

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

NReco PDF Generatorvs IronPDFVergleich

Aspekt NReco PDF Generator IronPDF
Rendering-Engine WebKit Qt (2012) Chromium (aktuell)
Sicherheit 20+ CVEs, keine Patches 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 Undurchsichtige Preise, Kontakt zum Vertrieb Transparente Preisgestaltung
Kostenlose Testversion Mit Wasserzeichen Volle Funktionalität

Für Teams, die die Einführung von .NET 10 und C# 14 bis 2025 und 2026 planen, bietet IronPDF eine zukunftssichere Grundlage mit aktiver Entwicklung und modernen Rendering-Funktionen.

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

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 NReco PDF Generatorgibt mit HtmlToPdfConverter.GeneratePdf() einen byte[] zurück, den Sie manuell mit File.WriteAllBytes() auf die Festplatte schreiben müssen. IronPDF's 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). Falls Sie die Rohbytes zur 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

Der NReco PDF Generatorverwendet numerische Dimensionen (PageWidth = 210, PageHeight = 297) und ein PageMargins Objekt.IronPDF verwendet die Aufzählung PdfPaperSize (die Standardgrößen wie A4, Letter und Legal umfasst) und individuelle Randeigenschaften des Objekts RenderingOptions.

Die wichtigsten Migrationsänderungen:

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

Für benutzerdefinierte Papierformate, die nicht durch die Aufzählung 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

Der NReco PDF Generatorverwendet die verwirrend benannte Methode GeneratePdfFromFile() sowohl für lokale Dateien als auch für URLs, wobei der zweite Parameter optional ist.IronPDF bietet spezielle Methoden: RenderUrlAsPdf() für URLs und RenderHtmlFileAsPdf() für lokale HTML-Dateien.

Der IronPDFAnsatz ist sauberer und intuitiver. Verwenden Sie für asynchrone Webanwendungen await renderer.RenderUrlAsPdfAsync(url), um blockierende Threads zu vermeiden – etwas, das der NReco PDF Generatornicht leisten 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. IronPDF s 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 aber PdfDocument.

Lösung: Zugriff auf die Eigenschaft .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

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 IronPDFPlatzhaltersyntax:

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

  • Alle NReco.PdfGenerator-Verwendungen im Quellcode erfassen
  • 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
  • Namespace-Importe von using NReco.PdfGenerator; auf using IronPdf; aktualisieren

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)
  • Konvertiere das PageMargins-Objekt in einzelne Randeigenschaften
  • Zoom von Gleitkommazahlen in Prozentwerte umrechnen
  • Aktualisierung der 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
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