Iron Suite for .NET

10 .NET-Bibliotheken. Eine komplette Dokumenten-Suite.

Entdecken Sie Iron Suite

IRONPDF

IRONWORD

IRONXL

IRONPPT

IRONOCR

IRONBARCODE

IRONQR

IRONPRINT

IRONZIP

IRONWEBSCRAPER

VERGLEICH

CraftMyPDF vs. IronPDF: Leitfaden für den technischen Vergleich

Curtis Chau

Updated: 28. Juni 2026

Wenn .NET-Entwickler nach Optionen zur PDF-Erzeugung suchen, sticht Haukcode.DinkToPdf als Fortsetzung des eingestellten DinkToPdf-Projekts hervor, das die wkhtmltopdf-Binärdatei verwendet. Haukcode.DinkToPdf bietet zwar eine einfache HTML-zu-PDF-Konvertierung, birgt aber erhebliche Sicherheitsrisiken durch wkhtmltopdf, die aufgrund der Einstellung des Projekts nie behoben werden.IronPDF bietet eine andere Möglichkeit: eine aktiv gepflegte Bibliothek, die eine moderne Chromium-Engine mit regelmäßigen Sicherheitsupdates verwendet.

In diesem Vergleich werden beide Bibliotheken hinsichtlich relevanter technischer Aspekte geprüft, um Entwicklern und Architekten eine fundierte Auswahl für ihre .NET PDF-Anforderungen zu ermöglichen.

Haukcode.DinkToPdf erforschen

Haukcode.DinkToPdf ist eine Fortsetzung der einst beliebten DinkToPdf-Bibliothek, die auf der inzwischen nicht mehr existierenden wkhtmltopdf-Binärdatei aufbaut. Die Bibliothek soll mit .NET Core kompatibel bleiben und gleichzeitig eine HTML-zu-PDF-Konvertierung ermöglichen. Als Fortsetzung eines eingestellten Projekts hat Haukcode.DinkToPdf erhebliche Einschränkungen.

Haukcode.DinkToPdf verwendet SynchronizedConverter mit PdfTools zur Konvertierung. Die Konfiguration wird über HtmlToPdfDocument Objekte verwaltet, die GlobalSettings für Seitenoptionen (ColorMode, Orientation, PaperSize, Margins) und ObjectSettings für Inhalt (HtmlContent für HTML-Strings, Page für URLs) enthalten. Die converter.Convert(doc) Methode gibt rohe byte[] Daten zurück.

Die Bibliothek benötigt plattformspezifische native Binärdateien: libwkhtmltox.dll (Windows), libwkhtmltox.so (Linux) und libwkhtmltox.dylib (macOS). Thread-Sicherheit erfordert die Verwendung von SynchronizedConverter in einem Singleton-Muster aufgrund von wkhtmltopdf-Beschränkungen.

IronPDF erforschen

IronPDF ist eine unabhängig entwickelte .NET-Bibliothek, die eine moderne Chromium-Rendering-Engine verwendet. Die Bibliothek wird aktiv mit regelmäßigen Updates, professionellem Support und kontinuierlichen Sicherheits-Patches gepflegt.

IronPDF verwendet ChromePdfRenderer als Haupt-Rendering-Klasse mit Konfiguration über RenderingOptions Eigenschaften. Methoden wie RenderHtmlAsPdf() und RenderUrlAsPdf() geben PdfDocument Objekte zurück, die mit SaveAs() gespeichert oder als BinaryData abgerufen werden können. Die Bibliothek ist in sich geschlossen, es sind keine externen nativen Binärdateien erforderlich, und sie ist von vornherein thread-sicher, ohne Singleton-Muster zu erfordern.

Der kritische Sicherheitsaspekt

Der wichtigste Unterschied zwischen diesen Bibliotheken ist die Sicherheit. Haukcode.DinkToPdf erbt CVE-2022-35583, eine kritische Server-Side Request Forgery (SSRF)-Schwachstelle mit einem CVSS-Wert von 9.8.

CVE-2022-35583 Angriffsvektoren:

Bösartige HTML-Inhalte können den Server dazu bringen, interne Ressourcen abzurufen
AWS-Metadaten-Angriffe können auf http://169.254.169.254 zugreifen, um Anmeldedaten zu stehlen
Scannen des internen Netzwerks und Zugang zu internen Diensten
Lokale Dateieinbindung über das file:// Protokoll
Potenzial für die vollständige Übernahme der Infrastruktur

Es gibt keinen Fix für diese Schwachstelle, da wkhtmltopdf nicht mehr weiterentwickelt wird (archiviert seit Januar 2023, die letzte Version war 0.12.6 im Jahr 2020).

Sicherheitsaspekt	Haukcode.DinkToPdf	IronPDF
Kritische CVEs	CVE-2022-35583 (CVSS 9.8, nicht behebbar)	Aktiv gepatcht
Unterliegende Engine	wkhtmltopdf (Qt WebKit ~2015)	Chromium (regelmäßig aktualisiert)
Projektstatus	Gabelung eines aufgegebenen Projekts	Aktiv entwickelt
Sicherheitsupdates	Keine erwartet	Regelmäßige Veröffentlichungen
Unterstützung	Nur für die Gemeinschaft	Professionelle Unterstützung

Vergleich von Architektur und Motor

Die grundlegenden Unterschiede in der Architektur wirken sich auf die Qualität der Darstellung, die Unterstützung moderner Webstandards und die Komplexität der Bereitstellung aus.

Aspekt	Haukcode.DinkToPdf	IronPDF
Rendering Engine	Qt WebKit (~2015)	Chromium (aktuell)
HTML5/CSS3	Beschränkt	Unterstützt
JavaScript	Begrenzt, unsicher	Vollständige V8-Engine
Native Binärdateien	Erforderlich (plattformspezifisch)	In sich geschlossen
Thread-Sicherheit	Erfordert Singleton-Muster	Thread-sicher durch Design
Aktualisierungen	Keine erwartet	Regelmäßige Veröffentlichungen

Da Haukcode.DinkToPdf auf die veraltete Qt-WebKit-Engine setzt, fehlen jahrelange Sicherheitspatches und die Unterstützung moderner Webstandards ist begrenzt. Die Chromium-Engine von IronPDF unterstützt aktuelle Webstandards und wird regelmäßig aktualisiert.

Code-Vergleich: Gängige PDF-Operationen

HTML-zu-PDF-Konvertierung

Der grundlegendste Vorgang demonstriert die Unterschiede im API-Design.

Haukcode.DinkToPdf:

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

// 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, den Aufbau eines HtmlToPdfDocument mit verschachtelten GlobalSettings und ObjectSettings Objekten, den Aufruf von Convert() zum Erhalten von Rohbytes und das manuelle Schreiben auf die Festplatte mit File.WriteAllBytes().

IronPDF erstellt ein ChromePdfRenderer, ruft RenderHtmlAsPdf() mit dem HTML-String direkt auf und speichert mit SaveAs(). Die Bedienung ist durch ein modernes API-Design deutlich prägnanter.

Für fortgeschrittene HTML-Rendering-Optionen lesen Sie bitte den Leitfaden zur Konvertierung von HTML in PDF.

URL zu PDF-Konvertierung

Die Konvertierung von Webseiten zeigt die verschiedenen Ansätze für den Umgang mit externen Inhalten.

Haukcode.DinkToPdf:

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

// 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 dieselbe HtmlToPdfDocument Struktur mit der ObjectSettings.Page Eigenschaft zur URL-Spezifikation.IronPDF bietet eine dedizierte RenderUrlAsPdf() Methode, die die URL direkt akzeptiert—eine sauberere API für diesen spezifischen Anwendungsfall.

Beachten Sie, dass das URL-Rendering mit Haukcode.DinkToPdf das Risiko der SSRF-Schwachstelle CVE-2022-35583 birgt, da bösartige URLs oder Weiterleitungen den Server ausnutzen könnten.

Benutzerdefinierte Seiteneinstellungen

Die Seitenkonfiguration veranschaulicht die verschiedenen Konfigurationsmodelle.

Haukcode.DinkToPdf:

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

// 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 konfiguriert Seiteneinstellungen über GlobalSettings mit verschachtelten MarginSettings Objekten. Eigenschaften nutzen Enums wie Orientation.Landscape und PaperKind.Letter.

IronPDF verwendet RenderingOptions Eigenschaften direkt am Renderer. Eigenschaften werden individuell gesetzt (PaperSize, PaperOrientation, MarginTop, etc.) mit typisierten Enums (PdfPaperSize.Letter, PdfPaperOrientation.Landscape). Beide verwenden Millimeter als Maßeinheit.

Weitere Informationen zur Rendering-Konfiguration finden Sie in den IronPDF-Tutorials.

API-Mapping-Referenz

Für Entwickler, die die Migration von Haukcode.DinkToPdf evaluieren oder deren Fähigkeiten vergleichen möchten, zeigt dieses Mapping gleichwertige Operationen:

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 für `RenderHtmlAsPdf()`
`Page` (URL)	`renderer.RenderUrlAsPdf(url)`
`HeaderSettings.Right = "[page]"`	`TextHeader.RightText = "{page}"`

Unterschiede in der Syntax von Platzhaltern

Platzhalter für Kopf- und Fußzeilen verwenden eine andere Syntax als die Bibliotheken:

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

Thread Safety und Dependency Injection

Haukcode.DinkToPdf erfordert aufgrund der von wkhtmltopdf geerbten Einschränkungen der Threadsicherheit eine sorgfältige Handhabung.

Haukcode.DinkToPdf (Singleton erforderlich):

// Startup.cs - MUST be singleton due to thread safety issues
public void ConfigureServices(IServiceCollection services)
{
    services.AddSingleton(typeof(IConverter), new SynchronizedConverter(new PdfTools()));
}

// Startup.cs - MUST be singleton due to thread safety issues
public void ConfigureServices(IServiceCollection services)
{
    services.AddSingleton(typeof(IConverter), new SynchronizedConverter(new PdfTools()));
}

' Startup.vb - MUST be singleton due to thread safety issues
Public Sub ConfigureServices(services As IServiceCollection)
    services.AddSingleton(GetType(IConverter), New SynchronizedConverter(New PdfTools()))
End Sub

' Startup.vb - MUST be singleton due to thread safety issues
Public Sub ConfigureServices(services As IServiceCollection)
    services.AddSingleton(GetType(IConverter), New SynchronizedConverter(New PdfTools()))
End Sub

IronPDF (Flexibel):

// Startup.cs - Can be singleton or transient (both work)
public void ConfigureServices(IServiceCollection services)
{
    IronPdf.License.LicenseKey = Configuration["IronPdf:LicenseKey"];
    services.AddSingleton<IPdfService, IronPdfService>();
    // Or services.AddTransient<IPdfService, IronPdfService>() - both are safe!
}

// Startup.cs - Can be singleton or transient (both work)
public void ConfigureServices(IServiceCollection services)
{
    IronPdf.License.LicenseKey = Configuration["IronPdf:LicenseKey"];
    services.AddSingleton<IPdfService, IronPdfService>();
    // Or services.AddTransient<IPdfService, IronPdfService>() - both are safe!
}

Imports Microsoft.Extensions.DependencyInjection

Public Sub ConfigureServices(services As IServiceCollection)
    IronPdf.License.LicenseKey = Configuration("IronPdf:LicenseKey")
    services.AddSingleton(Of IPdfService, IronPdfService)()
    ' Or services.AddTransient(Of IPdfService, IronPdfService) - both are safe!
End Sub

Imports Microsoft.Extensions.DependencyInjection

Public Sub ConfigureServices(services As IServiceCollection)
    IronPdf.License.LicenseKey = Configuration("IronPdf:LicenseKey")
    services.AddSingleton(Of IPdfService, IronPdfService)()
    ' Or services.AddTransient(Of IPdfService, IronPdfService) - both are safe!
End Sub

IronPDF ist von Haus aus thread-sicher und ermöglicht flexible Dependency-Injection-Muster ohne Singleton-Anforderungen.

Zusammenfassung des Funktionsvergleichs

Feature	Haukcode.DinkToPdf	IronPDF
Herkunft	Gabelung eines aufgegebenen Projekts	Unabhängige Entwicklung
Sicherheit	Ererbte CVEs von Upstream (nicht behebbar)	Proaktiv gepatcht und sicher
Gemeinschaft & Unterstützung	Klein und sporadisch	Groß, aktiv und engagiert
Funktionen und Aktualisierungen	Begrenzt und sporadisch	Regelmäßig mit aktiver Entwicklung
Multi-Threading-Unterstützung	Erfordert Singleton-Muster	Vollständig unterstützt und optimiert
Native Binärdateien	Erforderlich (plattformspezifisch)	In sich geschlossen
HTML5/CSS3	Beschränkt	Unterstützt
JavaScript	Beschränkt	Vollständige V8-Engine
Lizenz	MIT (kostenlos)	Kommerziell mit kostenloser Testversion

Wenn Teams den Wechsel von Haukcode.DinkToPdf zu IronPDF erwägen

Entwicklungsteams erwägen den Umstieg von Haukcode.DinkToPdf auf IronPDF aus mehreren Gründen:

Kritische Sicherheitslücken: CVE-2022-35583 (SSRF) ist eine kritische Sicherheitslücke mit CVSS 9.8, die niemals gepatcht werden wird. Bei Anwendungen, die vom Benutzer bereitgestelltes HTML verarbeiten oder externe URLs wiedergeben, ermöglicht diese Schwachstelle den Diebstahl von AWS-Anmeldeinformationen, den internen Netzwerkzugriff und Angriffe zur Einbindung lokaler Dateien.

Aufgegebene zugrunde liegende Technologie: wkhtmltopdf ist aufgegeben (archiviert Januar 2023, letzte Version 2020). Haukcode.DinkToPdf als Fortsetzung kann nicht auf grundlegende Fragen der zugrunde liegenden Technologie eingehen. Der veralteten Qt WebKit-Engine (~2015) fehlen jahrelange Sicherheitspatches.

Native Binary Management: Haukcode.DinkToPdf erfordert die Verteilung plattformspezifischer Binärdateien (libwkhtmltox.dll, libwkhtmltox.so, libwkhtmltox.dylib). Dies erschwert die Bereitstellung, CI/CD-Pipelines und Containerisierung.IronPDF ist in sich geschlossen und enthält keine externen Binärdateien.

Thread Safety Limitations: Das erforderliche SynchronizedConverter Singleton-Muster begrenzt die architektonische Flexibilität und kann bei hoher Last Engpässe verursachen.IronPDF ist von vornherein thread-sicher und erlaubt Instanzen pro Anfrage.

Moderne Webstandards: Begrenzte HTML5/CSS3-Unterstützung und unsichere JavaScript-Ausführung schränken die Rendering-Möglichkeiten für moderne Webinhalte ein. Die Chromium-Engine von IronPDF bietet Unterstützung für aktuelle Webstandards.

Langfristige Rentabilität: Die Abhängigkeit von nicht mehr verwendeten Technologien führt zu technischen Schulden, die sich im Laufe der Zeit erhöhen. Wenn Projekte in Richtung .NET 10 und C# 14 bis 2026 skalieren, wird es zunehmend problematisch, die Abhängigkeit von nicht gewarteten wkhtmltopdf-Wrappern aufrechtzuerhalten.

Stärken und Überlegungen

Haukcode.DinkToPdf Stärken

Frei und Open Source: MIT-Lizenz ohne Lizenzkosten
Grundlegende Funktionalität: Unterstützt grundlegende HTML-zu-PDF-Konvertierung
Vorhandene Codebasis: Vertraut mit Teams, die bereits DinkToPdf verwenden

Haukcode.DinkToPdf Überlegungen

Kritische Sicherheitslücken: CVE-2022-35583 ist nicht behebbar
Aufgegebene Technologie: Basiert auf dem nicht mehr weiterentwickelten wkhtmltopdf
Native Binärabhängigkeit: Plattformspezifische DLLs erforderlich
Thread-Sicherheitsprobleme: Singleton-Muster erforderlich
Eingeschränkte Webstandards: Veraltete Qt WebKit-Engine
Kein professioneller Support: Nur Community-Unterstützung
Technische Verschuldung: Die Abhängigkeit von einem aufgegebenen Projekt erhöht das Risiko

IronPDF Stärken

Aktives Sicherheits-Patching: Regelmäßige Updates beheben Sicherheitslücken
Moderne Chromium-Engine: Unterstützung aktueller Webstandards
Eigenständig: Keine nativen binären Abhängigkeiten
Thread-Safe Design: Flexible Einsatzmuster
Vollständiges HTML5/CSS3/JavaScript: Moderne Rendering-Funktionen
Professionelle Unterstützung: Engagierte technische Unterstützung
Umfassende Ressourcen: Umfangreiche Tutorials und Dokumentation

IronPDF Überlegungen

Gewerbliche Lizenz: Erforderlich für die produktive Nutzung

Abschluss

Haukcode.DinkToPdf und IronPDF stellen grundlegend unterschiedliche Ansätze zur PDF-Erzeugung in .NET-Anwendungen dar. Haukcode.DinkToPdf, als Fortsetzung des aufgegebenen DinkToPdf-Projekts, das die eingestellte wkhtmltopdf-Binärdatei umhüllt, enthält kritische Sicherheitslücken (CVE-2022-35583), die nie gepatcht werden. Die Bibliothek erfordert eine native Binärdistribution, Singleton-Muster für Thread-Sicherheit und bietet begrenzte Unterstützung für moderne Webstandards.

IronPDF bietet eine aktiv gepflegte Alternative mit einer modernen Chromium-Engine, regelmäßigen Sicherheitsupdates und einer thread-sicheren Architektur. Die in sich geschlossene Bibliothek macht die Verwaltung nativer Binärdateien überflüssig und bietet gleichzeitig volle HTML5/CSS3/JavaScript-Unterstützung.

Da Unternehmen for .NET 10, C# 14 und die Anwendungsentwicklung bis 2026 planen, hat die Entscheidung zwischen der Aufrechterhaltung der Abhängigkeit von veralteter Technologie mit kritischen, nicht behebbaren Schwachstellen und der Übernahme einer aktiv gewarteten Lösung mit modernen Funktionen erhebliche Auswirkungen auf die Sicherheitslage und die Entwicklungsgeschwindigkeit. Teams, die eine sichere PDF-Erzeugung, ein modernes Rendering oder eine vereinfachte Bereitstellung benötigen, werden feststellen, dass IronPDF diese Anforderungen effektiv erfüllt.

Testen Sie IronPDF mit einer kostenlosen Testversion und lesen Sie die umfassende Dokumentation, um die Eignung für Ihre spezifischen Anforderungen zu prüfen.

Hinweis:: DinkToPdf und wkhtmltopdf sind eingetragene Marken ihrer jeweiligen Inhaber. Diese Website ist nicht verbunden mit, unterstützt oder gesponsert von DinkToPdf oder wkhtmltopdf. 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.