Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. Migrationsleitfäden
  4. Haukcode.DinkToPdf nach IronPDF
MIGRATIONSLEITFäDEN

Umstellung von Haukcode.DinkToPdf auf IronPDF

Curtis Chau
Curtis Chau
Aktualisiert:

Haukcode.DinkToPdf ist eine Weiterentwicklung der einst populären DinkToPdf-Bibliothek, die die wkhtmltopdf-Binärdatei verwendet, um HTML for .NET Anwendungen in PDF zu konvertieren. Obwohl Haukcode.DinkToPdf nach dem Stillstand des ursprünglichen Projekts mit .NET Core Schritt hielt, weist es aufgrund seiner Upstream-Abhängigkeit erhebliche Sicherheitsprobleme auf. Das wkhtmltopdf-Projekt wurde im Januar 2023 archiviert, daher werden diese Probleme nie gelöst werden.

Dieser Leitfaden bietet einen umfassenden Migrationspfad von Haukcode.DinkToPdf zu IronPDF, einschließlich Schritt-für-Schritt-Anleitungen, Codevergleichen und praktischen Beispielen für Professional .NET Entwickler, die Sicherheitsrisiken aus ihren PDF-Generierungs-Workflows entfernen möchten.

Kritische Sicherheitswarnung: CVE-2022-35583

Haukcode.DinkToPdf erbt eine schwerwiegende Sicherheitslücke von wkhtmltopdf, die nicht behoben werden kann:

CVE-2022-35583 - Kritische SSRF-Schwachstelle (CVSS 9.8)

Die wkhtmltopdf-Bibliothek (und alle Wrapper einschließlich Haukcode.DinkToPdf) ist anfällig für Server-Side Request Forgery (SSRF):

  • Angriffsvektor: Bösartiger HTML-Inhalt kann den Server dazu veranlassen, interne Ressourcen abzurufen AWS-Metadatenangriff: Zugriff auf http://169.254.169.254 möglich, um AWS-Zugangsdaten zu stehlen
  • Interner Netzwerkzugriff: Kann interne Dienste scannen und darauf zugreifen.
  • Lokale Dateieinbindung: Kann lokale Dateien über das file://-Protokoll lesen.
  • Auswirkung: Vollständige Übernahme der Infrastruktur möglich

Es gibt KEINEN Fix für diese Schwachstelle, da wkhtmltopdf im Jahr 2023 aufgegeben und archiviert wurde. Die letzte Veröffentlichung war Version 0.12.6 im Jahr 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 (Qt WebKit ~2015) Chromium (regelmäßig aktualisiert)
Sicherheitsstatus CVE-2022-35583 (KRITISCH, nicht behebbar) Aktiv gepatcht
Projektstatus Gabelung eines aufgegebenen Projekts Aktiv entwickelt
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
Unterstützung Nur für die Gemeinschaft Professionelle Unterstützung
Aktualisierungen Keine erwartet Regelmäßige Veröffentlichungen
Lizenz MIT (kostenlos) Kommerziell mit kostenloser Testversion

Schnellstart: Haukcode.DinkToPdf zuIronPDF 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
$vbLabelText   $csharpLabel

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

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);
    }
}
Imports DinkToPdf
Imports DinkToPdf.Contracts
Imports System.IO

Module Program
    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 List(Of ObjectSettings) From {
                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 Module
$vbLabelText   $csharpLabel

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");
    }
}
Imports IronPdf
Imports System.IO

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()

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

        pdf.SaveAs("output.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

Haukcode.DinkToPdf erfordert das Erstellen eines SynchronizedConverter mit PdfTools, das Konstruieren eines HtmlToPdfDocument mit verschachtelten GlobalSettings und Objects, das Hinzufügen eines ObjectSettings mit HtmlContent, den Aufruf von converter.Convert() zum Abrufen der Rohbytes 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 Methode SaveAs().

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);
    }
}
Imports DinkToPdf
Imports DinkToPdf.Contracts
Imports System.IO

Module Program
    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 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
$vbLabelText   $csharpLabel

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");
    }
}
Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()

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

        pdf.SaveAs("webpage.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

Haukcode.DinkToPdf verwendet für URLs das gleiche Dokumentkonstruktionsmuster wie ObjectSettings.Page.IronPDF bietet eine spezielle Methode RenderUrlAsPdf(), die die Absicht klar zum Ausdruck bringt.

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);
    }
}
Imports DinkToPdf
Imports DinkToPdf.Contracts
Imports System.IO

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

        Dim doc = 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
$vbLabelText   $csharpLabel

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");
    }
}
Imports IronPdf
Imports IronPdf.Rendering

Class Program
    Shared Sub Main()
        Dim 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

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

        pdf.SaveAs("landscape.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

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

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

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: Benötigt SynchronizedConverter als Singleton aufgrund von Thread-Sicherheitsproblemen mit der nativen wkhtmltopdf-Binärdatei.

Lösung: IronPDF s ChromePdfRenderer ist von Grund auf threadsicher – 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!
$vbLabelText   $csharpLabel

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

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

Haukcode.DinkToPdf: Verwendet eckige Klammern 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.TextHeader = new TextHeaderFooter
{
    RightText = "Page {page} of {total-pages}"
};
// Before (DinkToPdf)
HeaderSettings = { Right = "Page [page] of [toPage]" }

// After (IronPDF)
renderer.RenderingOptions.TextHeader = new TextHeaderFooter
{
    RightText = "Page {page} of {total-pages}"
};
' Before (DinkToPdf)
HeaderSettings = New With {.Right = "Page [page] of [toPage]"}

' After (IronPDF)
renderer.RenderingOptions.TextHeader = New TextHeaderFooter With {
    .RightText = "Page {page} of {total-pages}"
}
$vbLabelText   $csharpLabel

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 die aktuellen Konfigurationen von GlobalSettings und ObjectSettings. Identifizieren Sie jeglichen Code zum Laden nativer Bibliotheken, der entfernt werden kann.

Aufgaben der Code-Aktualisierung

  1. DinkToPdf NuGet-Pakete entfernen 2.IronPDF NuGet-Paket installieren
  2. Namespace-Importe von DinkToPdf auf IronPdf aktualisieren
  3. Ersetzen Sie SynchronizedConverter durch ChromePdfRenderer
  4. Konvertieren Sie HtmlToPdfDocument Muster in direkte Methodenaufrufe.
  5. Konvertiere GlobalSettings in RenderingOptions
  6. Konvertiere ObjectSettings in RenderingOptions
  7. Aktualisieren Sie die Platzhaltersyntax ([page] → {page}, [toPage] → {total-pages})
  8. IronPDF-Lizenzinitialisierung beim Start hinzufügen

Infrastruktur-Aufräumarbeiten

  1. Native Binärdateien löschen (libwkhtmltox.*)
  2. Code zum Laden nativer Bibliotheken entfernen
  3. CustomAssemblyLoadContext entfernen, falls vorhanden
  4. Aktualisierung der Dependency Injection (Singleton nicht mehr erforderlich)
  5. 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 zuIronPDF 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 – ChromePdfRenderer kann in jedem Muster frei verwendet werden, einschließlich der Instanziierung pro Anfrage.

Einfachere API: Direkte Methodenaufrufe (RenderHtmlAsPdf(), RenderUrlAsPdf()) anstelle der komplexen Konstruktion von Dokumentobjekten.

Aktive Weiterentwicklung: Da die Verbreitung von .NET 10 und C# 14 bis 2026 zunimmt, gewährleisten die regelmäßigen Updates vonIronPDF die Kompatibilität mit aktuellen und zukünftigen .NET Versionen.

Curtis Chau
Curtis Chau
  Jetzt mit dem Ingenieurteam chatten
Technischer Autor

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen

Iron Support Team

Wir sind 24 Stunden am Tag, 5 Tage die Woche online.
Chat
E-Mail
Rufen Sie mich an