Die C# PDF-Bibliothek

HTML zu PDF

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >Install-Package IronPdf

Install-Package IronPdf

VIDEOS

Wie man RTF in PDF mit C# konvertiert

Curtis Chau

Updated: 19. Juli 2026

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

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.
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
Externe Binärabhängigkeit: Erfordert die Verwaltung von wkhtmltopdf-Binärdateien pro Plattform (wkhtmltopdf.exe, wkhtmltox.dll).
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.
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

.NET -Umgebung: .NET Framework 4.6.2+ oder .NET Core 3.1+ / .NET 5/6/7/8/9+
NuGet -Zugriff: Möglichkeit zur Installation von NuGet -Paketen
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"

' Add at application startup (Program.vb or Startup.vb)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

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

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

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

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

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

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

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

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

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

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

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

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

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)

' NReco PDF Generator: Zoom = 0.9F (90%)
' IronPDF: Zoom = 90

' Conversion formula:
Dim ironPdfZoom As Integer = CInt(nrecoZoom * 100)

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
}

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
}

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

' 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

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

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

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

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

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

' NReco PDF Generator
Dim converter As New HtmlToPdfConverter()

' IronPDF
Dim renderer As New ChromePdfRenderer()

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

' NReco PDF Generator
Dim pdfBytes As Byte() = converter.GeneratePdf(html)

' IronPDF
Dim pdfBytes As Byte() = renderer.RenderHtmlAsPdf(html).BinaryData

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

' 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

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
}

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
}

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

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 Handbücher.

...