Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. Migrationsleitfäden
  4. migration von Dinktopdf zu IronPDF
MIGRATIONSLEITFäDEN

Wie man von DinkToPdf zu IronPDF in C# migriert

Curtis Chau
Curtis Chau
Aktualisiert:

DinkToPdf umhüllt wkhtmltopdf und erbt alle seine Sicherheitslücken und technischen Einschränkungen. Das Verständnis dieser Aspekte ist entscheidend für die Beurteilung der Dringlichkeit der Migration.

Kritische Sicherheitsprobleme

DinkToPdf erbt kritische ungepatchte Sicherheitslücken von wkhtmltopdf:

  1. CVE-2022-35583 (SSRF): Serverseitige Anforderungsfälschung, die Angreifern den Zugriff auf interne Netzwerkressourcen ermöglicht
  2. Aufgegebenes Projekt: wkhtmltopdf wird seit 2020 nicht mehr weiterentwickelt.
  3. Keine Sicherheitspatches: Bekannte Sicherheitslücken werden nie behoben.

Technische Probleme

Problem Auswirkungen
Thread-Sicherheit SynchronizedConverter stürzt in der Produktion unter gleichzeitiger Last immer noch ab
Native Binärdateien Komplexe Bereitstellung mit plattformspezifischen libwkhtmltox-Binärdateien
CSS-Einschränkungen Keine Flexbox-, Grid- oder moderne CSS-Unterstützung
JavaScript Inkonsistente Ausführung, Zeitüberschreitungen
Rendering Veraltete WebKit-Engine (ca. 2015)
Wartung Letzte Aktualisierung: 2018

Architektur-Vergleich

Aspekt DinkToPdf IronPDF
Sicherheit CVE-2022-35583 (SSRF), ungepatched Keine bekannten Schwachstellen
Rendering Engine Veraltetes WebKit (2015) Modernes Chromium
Thread-Sicherheit Abstürze bei gleichzeitiger Nutzung Vollständig thread-sicher
Native Abhängigkeiten Plattformspezifische Binärdateien Reines NuGet-Paket
CSS-Unterstützung Kein Flexbox/Grid Vollständig CSS3
JavaScript Begrenzt, inkonsistent Unterstützt
Wartung Abandoned (2018) Aktiv gepflegt

Funktionsvergleich

Feature DinkToPdf IronPDF
HTML zu PDF ✅(veralteter Motor) ✅(Chromium)
URL zu PDF ✅ ✅
Benutzerdefinierte Ränder ✅ ✅
Kopf-/Fußzeilen ✅(eingeschränkt) ✅(vollständiges HTML)
CSS3 ❌Eingeschränkt ✅Vollständig
Flexbox/Grid ❌ ✅
JavaScript ⚠️ Eingeschränkt ✅Vollständig
PDF-Manipulation ❌ ✅
Ausfüllen von Formularen ❌ ✅
Digitale Signaturen ❌ ✅
Verschlüsselung ❌ ✅
Wasserzeichen ❌ ✅
Zusammenführen/Spalten ❌ ✅

Vorbereitung auf die Migration

Voraussetzungen

Stellen Sie sicher, dass Ihre Umgebung diese Anforderungen erfüllt:

  • .NET Framework 4.6.2+ oder .NET Core 3.1 / .NET 5-9
  • Visual Studio 2019+ oder VS Code mit C#-Erweiterung
  • NuGet Package Manager Zugang
  • IronPDF-Lizenzschlüssel (kostenlose Testversion erhältlich unter ironpdf.com)

Überprüfen Sie die Verwendung von DinkToPdf

Führen Sie diese Befehle in Ihrem Lösungsverzeichnis aus, um alle DinkToPdf-Referenzen zu identifizieren:

# Find all DinkToPdf usages in your codebase
grep -r "using DinkToPdf" --include="*.cs" .
grep -r "SynchronizedConverter\|HtmlToPdfDocument\|ObjectSettings" --include="*.cs" .

# Find NuGet package references
grep -r "DinkToPdf" --include="*.csproj" .

# Find wkhtmltopdf binaries
find . -name "libwkhtmltox*"
# Find all DinkToPdf usages in your codebase
grep -r "using DinkToPdf" --include="*.cs" .
grep -r "SynchronizedConverter\|HtmlToPdfDocument\|ObjectSettings" --include="*.cs" .

# Find NuGet package references
grep -r "DinkToPdf" --include="*.csproj" .

# Find wkhtmltopdf binaries
find . -name "libwkhtmltox*"
SHELL

Bahnbrechende Änderungen, die zu erwarten sind

Ändern Sie DinkToPdf IronPDF Auswirkungen
Konverter SynchronizedConverter(new PdfTools()) ChromePdfRenderer Einfachere Instanziierung
Dokument HtmlToPdfDocument Direkter Methodenaufruf Kein Dokument-Objekt
Einstellungen GlobalSettings + ObjectSettings RenderingOptions Einzelne Optionen Objekt
Rückgabetyp byte[] PdfDocument Leistungsfähigeres Objekt
Binär libwkhtmltox.dll/so Keine (verwaltet) Native Dateien entfernen
Thread-Sicherheit SynchronizedConverter erforderlich Thread-sicher als Standard Einfacherer Code
DI Singleton erforderlich Jede Lebensdauer Flexibel

Schritt-für-Schritt-Migrationsprozess

Schritt 1: NuGet-Pakete aktualisieren

Entfernen Sie DinkToPdf und installieren Sie IronPDF:

# Remove DinkToPdf
dotnet remove package DinkToPdf

# Install IronPDF
dotnet add package IronPdf
# Remove DinkToPdf
dotnet remove package DinkToPdf

# Install IronPDF
dotnet add package IronPdf
SHELL

Schritt 2: Entfernen nativer Binärdateien

Löschen Sie diese plattformspezifischen Dateien aus Ihrem Projekt:

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

IronPDF hat keine nativen Abhängigkeiten - alles ist verwalteter Code.

Schritt 3: Aktualisieren der Namensraum-Referenzen

Ersetzen Sie die Namensräume von DinkToPdf durch IronPDF:

// Remove these
using DinkToPdf;
using DinkToPdf.Contracts;

// Add this
using IronPdf;
// Remove these
using DinkToPdf;
using DinkToPdf.Contracts;

// Add this
using IronPdf;
Imports IronPdf
$vbLabelText   $csharpLabel

Schritt 4: Lizenz konfigurieren

// Add at application startup (Program.cs or Global.asax)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
// Add at application startup (Program.cs or Global.asax)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
' Add at application startup (Program.vb or Global.asax)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
$vbLabelText   $csharpLabel

Komplette API-Migrationsreferenz

Kernklassen-Zuordnung

DinkToPdf IronPDF
SynchronizedConverter ChromePdfRenderer
BasicConverter ChromePdfRenderer
PdfTools Nicht erforderlich
HtmlToPdfDocument Nicht erforderlich
GlobalSettings RenderingOptions
ObjectSettings RenderingOptions
MarginSettings Einzelne Randeigenschaften

GlobalSettings Zuordnung

DinkToPdfGlobalSettings IronPDF-Äquivalent
ColorMode = ColorMode.Color Standard (immer Farbe)
Orientation = Orientation.Portrait PaperOrientation = PdfPaperOrientation.Portrait
Orientation = Orientation.Landscape PaperOrientation = PdfPaperOrientation.Landscape
PaperSize = PaperKind.A4 PaperSize = PdfPaperSize.A4
Margins = new MarginSettings() Einzelne Randeigenschaften

MarginSettings-Zuordnung

DinkToPdfRänder IronPDF-Äquivalent
Margins.Top = 10 MarginTop = 10
Margins.Bottom = 10 MarginBottom = 10
Margins.Left = 15 MarginLeft = 15
Margins.Right = 15 MarginRight = 15

Beispiele für die Code-Migration

Einfaches HTML zu PDF

Die grundlegende Konvertierung demonstriert die drastische Vereinfachung von der ausführlichen Konfiguration von DinkToPdf zu IronPDF s schlanker API.

DinkToPdf Implementierung:

// 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 = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>",
                    WebSettings = { DefaultEncoding = "utf-8" }
                }
            }
        };
        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 = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>",
                    WebSettings = { DefaultEncoding = "utf-8" }
                }
            }
        };
        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 ObjectSettings() With {
                    .HtmlContent = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>",
                    .WebSettings = New WebSettings() With {
                        .DefaultEncoding = "utf-8"
                    }
                }
            }
        }
        Dim pdf As Byte() = converter.Convert(doc)
        File.WriteAllBytes("output.pdf", pdf)
    End Sub
End Module
$vbLabelText   $csharpLabel

IronPDF-Implementierung:

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1><p>This is a PDF from HTML.</p>");
        pdf.SaveAs("output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1><p>This is a PDF from HTML.</p>");
        pdf.SaveAs("output.pdf");
    }
}
Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1><p>This is a PDF from HTML.</p>")
        pdf.SaveAs("output.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

IronPDF reduziert eine 20-zeilige DinkToPdf-Konfiguration auf 4 Zeilen. Kein SynchronizedConverter, kein PdfTools, kein HtmlToPdfDocument, kein ObjectSettings—einfach rendern und speichern. Weitere Optionen finden Sie in der HTML zu PDF Dokumentation.

URL zu PDF-Konvertierung

DinkToPdf Implementierung:

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

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

IronPDF s RenderUrlAsPdf ersetzt die verschachtelte ObjectSettings.Page Konfiguration durch einen direkten Methodenaufruf. Weitere Optionen finden Sie in der URL zur PDF-Dokumentation.

Benutzerdefinierte Einstellungen mit Querformat und Rändern

DinkToPdf Implementierung:

// 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.A4,
                Margins = new MarginSettings { Top = 10, Bottom = 10, Left = 15, Right = 15 }
            },
            Objects = {
                new ObjectSettings() {
                    HtmlContent = "<h1>Custom PDF</h1><p>Landscape orientation with custom margins.</p>",
                    WebSettings = { DefaultEncoding = "utf-8" }
                }
            }
        };
        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("custom.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.A4,
                Margins = new MarginSettings { Top = 10, Bottom = 10, Left = 15, Right = 15 }
            },
            Objects = {
                new ObjectSettings() {
                    HtmlContent = "<h1>Custom PDF</h1><p>Landscape orientation with custom margins.</p>",
                    WebSettings = { DefaultEncoding = "utf-8" }
                }
            }
        };
        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("custom.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.A4,
                .Margins = New MarginSettings() With {
                    .Top = 10,
                    .Bottom = 10,
                    .Left = 15,
                    .Right = 15
                }
            },
            .Objects = {
                New ObjectSettings() With {
                    .HtmlContent = "<h1>Custom PDF</h1><p>Landscape orientation with custom margins.</p>",
                    .WebSettings = New WebSettings() With {
                        .DefaultEncoding = "utf-8"
                    }
                }
            }
        }
        Dim pdf As Byte() = converter.Convert(doc)
        File.WriteAllBytes("custom.pdf", pdf)
    End Sub
End Module
$vbLabelText   $csharpLabel

IronPDF-Implementierung:

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.MarginTop = 10;
        renderer.RenderingOptions.MarginBottom = 10;
        renderer.RenderingOptions.MarginLeft = 15;
        renderer.RenderingOptions.MarginRight = 15;

        var pdf = renderer.RenderHtmlAsPdf("<h1>Custom PDF</h1><p>Landscape orientation with custom margins.</p>");
        pdf.SaveAs("custom.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.MarginTop = 10;
        renderer.RenderingOptions.MarginBottom = 10;
        renderer.RenderingOptions.MarginLeft = 15;
        renderer.RenderingOptions.MarginRight = 15;

        var pdf = renderer.RenderHtmlAsPdf("<h1>Custom PDF</h1><p>Landscape orientation with custom margins.</p>");
        pdf.SaveAs("custom.pdf");
    }
}
Imports IronPdf
Imports IronPdf.Rendering
Imports System

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape
        renderer.RenderingOptions.MarginTop = 10
        renderer.RenderingOptions.MarginBottom = 10
        renderer.RenderingOptions.MarginLeft = 15
        renderer.RenderingOptions.MarginRight = 15

        Dim pdf = renderer.RenderHtmlAsPdf("<h1>Custom PDF</h1><p>Landscape orientation with custom margins.</p>")
        pdf.SaveAs("custom.pdf")
    End Sub
End Module
$vbLabelText   $csharpLabel

IronPDF s RenderingOptions ersetzt sowohl GlobalSettings als auch MarginSettings durch eine einheitliche, flüssige API. Weitere Konfigurationsoptionen finden Sie in der Dokumentation der Darstellungsoptionen.

Kritische Hinweise zur Migration

Entfernen nativer Binärdateien

Der wichtigste Bereinigungsschritt ist das Entfernen der nativen wkhtmltopdf-Binärdateien.IronPDF hat keine nativen Abhängigkeiten:

# Delete native binaries
rm libwkhtmltox.* 2>/dev/null
# Delete native binaries
rm libwkhtmltox.* 2>/dev/null
SHELL

Kein Singleton erforderlich

DinkToPdf's SynchronizedConverter musste als Singleton registriert werden, um Abstürze zu vermeiden. IronPDF s ChromePdfRenderer ist threadsicher mit beliebiger DI-Lebensdauer:

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

//IronPDF- any lifetime works
services.AddScoped<ChromePdfRenderer>();
// Or just create inline:
var renderer = new ChromePdfRenderer();
// DinkToPdf- MUST be singleton
services.AddSingleton(typeof(IConverter), new SynchronizedConverter(new PdfTools()));

//IronPDF- any lifetime works
services.AddScoped<ChromePdfRenderer>();
// Or just create inline:
var renderer = new ChromePdfRenderer();
' DinkToPdf- MUST be singleton
services.AddSingleton(GetType(IConverter), New SynchronizedConverter(New PdfTools()))

' IronPDF- any lifetime works
services.AddScoped(Of ChromePdfRenderer)()
' Or just create inline:
Dim renderer As New ChromePdfRenderer()
$vbLabelText   $csharpLabel

Reichhaltigerer Renditetyp

DinkToPdf gibt byte[] zurück.IronPDF gibt PdfDocument mit Manipulationsfunktionen zurück:

// DinkToPdf returns byte[]
byte[] pdf = converter.Convert(doc);
File.WriteAllBytes("output.pdf", pdf);
return File(pdf, "application/pdf");

//IronPDF returns PdfDocument
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
return File(pdf.BinaryData, "application/pdf");
// DinkToPdf returns byte[]
byte[] pdf = converter.Convert(doc);
File.WriteAllBytes("output.pdf", pdf);
return File(pdf, "application/pdf");

//IronPDF returns PdfDocument
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
return File(pdf.BinaryData, "application/pdf");
' DinkToPdf returns Byte()
Dim pdf As Byte() = converter.Convert(doc)
File.WriteAllBytes("output.pdf", pdf)
Return File(pdf, "application/pdf")

' IronPDF returns PdfDocument
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")
Return File(pdf.BinaryData, "application/pdf")
$vbLabelText   $csharpLabel

Vollständige CSS3-Unterstützung

Moderne Layouts, die in DinkToPdf versagen, funktionieren in IronPDF perfekt:

// DinkToPdf- doesn't work (wkhtmltopdf uses 2015 WebKit)
var html = "<div style='display: flex;'>...</div>";  // Broken!

//IronPDF- full support (modern Chromium)
var html = @"
    <div style='display: flex; justify-content: space-between;'>
        <div>Left</div>
        <div>Right</div>
    </div>";
var pdf = renderer.RenderHtmlAsPdf(html);  // Works!
// DinkToPdf- doesn't work (wkhtmltopdf uses 2015 WebKit)
var html = "<div style='display: flex;'>...</div>";  // Broken!

//IronPDF- full support (modern Chromium)
var html = @"
    <div style='display: flex; justify-content: space-between;'>
        <div>Left</div>
        <div>Right</div>
    </div>";
var pdf = renderer.RenderHtmlAsPdf(html);  // Works!
' DinkToPdf- doesn't work (wkhtmltopdf uses 2015 WebKit)
Dim html As String = "<div style='display: flex;'>...</div>"  ' Broken!

' IronPDF- full support (modern Chromium)
Dim html As String = "
    <div style='display: flex; justify-content: space-between;'>
        <div>Left</div>
        <div>Right</div>
    </div>"
Dim pdf = renderer.RenderHtmlAsPdf(html)  ' Works!
$vbLabelText   $csharpLabel

Post-Migrations-Checkliste

Überprüfen Sie nach Abschluss der Codemigration Folgendes:

  • Führen Sie alle Unit-Tests aus, um zu überprüfen, ob die PDF-Generierung korrekt funktioniert.
  • Testen von Multithread-Szenarien (diese führten zu Abstürzen mit DinkToPdf)
  • Vergleich der PDF-Ausgabequalität (IronPDF s Chromium liefert bessere Ergebnisse)
  • CSS-Rendering überprüfen (Flexbox/Grid funktioniert jetzt)
  • Test der JavaScriptAusführung (zuverlässig mit IronPDF)
  • CI/CD-Pipelines aktualisieren, um die Installation von wkhtmltopdf zu entfernen
  • Überprüfung, ob der Sicherheitsscan erfolgreich war (keine CVE-2022-35583-Flags mehr)
  • Entfernen der nativen Binärbereitstellung aus Docker/Bereitstellungsskripten

Zukunftssicherheit für Ihre PDF-Infrastruktur

In Anbetracht der bevorstehenden Entwicklung von .NET 10 und der Einführung neuer Sprachfunktionen in C# 14 sollte eine PDF-Bibliothek gewählt werden, die aktiv gepflegt wird, um langfristige Kompatibilität zu gewährleisten. Die moderne Chromium-Engine von IronPDF wird regelmäßig aktualisiert, während das nicht mehr genutzte wkhtmltopdf von DinkToPdf auf dem Stand von 2015 verharrt - eine wachsende Lücke, die sich mit der Weiterentwicklung der Webstandards bis 2025 und 2026 nur vergrößern wird.

Zusätzliche Ressourcen

Durch die Migration von DinkToPdf zu IronPDF werden kritische Sicherheitslücken (CVE-2022-35583), Abstürze der Thread-Sicherheit, die Komplexität der nativen Binärbereitstellung und die veraltete CSS-Darstellung beseitigt. Der Übergang zu einer modernen Chromium-Engine bietet vollständige CSS3-Unterstützung, zuverlässige JavaScript-Ausführung und die Sicherheit einer aktiv gepflegten Bibliothek.

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