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 DOCX in PDF mit C# konvertiert

Curtis Chau

Updated: 18. Mai 2026

Haukcode.DinkToPdf ist ein Community-Fork der einst populären DinkToPdf-Bibliothek, die das wkhtmltopdf-Binary umhüllt, um HTML in PDF for .NET-Anwendungen umzuwandeln. Der Fork wurde später in Haukcode.WkHtmlToPdfDotNet umbenannt, mit der neuesten Veröffentlichung 1.5.95, die am 22. Oktober 2024 unter LGPL-3.0-or-later veröffentlicht wurde. Während der Fork das Paket nach der Aufgabe des ursprünglichen DinkToPdf (1.0.8, 18. April 2017) auf NuGet am Leben gehalten hat, bindet es immer noch an dieselbe archivierte wkhtmltopdf-Binärdatei wie sein Elternteil. Das wkhtmltopdf/wkhtmltopdf Repository wurde am 2. Januar 2023 archiviert, und die gesamte wkhtmltopdf GitHub-Organisation wurde am 10. Juli 2024 archiviert, sodass keine upstream-Probleme behoben werden.

Dieses Handbuch bietet einen Migrationspfad von Haukcode.DinkToPdf / Haukcode.WkHtmlToPdfDotNet zu IronPDF, einschließlich Schritt-für-Schritt-Anleitungen, Code-Vergleichen und praktischen Beispielen for .NET-Entwickler, die von der archivierten wkhtmltopdf-Binärdatei weggehen möchten.

Sicherheitsberatung: CVE-2022-35583

Haukcode.DinkToPdf erbt eine Sicherheitsberatung gegen sein vorgelagertes wkhtmltopdf-Binary:

CVE-2022-35583 — SSRF-Beratung gegen wkhtmltopdf 0.12.6

Eine Beratung zu Server Side Request Forgery wurde gegen wkhtmltopdf 0.12.6 veröffentlicht (CVSS 9.8 in NVD; angefochten vom Upstream wkhtmltopdf-Projekt, das es als Problem der Anwendungseingabesanitisierung und nicht als Bibliotheksfehler betrachtet). Wie dem auch sei, es wird nicht gepatcht — Upstream ist archiviert. Typische Belichtungsmuster, die in öffentlichen Diskussionen gekennzeichnet werden, umfassen:

Angriffsvektor: Unvertrauenswürdiger HTML-Inhalt kann dazu führen, dass der Renderer während der Umwandlung interne Ressourcen abruft
AWS Metadaten: Anfragen an http://169.254.169.254 können Instanzmetadaten zurückgeben, wenn der Renderer auf EC2 läuft
Interner Netzwerkzugang: Interne Dienste können vom Rendering-Host aus erreichbar sein
Lokale Dateieinbindung: Lokale Dateien können über das file:// Protokoll lesbar sein

Es wird kein Upstream-Patch erwartet — das wkhtmltopdf-Repository wurde am 2. Januar 2023 archiviert, und die letzte Veröffentlichung (0.12.6) war im Juni 2020.

##IronPDF vs. Haukcode.DinkToPdf: Funktionsvergleich

Das Verständnis der architektonischen Unterschiede hilft technischen Entscheidungsträgern, die Investition in die Migration zu bewerten:

Aspekt	Haukcode.DinkToPdf	IronPDF
Unterliegende Engine	wkhtmltopdf (QtWebKit-Abspaltung, ca. 2015)	Modernes Chromium
Sicherheitsstatus	CVE-2022-35583-Beratung (ungepatcht/strittig von Upstream)	Keine bekannten kritischen CVEs
Projektstatus	Community-Fork; upstream wkhtmltopdf archiviert	Aktiv gepflegt
HTML5/CSS3	Kein modernes Flexbox/Grid	Vollständig CSS3
JavaScript	Begrenzt, inkonsistent	Volle Unterstützung
Native Binärdateien	`libwkhtmltox.dll/.so/.dylib` pro Plattform	Verwaltetes NuGet-Paket
Thread-Sicherheit	`SynchronizedConverter` serialisiert Aufrufe	Thread-sicher durch Design
Unterstützung	Gemeinschaft	Professionelle Unterstützung
Aktualisierungen	Fork letzte Veröffentlichung 1.5.95 (22. Okt 2024); upstream wkhtmltopdf 0.12.6 (Jun 2020)	Regelmäßige Veröffentlichungen
Lizenz	LGPL-3.0-oder-später (Fork) / MIT (ursprüngliches DinkToPdf)	Kommerziell mit kostenloser Testversion

Schnellstart: Haukcode.DinkToPdf zu IronPDF Migration

Mit diesen grundlegenden Schritten kann die Migration sofort beginnen.

Schritt 1: Entfernen von DinkToPdf und nativen Binärdateien

Haukcode.DinkToPdf NuGet-Pakete entfernen:

# Remove NuGet packages
dotnet remove package DinkToPdf
dotnet remove package Haukcode.DinkToPdf
dotnet remove package Haukcode.WkHtmlToPdf-DotNet

# Remove NuGet packages
dotnet remove package DinkToPdf
dotnet remove package Haukcode.DinkToPdf
dotnet remove package Haukcode.WkHtmlToPdf-DotNet

SHELL

Löschen Sie native Binärdateien aus Ihrem Projekt:

libwkhtmltox.dll (Windows)
libwkhtmltox.so (Linux)
libwkhtmltox.dylib (macOS)

Schritt 2:IronPDF installieren

# Install IronPDF
dotnet add package IronPdf

# Install IronPDF
dotnet add package IronPdf

SHELL

Schritt 3: Namespaces aktualisieren

Ersetzen Sie die Namensräume von DinkToPdf durch IronPDF:

// Before (Haukcode.DinkToPdf)
using DinkToPdf;
using DinkToPdf.Contracts;

// After (IronPDF)
using IronPdf;
using IronPdf.Rendering;  // For RenderingOptions

// Before (Haukcode.DinkToPdf)
using DinkToPdf;
using DinkToPdf.Contracts;

// After (IronPDF)
using IronPdf;
using IronPdf.Rendering;  // For RenderingOptions

Imports IronPdf
Imports IronPdf.Rendering

Imports IronPdf
Imports IronPdf.Rendering

Schritt 4: Lizenz initialisieren

Hinzufügen der Lizenzinitialisierung beim Start der Anwendung:

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

Beispiele für die Code-Migration

Basiskonvertierung von HTML in PDF

Der grundlegendste Vorgang offenbart den Komplexitätsunterschied zwischen diesen .NET-PDF-Bibliotheken.

Haukcode.DinkToPdf Ansatz:

// NuGet: Install-Package DinkToPdf
using DinkToPdf;
using DinkToPdf.Contracts;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new SynchronizedConverter(new PdfTools());
        
        var doc = new HtmlToPdfDocument()
        {
            GlobalSettings = {
                ColorMode = ColorMode.Color,
                Orientation = Orientation.Portrait,
                PaperSize = PaperKind.A4,
            },
            Objects = {
                new ObjectSettings() {
                    HtmlContent = "<html><body><h1>Hello World</h1></body></html>",
                }
            }
        };
        
        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("output.pdf", pdf);
    }
}

// NuGet: Install-Package DinkToPdf
using DinkToPdf;
using DinkToPdf.Contracts;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new SynchronizedConverter(new PdfTools());
        
        var doc = new HtmlToPdfDocument()
        {
            GlobalSettings = {
                ColorMode = ColorMode.Color,
                Orientation = Orientation.Portrait,
                PaperSize = PaperKind.A4,
            },
            Objects = {
                new ObjectSettings() {
                    HtmlContent = "<html><body><h1>Hello World</h1></body></html>",
                }
            }
        };
        
        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("output.pdf", pdf);
    }
}

' NuGet: Install-Package DinkToPdf
Imports DinkToPdf
Imports DinkToPdf.Contracts
Imports System.IO

Class Program
    Shared Sub Main()
        Dim converter = New SynchronizedConverter(New PdfTools())

        Dim doc = New HtmlToPdfDocument() With {
            .GlobalSettings = New GlobalSettings() With {
                .ColorMode = ColorMode.Color,
                .Orientation = Orientation.Portrait,
                .PaperSize = PaperKind.A4
            },
            .Objects = New ObjectSettings() {
                New ObjectSettings() With {
                    .HtmlContent = "<html><body><h1>Hello World</h1></body></html>"
                }
            }
        }

        Dim pdf As Byte() = converter.Convert(doc)
        File.WriteAllBytes("output.pdf", pdf)
    End Sub
End Class

' NuGet: Install-Package DinkToPdf
Imports DinkToPdf
Imports DinkToPdf.Contracts
Imports System.IO

Class Program
    Shared Sub Main()
        Dim converter = New SynchronizedConverter(New PdfTools())

        Dim doc = New HtmlToPdfDocument() With {
            .GlobalSettings = New GlobalSettings() With {
                .ColorMode = ColorMode.Color,
                .Orientation = Orientation.Portrait,
                .PaperSize = PaperKind.A4
            },
            .Objects = New ObjectSettings() {
                New ObjectSettings() With {
                    .HtmlContent = "<html><body><h1>Hello World</h1></body></html>"
                }
            }
        }

        Dim pdf As Byte() = converter.Convert(doc)
        File.WriteAllBytes("output.pdf", pdf)
    End Sub
End Class

IronPDF-Ansatz:

// NuGet: Install-Package IronPdf
using IronPdf;
using System.IO;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        
        var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1></body></html>");
        
        pdf.SaveAs("output.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using System.IO;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        
        var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1></body></html>");
        
        pdf.SaveAs("output.pdf");
    }
}

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports System.IO

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()

        Dim pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1></body></html>")

        pdf.SaveAs("output.pdf")
    End Sub
End Module

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports System.IO

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()

        Dim pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1></body></html>")

        pdf.SaveAs("output.pdf")
    End Sub
End Module

Haukcode.DinkToPdf erfordert die Erstellung eines SynchronizedConverter mit PdfTools, das Erstellen eines HtmlToPdfDocument mit verschachtelten GlobalSettings und Objects, das Hinzufügen eines ObjectSettings mit HtmlContent, den Aufruf von converter.Convert(), um rohe Bytes zu erhalten, und das manuelle Schreiben in eine Datei mit File.WriteAllBytes().

IronPDF vereinfacht dies auf drei Zeilen: erstellen Sie ein ChromePdfRenderer, rufen Sie RenderHtmlAsPdf() auf und verwenden Sie die integrierte SaveAs() Methode.

Für fortgeschrittene HTML-zu-PDF-Szenarien siehe den HTML-zu-PDF-Konvertierungsleitfaden.

Konvertierung von URLs zu PDF

Die URL-zu-PDF-Konvertierung weist ähnliche Musterunterschiede auf.

Haukcode.DinkToPdf Ansatz:

// NuGet: Install-Package DinkToPdf
using DinkToPdf;
using DinkToPdf.Contracts;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new SynchronizedConverter(new PdfTools());
        
        var doc = new HtmlToPdfDocument()
        {
            GlobalSettings = {
                ColorMode = ColorMode.Color,
                Orientation = Orientation.Portrait,
                PaperSize = PaperKind.A4,
            },
            Objects = {
                new ObjectSettings() {
                    Page = "https://www.example.com",
                }
            }
        };
        
        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("webpage.pdf", pdf);
    }
}

// NuGet: Install-Package DinkToPdf
using DinkToPdf;
using DinkToPdf.Contracts;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new SynchronizedConverter(new PdfTools());
        
        var doc = new HtmlToPdfDocument()
        {
            GlobalSettings = {
                ColorMode = ColorMode.Color,
                Orientation = Orientation.Portrait,
                PaperSize = PaperKind.A4,
            },
            Objects = {
                new ObjectSettings() {
                    Page = "https://www.example.com",
                }
            }
        };
        
        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("webpage.pdf", pdf);
    }
}

' NuGet: Install-Package DinkToPdf
Imports DinkToPdf
Imports DinkToPdf.Contracts
Imports System.IO

Module Program
    Sub Main()
        Dim converter As New SynchronizedConverter(New PdfTools())

        Dim doc As New HtmlToPdfDocument() With {
            .GlobalSettings = New GlobalSettings() With {
                .ColorMode = ColorMode.Color,
                .Orientation = Orientation.Portrait,
                .PaperSize = PaperKind.A4
            },
            .Objects = New List(Of ObjectSettings) From {
                New ObjectSettings() With {
                    .Page = "https://www.example.com"
                }
            }
        }

        Dim pdf As Byte() = converter.Convert(doc)
        File.WriteAllBytes("webpage.pdf", pdf)
    End Sub
End Module

' NuGet: Install-Package DinkToPdf
Imports DinkToPdf
Imports DinkToPdf.Contracts
Imports System.IO

Module Program
    Sub Main()
        Dim converter As New SynchronizedConverter(New PdfTools())

        Dim doc As New HtmlToPdfDocument() With {
            .GlobalSettings = New GlobalSettings() With {
                .ColorMode = ColorMode.Color,
                .Orientation = Orientation.Portrait,
                .PaperSize = PaperKind.A4
            },
            .Objects = New List(Of ObjectSettings) From {
                New ObjectSettings() With {
                    .Page = "https://www.example.com"
                }
            }
        }

        Dim pdf As Byte() = converter.Convert(doc)
        File.WriteAllBytes("webpage.pdf", pdf)
    End Sub
End Module

IronPDF-Ansatz:

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

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;
using System;

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
Imports IronPdf
Imports System

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()

        Dim pdf = renderer.RenderUrlAsPdf("https://www.example.com")

        pdf.SaveAs("webpage.pdf")
    End Sub
End Module

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports System

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()

        Dim pdf = renderer.RenderUrlAsPdf("https://www.example.com")

        pdf.SaveAs("webpage.pdf")
    End Sub
End Module

Haukcode.DinkToPdf verwendet dasselbe Dokumentkonstruktionsmuster mit ObjectSettings.Page für URLs.IronPDF bietet eine dedizierte RenderUrlAsPdf() Methode, die den Zweck klar ausdrückt.

In der URL zur PDF-Dokumentation finden Sie Informationen zur Authentifizierung und zu benutzerdefinierten Kopfzeilenoptionen.

Benutzerdefinierte Seiteneinstellungen

Die Konfiguration von Ausrichtung, Papiergröße und Rändern erfordert unterschiedliche Ansätze.

Haukcode.DinkToPdf Ansatz:

// NuGet: Install-Package DinkToPdf
using DinkToPdf;
using DinkToPdf.Contracts;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new SynchronizedConverter(new PdfTools());
        
        var doc = new HtmlToPdfDocument()
        {
            GlobalSettings = {
                ColorMode = ColorMode.Color,
                Orientation = Orientation.Landscape,
                PaperSize = PaperKind.Letter,
                Margins = new MarginSettings() { Top = 10, Bottom = 10, Left = 10, Right = 10 }
            },
            Objects = {
                new ObjectSettings() {
                    HtmlContent = "<html><body><h1>Landscape Document</h1><p>Custom page settings</p></body></html>",
                }
            }
        };
        
        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("landscape.pdf", pdf);
    }
}

// NuGet: Install-Package DinkToPdf
using DinkToPdf;
using DinkToPdf.Contracts;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new SynchronizedConverter(new PdfTools());
        
        var doc = new HtmlToPdfDocument()
        {
            GlobalSettings = {
                ColorMode = ColorMode.Color,
                Orientation = Orientation.Landscape,
                PaperSize = PaperKind.Letter,
                Margins = new MarginSettings() { Top = 10, Bottom = 10, Left = 10, Right = 10 }
            },
            Objects = {
                new ObjectSettings() {
                    HtmlContent = "<html><body><h1>Landscape Document</h1><p>Custom page settings</p></body></html>",
                }
            }
        };
        
        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("landscape.pdf", pdf);
    }
}

' NuGet: Install-Package DinkToPdf
Imports DinkToPdf
Imports DinkToPdf.Contracts
Imports System.IO

Module Program
    Sub Main()
        Dim converter As New SynchronizedConverter(New PdfTools())

        Dim doc As New HtmlToPdfDocument() With {
            .GlobalSettings = New GlobalSettings() With {
                .ColorMode = ColorMode.Color,
                .Orientation = Orientation.Landscape,
                .PaperSize = PaperKind.Letter,
                .Margins = New MarginSettings() With {.Top = 10, .Bottom = 10, .Left = 10, .Right = 10}
            },
            .Objects = {New ObjectSettings() With {
                .HtmlContent = "<html><body><h1>Landscape Document</h1><p>Custom page settings</p></body></html>"
            }}
        }

        Dim pdf As Byte() = converter.Convert(doc)
        File.WriteAllBytes("landscape.pdf", pdf)
    End Sub
End Module

' NuGet: Install-Package DinkToPdf
Imports DinkToPdf
Imports DinkToPdf.Contracts
Imports System.IO

Module Program
    Sub Main()
        Dim converter As New SynchronizedConverter(New PdfTools())

        Dim doc As New HtmlToPdfDocument() With {
            .GlobalSettings = New GlobalSettings() With {
                .ColorMode = ColorMode.Color,
                .Orientation = Orientation.Landscape,
                .PaperSize = PaperKind.Letter,
                .Margins = New MarginSettings() With {.Top = 10, .Bottom = 10, .Left = 10, .Right = 10}
            },
            .Objects = {New ObjectSettings() With {
                .HtmlContent = "<html><body><h1>Landscape Document</h1><p>Custom page settings</p></body></html>"
            }}
        }

        Dim pdf As Byte() = converter.Convert(doc)
        File.WriteAllBytes("landscape.pdf", pdf)
    End Sub
End Module

IronPDF-Ansatz:

// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        
        renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.MarginTop = 10;
        renderer.RenderingOptions.MarginBottom = 10;
        renderer.RenderingOptions.MarginLeft = 10;
        renderer.RenderingOptions.MarginRight = 10;
        
        var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Landscape Document</h1><p>Custom page settings</p></body></html>");
        
        pdf.SaveAs("landscape.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        
        renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.MarginTop = 10;
        renderer.RenderingOptions.MarginBottom = 10;
        renderer.RenderingOptions.MarginLeft = 10;
        renderer.RenderingOptions.MarginRight = 10;
        
        var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Landscape Document</h1><p>Custom page settings</p></body></html>");
        
        pdf.SaveAs("landscape.pdf");
    }
}

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports IronPdf.Rendering

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()

        renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape
        renderer.RenderingOptions.MarginTop = 10
        renderer.RenderingOptions.MarginBottom = 10
        renderer.RenderingOptions.MarginLeft = 10
        renderer.RenderingOptions.MarginRight = 10

        Dim pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Landscape Document</h1><p>Custom page settings</p></body></html>")

        pdf.SaveAs("landscape.pdf")
    End Sub
End Module

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports IronPdf.Rendering

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()

        renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape
        renderer.RenderingOptions.MarginTop = 10
        renderer.RenderingOptions.MarginBottom = 10
        renderer.RenderingOptions.MarginLeft = 10
        renderer.RenderingOptions.MarginRight = 10

        Dim pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Landscape Document</h1><p>Custom page settings</p></body></html>")

        pdf.SaveAs("landscape.pdf")
    End Sub
End Module

Haukcode.DinkToPdf verschachtelt Einstellungen innerhalb von GlobalSettings mit einem separaten MarginSettings Objekt.IronPDF bietet direkte RenderingOptions Eigenschaften mit klaren Namen wie PaperSize, PaperOrientation und individuellen Randeigenschaften.

Haukcode.DinkToPdf API zu IronPDF Mapping Referenz

Dieses Mapping beschleunigt die Migration, indem es direkte API-Entsprechungen aufzeigt:

Konverter-Klassen-Zuordnung

Haukcode.DinkToPdf	IronPDF
`SynchronizedConverter`	`ChromePdfRenderer`
`BasicConverter`	`ChromePdfRenderer`
`PdfTools`	Nicht anwendbar
`IConverter`	Nicht anwendbar

Zuordnung der Dokumentenkonfiguration

Haukcode.DinkToPdf	IronPDF
`HtmlToPdfDocument`	Methodenaufruf
`GlobalSettings`	`RenderingOptions`
`ObjectSettings`	`RenderingOptions`
`converter.Convert(doc)`	`renderer.RenderHtmlAsPdf(html)`

GlobalSettings Eigenschaftszuordnung

GlobalSettings-Eigenschaft	IronPDF Eigenschaft
`ColorMode`	`RenderingOptions.GrayScale`
`Orientation`	`RenderingOptions.PaperOrientation`
`PaperSize`	`RenderingOptions.PaperSize`
`Margins.Top`	`RenderingOptions.MarginTop`
`Margins.Bottom`	`RenderingOptions.MarginBottom`
`Margins.Left`	`RenderingOptions.MarginLeft`
`Margins.Right`	`RenderingOptions.MarginRight`

ObjectSettings Eigenschaftszuordnung

ObjectSettings-Eigenschaft	IronPDF-Äquivalent
`HtmlContent`	Erster Parameter an `RenderHtmlAsPdf()`
`Page` (URL)	`renderer.RenderUrlAsPdf(url)`
`HeaderSettings.Right = "[page]"`	`{page}` innerhalb von `HtmlHeader.HtmlFragment`

Migration der Platzhalter-Syntax

Haukcode.DinkToPdf	IronPDF
`[page]`	`{page}`
`[toPage]`	`{total-pages}`
`[date]`	`{date}`

Gängige Migrationsprobleme und Lösungen

Ausgabe 1: Singleton-Anforderung

Haukcode.DinkToPdf: Erfordert SynchronizedConverter als Singleton aufgrund von Thread-Sicherheitsproblemen mit der nativen wkhtmltopdf-Binärdatei.

Lösung: IronPDFs ChromePdfRenderer ist von Haus aus thread-sicher—kein Singleton erforderlich:

// Before (DinkToPdf) - MUST be singleton
services.AddSingleton(typeof(IConverter), new SynchronizedConverter(new PdfTools()));

// After (IronPDF) - Can be singleton or transient (both work)
services.AddSingleton<IPdfService, IronPdfService>();
// Or services.AddTransient<IPdfService, IronPdfService>() - both are safe!

// Before (DinkToPdf) - MUST be singleton
services.AddSingleton(typeof(IConverter), new SynchronizedConverter(new PdfTools()));

// After (IronPDF) - Can be singleton or transient (both work)
services.AddSingleton<IPdfService, IronPdfService>();
// Or services.AddTransient<IPdfService, IronPdfService>() - both are safe!

' Before (DinkToPdf) - MUST be singleton
services.AddSingleton(GetType(IConverter), New SynchronizedConverter(New PdfTools()))

' After (IronPDF) - Can be singleton or transient (both work)
services.AddSingleton(Of IPdfService, IronPdfService)()
' Or services.AddTransient(Of IPdfService, IronPdfService)() - both are safe!

' Before (DinkToPdf) - MUST be singleton
services.AddSingleton(GetType(IConverter), New SynchronizedConverter(New PdfTools()))

' After (IronPDF) - Can be singleton or transient (both work)
services.AddSingleton(Of IPdfService, IronPdfService)()
' Or services.AddTransient(Of IPdfService, IronPdfService)() - both are safe!

Ausgabe 2: Native Binärabhängigkeiten

Haukcode.DinkToPdf: Erfordert plattformspezifische native Bibliotheken (libwkhtmltox.dll/so/dylib).

**Lösung:**IronPDF ist eine eigenständige Software, die keine Abhängigkeiten von nativen Binärdateien aufweist. Löschen Sie diese Dateien nach der Migration:

libwkhtmltox.dll (Windows)
libwkhtmltox.so (Linux)
libwkhtmltox.dylib (macOS)

Ausgabe 3: Unterschiede im Rückgabetyp

Haukcode.DinkToPdf: converter.Convert() gibt byte[] direkt zurück.

**Lösung:**IronPDF gibt ein PdfDocument Objekt mit mehreren Ausgabeoptionen zurück:

var pdf = renderer.RenderHtmlAsPdf(html);
byte[] bytes = pdf.BinaryData;  // Get bytes
pdf.SaveAs("output.pdf");       // Or save directly

var pdf = renderer.RenderHtmlAsPdf(html);
byte[] bytes = pdf.BinaryData;  // Get bytes
pdf.SaveAs("output.pdf");       // Or save directly

Dim pdf = renderer.RenderHtmlAsPdf(html)
Dim bytes As Byte() = pdf.BinaryData  ' Get bytes
pdf.SaveAs("output.pdf")  ' Or save directly

Dim pdf = renderer.RenderHtmlAsPdf(html)
Dim bytes As Byte() = pdf.BinaryData  ' Get bytes
pdf.SaveAs("output.pdf")  ' Or save directly

Ausgabe 4: Syntax für Kopf-/Fußzeilen-Platzhalter

Haukcode.DinkToPdf: Verwendet eckige Klammer-Syntax wie [page] und [toPage].

Lösung: Aktualisierung der Platzhalter für geschweifte Klammern in IronPDF:

// Before (DinkToPdf)
HeaderSettings = { Right = "Page [page] of [toPage]" }

// After (IronPDF)
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    HtmlFragment = "<span style='float:right'>Page {page} of {total-pages}</span>"
};

// Before (DinkToPdf)
HeaderSettings = { Right = "Page [page] of [toPage]" }

// After (IronPDF)
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    HtmlFragment = "<span style='float:right'>Page {page} of {total-pages}</span>"
};

' Before (DinkToPdf)
HeaderSettings = New With {.Right = "Page [page] of [toPage]"}

' After (IronPDF)
renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter With {
    .HtmlFragment = "<span style='float:right'>Page {page} of {total-pages}</span>"
}

' Before (DinkToPdf)
HeaderSettings = New With {.Right = "Page [page] of [toPage]"}

' After (IronPDF)
renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter With {
    .HtmlFragment = "<span style='float:right'>Page {page} of {total-pages}</span>"
}

Haukcode.DinkToPdf Migration Checkliste

Vor der Migration anfallende Aufgaben

Überprüfen Sie Ihre Codebasis, um die Verwendung von DinkToPdf zu identifizieren:

# Find DinkToPdf namespace usage
grep -r "using DinkToPdf\|using Haukcode" --include="*.cs" .

# Find converter usage
grep -r "SynchronizedConverter\|BasicConverter\|HtmlToPdfDocument" --include="*.cs" .

# Find native library loading
grep -r "wkhtmltopdf\|libwkhtmltox" --include="*.cs" --include="*.csproj" .

# Find GlobalSettings/ObjectSettings usage
grep -r "GlobalSettings\|ObjectSettings\|MarginSettings" --include="*.cs" .

# Find DinkToPdf namespace usage
grep -r "using DinkToPdf\|using Haukcode" --include="*.cs" .

# Find converter usage
grep -r "SynchronizedConverter\|BasicConverter\|HtmlToPdfDocument" --include="*.cs" .

# Find native library loading
grep -r "wkhtmltopdf\|libwkhtmltox" --include="*.cs" --include="*.csproj" .

# Find GlobalSettings/ObjectSettings usage
grep -r "GlobalSettings\|ObjectSettings\|MarginSettings" --include="*.cs" .

SHELL

Dokumentieren Sie aktuelle GlobalSettings und ObjectSettings Konfigurationen. Identifizieren Sie jeglichen Code zum Laden nativer Bibliotheken, der entfernt werden kann.

Aufgaben der Code-Aktualisierung

DinkToPdf NuGet-Pakete entfernen 2.IronPDF NuGet-Paket installieren
Aktualisieren Sie Namensraum-Importe von DinkToPdf zu IronPdf
Ersetzen Sie SynchronizedConverter durch ChromePdfRenderer
Konvertieren Sie HtmlToPdfDocument Muster in direkte Methodenaufrufe
Konvertieren Sie GlobalSettings zu RenderingOptions
Konvertieren Sie ObjectSettings zu RenderingOptions
Aktualisieren Sie die Platzhaltersyntax ([page] → {page}, [toPage] → {total-pages})
IronPDF-Lizenzinitialisierung beim Start hinzufügen

Infrastruktur-Aufräumarbeiten

Native Binärdateien löschen (libwkhtmltox.*)
Code zum Laden nativer Bibliotheken entfernen
CustomAssemblyLoadContext entfernen, falls vorhanden
Aktualisierung der Dependency Injection (Singleton nicht mehr erforderlich)
Plattformerkennungscode für native Binärdateien entfernen

Post-Migrationstests

Überprüfen Sie diese Aspekte nach der Migration:

Test der Konvertierung von HTML in PDF
Test der URL-zu-PDF-Konvertierung
Überprüfen der Seiteneinstellungen (Größe, Ausrichtung, Ränder)
Überprüfen von Kopf- und Fußzeilen mit Platzhaltern
Test mit aktuellen HTML-Vorlagen
Leistungstest unter Last

Die wichtigsten Vorteile der Migration zu IronPDF

Der Wechsel von Haukcode.DinkToPdf zu IronPDF bietet mehrere entscheidende Vorteile:

Sicherheit: Beseitigt CVE-2022-35583 (SSRF) und andere wkhtmltopdf-Schwachstellen, die niemals behoben werden.

Moderne Rendering-Engine: Nutzt das aktiv aktualisierte Chromium anstelle des veralteten Qt WebKit aus dem Jahr 2015. Volle Unterstützung für HTML5, CSS3 und JavaScript .

Keine nativen Binärdateien: Eigenständige Bibliothek ohne plattformspezifische DLLs, die verwaltet werden müssen. Vereinfacht den Einsatz unter Windows, Linux und macOS.

Thread-Sicherheit: Keine Singleton-Anforderung—verwenden Sie ChromePdfRenderer frei in jedem Muster einschließlich der pro Anfrage Erstellung.

Einfachere API: Direkte Methodenaufrufe (RenderHtmlAsPdf(), RenderUrlAsPdf()) anstelle komplexer Dokumentenobjektkonstruktionen.

Aktive Entwicklung: Dank des regelmäßigen Veröffentlichungsrhythmus von IronPDF bleibt es mit aktuellen .NET-Versionen kompatibel, einschließlich .NET Framework 4.6.2+, .NET Core 3.1+ und .NET 5/6/7/8/9/10.

Hinweis:: DinkToPdf, Haukcode.DinkToPdf, Haukcode.WkHtmlToPdfDotNet und wkhtmltopdf sind Warenzeichen oder Produktnamen ihrer jeweiligen Eigentümer. Diese Seite ist nicht mit einem dieser Projekte verbunden, unterstützt 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.

...