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:

Migrieren Sie von NReco PDF Generatorzu IronPDF: Vollständige C#-Migrationsanleitung

Die Migration von NReco PDF GeneratorzuIronPDFbeseitigt kritische Sicherheitslücken, die von wkhtmltopdf geerbt wurden, während Ihr .NET-PDF-Workflow von einer veralteten WebKit Qt-Engine (ca. 2012) auf einen modernen Chromium-basierten Renderer mit vollständiger CSS3- und JavaScript-Unterstützung aktualisiert wird. Dieser Leitfaden bietet einen umfassenden, schrittweisen Migrationspfad, der sowohl die Sicherheitsbedenken als auch die Rendering-Einschränkungen von NReco PDF Generatorberücksichtigt.

Warum von NReco PDF GeneratorzuIronPDFmigrieren

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: Server-seitige Anforderungsfälschung (SSRF)
  • CVE-2022-35583: Lokale Datei über HTML-Injection lesen
  • CVE-2022-35580: Potenzial zur Ausführung von Remotecode

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

Zusätzliche NReco PDF GeneratorEinschränkungen

  1. Freie Version mit Wasserzeichen: Für die produktive Nutzung ist eine kostenpflichtige Lizenz mit undurchsichtiger Preisgestaltung erforderlich, die eine Kontaktaufnahme mit dem Vertrieb erfordert.

  2. Veraltete Rendering Engine: WebKit Qt (ca. 2012) bietet nur begrenzte moderne Webunterstü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. Keine aktive Entwicklung: Der Wrapper wird gewartet, ohne dass die zugrunde liegende Engine aktualisiert wird.

  5. Limited Async Support: Synchronous API blockiert Threads in Webanwendungen.

NReco PDF GeneratorvsIronPDFVergleich

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, bietetIronPDFeine 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 Access: Fähigkeit, NuGet-Pakete zu installieren
  3. IronPDF Lizenz: Beziehen Sie Ihren Lizenzschlüssel von ironPdf.com

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";
IRON VB CONVERTER ERROR developers@ironsoftware.com
$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 Notizen
HtmlToPdfConverter ChromePdfRenderer Haupt-Renderer
Seitenränder Einzelne Randeigenschaften MarginTop, MarginBottom, etc.
Seitenausrichtung PdfPaperOrientierung Enum
Seitengröße PdfPaperSize Enum

Rendering Method Mappings

NReco PDF Generator IronPDF Notizen
GeneratePdf(html) RenderHtmlAsPdf(html) Liefert PdfDocument
GeneratePdfFromFile(url, output) RenderUrlAsPdf(url) Direkte URL-Unterstützung
GeneratePdfFromFile(htmlPath, output) RenderHtmlFileAsPdf(path) Dateipfad
(async nicht unterstützt) RenderHtmlAsPdfAsync(html) Asynchrone Version
(async nicht unterstützt) RenderUrlAsPdfAsync(url) Asynchrone Version

Zuordnungen der Seitenkonfiguration

NReco PDF Generator IronPDF Notizen
Seitenbreite = 210 RenderingOptions.PaperSize = PdfPaperSize.A4 Enumoder SetCustomPaperSize verwenden
Seitenhöhe = 297 RenderingOptions.SetCustomPaperSizeinMilimeters(w, h) Benutzerdefinierte Größe
Orientation = PageOrientation.Landscape RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape Landschaft
Größe = PageSize.A4 RenderingOptions.PaperSize = PdfPaperSize.A4 Papierformat enum

Margin Mappings

NReco PDF Generator IronPDF Notizen
Margins.Top = 10 RenderingOptions.MarginTop = 10 In Millimetern
Margins.Bottom = 10 RenderingOptions.MarginBottom = 10 In Millimetern
Margins.Left = 10 RenderingOptions.MarginLeft = 10 In Millimetern
Margins.Right = 10 RenderingOptions.MarginRight = 10 In Millimetern
new PageMargins { ... } Einzelne Eigenschaften Objekt ohne Ränder

Kopf-/Fußzeilen-Platzhalter-Zuordnungen

NReco PDF Generator(wkhtmltopdf) IronPDF Notizen
[Seite] {Seite} Aktuelle Seitenzahl
[topage] {Gesamtseiten} Gesamtseitenzahl
[Datum] {Datum} Aktuelles Datum
[Zeit] {Zeit} Aktuelle Zeit
[Titel] {html-title} Titel des Dokuments

Zuordnungen für die Ausgabeverarbeitung

NReco PDF Generator IronPDF Notizen
byte[] pdfBytes = GeneratePdf(html) PdfDocument pdf = RenderHtmlAsPdf(html) Liefert ein Objekt
File.WriteAllBytes(Pfad, Bytes) pdf.SaveAs(Pfad) Direkt speichern
Rückgabe pdfBytes Rückgabe pdf.BinaryData Byte-Array abrufen
new MemoryStream(pdfBytes) pdf.Stream Stream erhalten

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);
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$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");
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Der grundlegende Unterschied liegt im Rückgabetyp und im Speichermuster. NReco PDF Generator's HtmlToPdfConverter.GeneratePdf() liefert ein Byte[], das Sie manuell mit File.WriteAllBytes() auf die Festplatte schreiben müssen. IronPDF's ChromePdfRenderer.RenderHtmlAsPdf() gibt ein PdfDocument Objekt mit einer integrierten 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);
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$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");
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

NReco PDF Generator verwendet numerische Dimensionen (PageWidth = 210, PageHeight = 297) und ein SeitenränderObjekt.IronPDFverwendet die Aufzählung PdfPaperSize(die Standardgrößen wie A4, Letter, Legal umfasst) und individuelle Randeigenschaften für das RenderingOptions-Objekt.

Die wichtigsten Migrationsänderungen:

  • Seitenbreite/Seitenhöhe → RenderingOptions.PaperSize = PdfPaperSize.A4
  • new PageMargins { Top = 10, ... }→ Einzelne Eigenschaften: RenderingOptions.MarginTop = 10

Für benutzerdefinierte Papiergrößen, die nicht von der 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);
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$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");
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

NReco PDF Generator verwendet die verwirrend benannte GeneratePdfFromFile()-Methode sowohl für lokale Dateien als auch für URLs, mit einem nullbaren zweiten Parameter.IronPDFbietet spezielle Methoden: RenderUrlAsPdf() für URLs und RenderHtmlFileAsPdf() für lokale HTML-Dateien.

Der Ansatz vonIronPDFist 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ährendIronPDFprozentuale 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);
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Aktualisierung der Platzhalter-Syntax

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

NReco PDF Generator IronPDF
[Seite] {Seite}
[topage] {Gesamtseiten}
[Datum] {Datum}
[Titel] {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
};
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Rückgabetyp ändern

NReco PDF Generator gibt Byte[] direkt zurück;IronPDFliefert 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;
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Thread-Sicherheit und Wiederverwendbarkeit

NReco PDF Generator erstellt in der Regel einen neuen Konverter pro Aufruf. Der ChromePdfRenderervonIronPDFist thread-sicher und kann wiederverwendet werden:

// 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;
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$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;
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Fehlerbehebung

Ausgabe 1: HtmlToPdfConverter nicht gefunden

Problem: die Klasse HtmlToPdfConverterist inIronPDFnicht vorhanden.

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();
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Problem 2: GeneratePdf liefert den falschen Typ

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

Lösung: Zugriff auf die .BinaryData-Eigenschaft:

// 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;
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Ausgabe 3: PageMargins Objekt nicht gefunden

Problem: SeitenränderKlasse 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;
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Problem 4: Nicht angezeigte Seitenzahlen

Problem: [Seite]und [topage]Platzhalter 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
};
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Migrations-Checkliste

Vor der Migration

  • [Inventarisierung aller Verwendungen von NReco.PdfGenerator in der Codebasis
  • [Dokumentieren Sie alle CustomWkHtmlArgs und CustomWkHtmlPageArgs Werte
  • [Alle Kopf-/Fußzeilen-HTML-Vorlagen mit Platzhaltern auflisten
  • [Identifizieren Sie asynchrone Anforderungen (Webcontroller, Dienste)
  • [Überprüfung der Zoom- und Randeinstellungen
  • [Sicherung vorhandener PDF-Ausgaben zum Vergleich
  • [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 aktualisieren von Verwendung von NReco.PdfGenerator; nach Verwendung von IronPdf;

Code-Änderungen

  • [Lizenzschlüsselkonfiguration beim Starten hinzufügen
  • [Ersetzen Sie HtmlToPdfConvertermit ChromePdfRenderer
  • [Ersetzen Sie GeneratePdf(html)durch RenderHtmlAsPdf(html)
  • [Ersetzen Sie GeneratePdfFromFile(url, null) durch RenderUrlAsPdf(url)
  • [Das PageMargins-Objekt in einzelne Randeigenschaften umwandeln
  • [Zoomwerte von Float auf Prozent aktualisieren
  • [Aktualisieren Sie die Syntax der Platzhalter: [Seite]→ {page}, [topage]→ {total-pages}
  • [Ersetzen Sie File.WriteAllBytes() durch pdf.SaveAs()
  • [Sync-Aufrufe in async umwandeln, wo es sinnvoll ist

Post-Migration

  • [wkhtmltopdf-Binärdateien aus Projekt/Einsatz entfernen
  • [Docker-Dateien aktualisieren, um die wkhtmltopdf-Installation zu entfernen
  • [Regressionstests durchführen und PDF-Ausgabe vergleichen
  • [Überprüfen Sie die korrekte Darstellung von Kopf- und Fußzeilen-Platzhaltern
  • [Test auf allen Zielplattformen (Windows, Linux, macOS)
  • [CI/CD-Pipeline aktualisieren, um wkhtmltopdf-Schritte zu entfernen
  • [Sicherheitsüberprüfung aktualisieren, um die Entfernung von CVEs zu bestätigen

Abschluss

Durch die Migration von NReco PDF GeneratorzuIronPDFwerden kritische Sicherheitslücken geschlossen und gleichzeitig die Rendering-Engine von einem veralteten WebKit Qt aus dem Jahr 2012 auf eine moderne Chromium-basierte Lösung umgestellt. Die Migration beseitigt mehr als 20 CVEs, die nicht gepatcht werden können, fügt vollständige CSS3- und ES6+-JavaScript-Unterstützung hinzu, entfernt externe Binärabhängigkeiten und ermöglicht async/await-Muster für eine bessere Leistung von Webanwendungen.

Die wichtigsten Änderungen bei dieser Migration sind:

  1. Sicherheit: 20+ CVEs beseitigt → Aktive Sicherheitsupdates
  2. Rendering: WebKit Qt (2012)→ Chromium (aktuell)
  3. Abhängigkeiten: Extern wkhtmltopdf → Eigenständig
  4. Async: Nur synchron → Voll async/await
  5. Klasse: HtmlToPdfConverter→ ChromePdfRenderer
  6. Margins: SeitenränderObjekt → Einzelne Eigenschaften
  7. Platzhalter: [Seite]/[Oberseite] → {Seite}/{Gesamtseiten}

Nutzen Sie die vollständige IronPDF-Dokumentation, Tutorials und API-Referenz, um Ihre Migration zu NReco PDF Generatorzu beschleunigen.

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