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
Veröffentlicht:

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: 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 der 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 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-Zugriff: Möglichkeit zur Installation von NuGet-Paketen
  3. IronPDF-Lizenz: Ihren Lizenzschlüssel erhalten Sie auf 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";
$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

Zuordnungen von Rendering-Methoden

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

Randzuordnungen

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);
    }
}
$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");
    }
}
$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);
    }
}
$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");
    }
}
$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);
    }
}
$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");
    }
}
$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);
$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
};
$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;
$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;
}
$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;
}
$vbLabelText   $csharpLabel

Fehlerbehebung

Ausgabe 1: HtmlToPdfConverter nicht gefunden

Problem: Die Klasse HtmlToPdfConverterexistiert inIronPDFnicht.

Lösung: ChromePdfRendererverwenden:

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

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

// IronPDF
var renderer = new ChromePdfRenderer();
$vbLabelText   $csharpLabel

Problem 2: GeneratePdf liefert den falschen Typ

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

Lösung: Zugriff auf .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;
$vbLabelText   $csharpLabel

Ausgabe 3: PageMargins Objekt nicht gefunden

Problem: Die Klasse Seitenränderexistiert inIronPDFnicht.

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;
$vbLabelText   $csharpLabel

Problem 4: Nicht angezeigte Seitenzahlen

Problem: Die Platzhalter [Seite]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
};
$vbLabelText   $csharpLabel

Migrations-Checkliste

Vor der Migration

  • Alle Verwendungen NReco.PdfGenerator im Quellcode erfassen
  • Dokumentieren Sie alle Werte CustomWkHtmlArgs und CustomWkHtmlPageArgs
  • Liste alle Header-/Footer-HTML-Vorlagen mit Platzhaltern auf
  • 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 IronPdf NuGet-Paket: dotnet add package IronPdf
  • Namespace-Importe von using NReco.PdfGenerator; auf using IronPdf;

Code-Änderungen

  • Lizenzschlüsselkonfiguration beim Start hinzufügen
  • Ersetzen Sie HtmlToPdfConverterdurch ChromePdfRenderer
  • Ersetzen Sie GeneratePdf(html)durch RenderHtmlAsPdf(html)
  • Ersetzen Sie GeneratePdfFromFile(url, null) durch RenderUrlAsPdf(url)
  • Konvertiere SeitenränderObjekt in einzelne Randeigenschaften
  • Zoomwerte von Gleitkommazahlen in Prozentwerte umrechnen
  • Aktualisierung der Platzhaltersyntax: [Seite]→ {Seite}, [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