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

PuppeteerSharp gegen IronPDF: Technischer Leitfaden zum Vergleich

Curtis Chau

Updated: 21. April 2026

Wenn .NET-Entwickler HTML in PDF konvertieren müssen, bieten sich mehrere Wrapper-Bibliotheken an, die auf älteren Rendering-Engines basieren. TuesPechkinist eine solche Lösung, die die wkhtmltopdf-Bibliothek umhüllt, um PDF-Generierungsfunktionen bereitzustellen. Dieser technische Vergleich untersucht TuesPechkinund IronPDF, um Architekten und Entwicklern zu helfen, die Kompromisse zwischen Legacy-Wrappern und modernen PDF-Bibliotheken zu verstehen.

TuesPechkin verstehen

TuesPechkin ist ein thread-sicherer Wrapper um die wkhtmltopdf-Bibliothek, der Entwicklern helfen soll, PDF-Dokumente aus HTML-Inhalten zu erzeugen. Die Bibliothek versucht, die bei wkhtmltopdf inhärenten Nebenläufigkeitsprobleme zu lösen, indem sie eine ThreadSafeConverter Implementierung bereitstellt.

TuesPechkin unterliegt jedoch den grundlegenden Einschränkungen der zugrunde liegenden Technologie:

Aufgegebene Foundation: TuesPechkinumhüllt wkhtmltopdf, das zuletzt im Jahr 2015 aktualisiert und im Dezember 2022 offiziell aufgegeben wurde
Veraltete Rendering-Engine: Verwendet Qt WebKit 4.8, eine Rendering-Engine aus der Vor-Chrome-Ära
Komplexes Thread-Management: Erfordert, dass Entwickler die Thread-Sicherheit manuell über RemotingToolset und Bereitstellungsmuster konfigurieren
Stabilität unter Last: Selbst bei Thread-sicherer Konfiguration kann die Bibliothek bei hoher Nebenläufigkeit mit AccessViolationException abstürzen oder Prozesse hängenbleiben
Beschränkte CSS-Unterstützung: Keine Unterstützung für moderne CSS-Funktionen wie Flexbox oder CSS Grid
JavaScript-Einschränkungen: Unzuverlässige JavaScript-Ausführung ohne ES6+-Unterstützung

Sicherheitserwägungen

TuesPechkin erbt alle Sicherheitslücken von wkhtmltopdf. CVE-2022-35583, eingestuft als kritisch (9.8/10), stellt eine Server-Side Request Forgery-Schwachstelle dar, die alle TuesPechkin-Versionen betrifft. Da wkhtmltopdf nicht mehr weiterentwickelt wird, wird diese Schwachstelle niemals gepatcht werden, was bedeutet, dass Anwendungen, die TuesPechkinverwenden, dauerhaft gefährdet bleiben.

IronPDF verstehen

IronPDF verfolgt einen grundlegend anderen Ansatz, indem es eine moderne, kommerzielle PDF-Bibliothek mit nativer Thread-Sicherheit und einer Chromium-basierten Rendering-Engine bereitstellt. Anstatt Legacy-Tools zu verpacken, konzentriert sich IronPDF in erster Linie auf die PDF-Erzeugung.

Zu den wichtigsten Merkmalen von IronPDF gehören:

Moderne Chromium-Engine: Unterstützt für HTML5, CSS3, Flexbox, CSS Grid und ES6+ JavaScript
Native Thread Safety: Keine manuelle Thread-Verwaltung erforderlich - gleichzeitige Operationen funktionieren automatisch
Aktive Entwicklung: Wöchentliche Updates und kontinuierliche Verbesserungen
Umfassende PDF-Funktionen: Neben der Generierung sind auch Manipulation, digitale Signaturen, PDF/A-Konformität und das Ausfüllen von Formularen möglich
Einfache Integration: Unkomplizierte NuGet-Installation ohne native Binärverteilung

Funktionsvergleich

In der folgenden Tabelle sind die technischen Unterschiede zwischen TuesPechkinund IronPDF aufgeführt:

Feature	TuesPechkin	IronPDF
Lizenz	Frei (MIT-Lizenz)	Kommerziell
Thread-Sicherheit	Erfordert manuelles Management	Native Unterstützung
Währung	Begrenzt, kann unter Last abstürzen	Robust, bewältigt hohe Gleichzeitigkeit
Entwicklungsstatus	Inaktiv, zuletzt aktualisiert 2015	Aktive, kontinuierliche Verbesserungen
Benutzerfreundlichkeit	Komplexe Einrichtung	Benutzerfreundlich mit Anleitungen
Dokumentation	Basic	Ausführlich mit Beispielen
Rendering Engine	Qt WebKit 4.8 (veraltet)	Modernes Chromium
CSS3-Unterstützung	Teilweise	Unterstützt
Flexbox/Grid	Nicht unterstützt	Unterstützt
JavaScript	Unzuverlässig	Vollständig ES6+
PDF-Bearbeitung	Nicht verfügbar	Unterstützt
Digitale Signaturen	Nicht verfügbar	Unterstützt
PDF/A-Konformität	Nicht verfügbar	Unterstützt
Formularausfüllen	Nicht verfügbar	Unterstützt
Wasserzeichen	Nicht verfügbar	Unterstützt
Merge/Split	Nicht verfügbar	Unterstützt
Kopf-/Fußzeilen	Nur einfacher Text	Volle HTML-Unterstützung
Sicherheits-Patches	Niemals (aufgegeben)	Regelmäßige Aktualisierungen

Unterschiede in der API-Architektur

Die architektonischen Unterschiede zwischen TuesPechkinund IronPDF werden sofort deutlich, wenn man die Initialisierungsmuster und die grundlegende Verwendung untersucht.

TuesPechkin Initialisierungskomplexität

TuesPechkin erfordert ein komplexes Initialisierungsritual mit Konvertern, Toolsets und Bereitstellungskonfigurationen:

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

class Program
{
    static void Main()
    {
        var converter = new StandardConverter(
            new RemotingToolset<PdfToolset>(
                new Win64EmbeddedDeployment(
                    new TempFolderDeployment())));
        
        string html = "<html><body><h1>Hello World</h1></body></html>";
        byte[] pdfBytes = converter.Convert(new HtmlToPdfDocument
        {
            Objects = { new ObjectSettings { HtmlText = html } }
        });
        
        File.WriteAllBytes("output.pdf", pdfBytes);
    }
}

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

class Program
{
    static void Main()
    {
        var converter = new StandardConverter(
            new RemotingToolset<PdfToolset>(
                new Win64EmbeddedDeployment(
                    new TempFolderDeployment())));
        
        string html = "<html><body><h1>Hello World</h1></body></html>";
        byte[] pdfBytes = converter.Convert(new HtmlToPdfDocument
        {
            Objects = { new ObjectSettings { HtmlText = html } }
        });
        
        File.WriteAllBytes("output.pdf", pdfBytes);
    }
}

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

Module Program
    Sub Main()
        Dim converter = New StandardConverter(
            New RemotingToolset(Of PdfToolset)(
                New Win64EmbeddedDeployment(
                    New TempFolderDeployment())))

        Dim html As String = "<html><body><h1>Hello World</h1></body></html>"
        Dim pdfBytes As Byte() = converter.Convert(New HtmlToPdfDocument With {
            .Objects = {New ObjectSettings With {.HtmlText = html}}
        })

        File.WriteAllBytes("output.pdf", pdfBytes)
    End Sub
End Module

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

Module Program
    Sub Main()
        Dim converter = New StandardConverter(
            New RemotingToolset(Of PdfToolset)(
                New Win64EmbeddedDeployment(
                    New TempFolderDeployment())))

        Dim html As String = "<html><body><h1>Hello World</h1></body></html>"
        Dim pdfBytes As Byte() = converter.Convert(New HtmlToPdfDocument With {
            .Objects = {New ObjectSettings With {.HtmlText = html}}
        })

        File.WriteAllBytes("output.pdf", pdfBytes)
    End Sub
End Module

Dieses Muster erfordert das Verständnis mehrerer verschachtelter Klassen: StandardConverter, RemotingToolset, Win64EmbeddedDeployment und TempFolderDeployment. Die Bereitstellungskonfiguration muss auch der Architektur der Zielplattform (x86/x64) entsprechen.

IronPDF Vereinfachter Ansatz

IronPDF eliminiert die Komplexität der Bereitstellung mit einer unkomplizierten API vollständig:

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

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

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

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

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports System

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

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

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

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports System

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

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

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

Die Klasse ChromePdfRenderer bietet unmittelbaren Zugang zur PDF-Erzeugung ohne plattformspezifische Konfiguration. Eine umfassende Anleitung zur HTML-Konvertierung finden Sie im HTML to PDF tutorial.

URL zu PDF Konvertierung

Die Konvertierung von Webseiten in PDF-Dokumente demonstriert die Unterschiede in der API-Nutzung zwischen den beiden Bibliotheken.

TuesPechkin Implementierung

TuesPechkin verwendet die PageUrl Eigenschaft innerhalb ObjectSettings, um die URL anzugeben:

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

class Program
{
    static void Main()
    {
        var converter = new StandardConverter(
            new RemotingToolset<PdfToolset>(
                new Win64EmbeddedDeployment(
                    new TempFolderDeployment())));
        
        byte[] pdfBytes = converter.Convert(new HtmlToPdfDocument
        {
            Objects = {
                new ObjectSettings {
                    PageUrl = "https://www.example.com"
                }
            }
        });
        
        File.WriteAllBytes("webpage.pdf", pdfBytes);
    }
}

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

class Program
{
    static void Main()
    {
        var converter = new StandardConverter(
            new RemotingToolset<PdfToolset>(
                new Win64EmbeddedDeployment(
                    new TempFolderDeployment())));
        
        byte[] pdfBytes = converter.Convert(new HtmlToPdfDocument
        {
            Objects = {
                new ObjectSettings {
                    PageUrl = "https://www.example.com"
                }
            }
        });
        
        File.WriteAllBytes("webpage.pdf", pdfBytes);
    }
}

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

Class Program
    Shared Sub Main()
        Dim converter = New StandardConverter(
            New RemotingToolset(Of PdfToolset)(
                New Win64EmbeddedDeployment(
                    New TempFolderDeployment())))

        Dim pdfBytes As Byte() = converter.Convert(New HtmlToPdfDocument With {
            .Objects = {
                New ObjectSettings With {
                    .PageUrl = "https://www.example.com"
                }
            }
        })

        File.WriteAllBytes("webpage.pdf", pdfBytes)
    End Sub
End Class

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

Class Program
    Shared Sub Main()
        Dim converter = New StandardConverter(
            New RemotingToolset(Of PdfToolset)(
                New Win64EmbeddedDeployment(
                    New TempFolderDeployment())))

        Dim pdfBytes As Byte() = converter.Convert(New HtmlToPdfDocument With {
            .Objects = {
                New ObjectSettings With {
                    .PageUrl = "https://www.example.com"
                }
            }
        })

        File.WriteAllBytes("webpage.pdf", pdfBytes)
    End Sub
End Class

Die Komplexität der Initialisierung ist dieselbe, und die veraltete WebKit-Engine kann moderne Websites aufgrund der fehlenden CSS3- und JavaScript-Unterstützung fehlerhaft darstellen.

IronPDF Implementierung

IronPDF bietet mit seiner modernen Chromium-Engine eine spezielle Methode für das URL-Rendering:

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

Die RenderUrlAsPdf-Methode lädt Seiten in einem Chromium-Browser ohne Kopfhörer, führt JavaScript aus und wendet alle modernen CSS-Stile korrekt an. Dies erweist sich als wesentlich für Webanwendungen, die mit Frameworks wie React, Angular oder Vue.js erstellt wurden und von TuesPechkinnicht korrekt wiedergegeben werden können.

Benutzerdefinierte Rendering-Einstellungen

Die Konfiguration von Seitenabmessungen, Rändern und Ausrichtung zeigt verschiedene Ansätze für Dokumenteinstellungen auf.

TuesPechkin Konfiguration

TuesPechkin verwendet GlobalSettings und ObjectSettings Klassen mit verschachtelter Konfiguration:

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

class Program
{
    static void Main()
    {
        var converter = new StandardConverter(
            new RemotingToolset<PdfToolset>(
                new Win64EmbeddedDeployment(
                    new TempFolderDeployment())));
        
        string html = "<html><body><h1>Custom PDF</h1></body></html>";
        
        var document = new HtmlToPdfDocument
        {
            GlobalSettings = {
                Orientation = GlobalSettings.PdfOrientation.Landscape,
                PaperSize = GlobalSettings.PdfPaperSize.A4,
                Margins = new MarginSettings { Unit = Unit.Millimeters, Top = 10, Bottom = 10 }
            },
            Objects = {
                new ObjectSettings { HtmlText = html }
            }
        };
        
        byte[] pdfBytes = converter.Convert(document);
        File.WriteAllBytes("custom.pdf", pdfBytes);
    }
}

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

class Program
{
    static void Main()
    {
        var converter = new StandardConverter(
            new RemotingToolset<PdfToolset>(
                new Win64EmbeddedDeployment(
                    new TempFolderDeployment())));
        
        string html = "<html><body><h1>Custom PDF</h1></body></html>";
        
        var document = new HtmlToPdfDocument
        {
            GlobalSettings = {
                Orientation = GlobalSettings.PdfOrientation.Landscape,
                PaperSize = GlobalSettings.PdfPaperSize.A4,
                Margins = new MarginSettings { Unit = Unit.Millimeters, Top = 10, Bottom = 10 }
            },
            Objects = {
                new ObjectSettings { HtmlText = html }
            }
        };
        
        byte[] pdfBytes = converter.Convert(document);
        File.WriteAllBytes("custom.pdf", pdfBytes);
    }
}

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

Class Program
    Shared Sub Main()
        Dim converter = New StandardConverter(
            New RemotingToolset(Of PdfToolset)(
                New Win64EmbeddedDeployment(
                    New TempFolderDeployment())))

        Dim html As String = "<html><body><h1>Custom PDF</h1></body></html>"

        Dim document = New HtmlToPdfDocument With {
            .GlobalSettings = New GlobalSettings With {
                .Orientation = GlobalSettings.PdfOrientation.Landscape,
                .PaperSize = GlobalSettings.PdfPaperSize.A4,
                .Margins = New MarginSettings With {.Unit = Unit.Millimeters, .Top = 10, .Bottom = 10}
            },
            .Objects = {
                New ObjectSettings With {.HtmlText = html}
            }
        }

        Dim pdfBytes As Byte() = converter.Convert(document)
        File.WriteAllBytes("custom.pdf", pdfBytes)
    End Sub
End Class

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

Class Program
    Shared Sub Main()
        Dim converter = New StandardConverter(
            New RemotingToolset(Of PdfToolset)(
                New Win64EmbeddedDeployment(
                    New TempFolderDeployment())))

        Dim html As String = "<html><body><h1>Custom PDF</h1></body></html>"

        Dim document = New HtmlToPdfDocument With {
            .GlobalSettings = New GlobalSettings With {
                .Orientation = GlobalSettings.PdfOrientation.Landscape,
                .PaperSize = GlobalSettings.PdfPaperSize.A4,
                .Margins = New MarginSettings With {.Unit = Unit.Millimeters, .Top = 10, .Bottom = 10}
            },
            .Objects = {
                New ObjectSettings With {.HtmlText = html}
            }
        }

        Dim pdfBytes As Byte() = converter.Convert(document)
        File.WriteAllBytes("custom.pdf", pdfBytes)
    End Sub
End Class

IronPDF-Konfiguration

IronPDF zentralisiert Einstellungen in der RenderingOptions Eigenschaft mit intuitiven Eigenschaftsnamen:

// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Engines.Chrome;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.MarginTop = 10;
        renderer.RenderingOptions.MarginBottom = 10;
        
        string html = "<html><body><h1>Custom PDF</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        
        pdf.SaveAs("custom.pdf");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Engines.Chrome;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.MarginTop = 10;
        renderer.RenderingOptions.MarginBottom = 10;
        
        string html = "<html><body><h1>Custom PDF</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        
        pdf.SaveAs("custom.pdf");
    }
}

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports IronPdf.Engines.Chrome
Imports System

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

        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
        renderer.RenderingOptions.MarginTop = 10
        renderer.RenderingOptions.MarginBottom = 10

        Dim html As String = "<html><body><h1>Custom PDF</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)

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

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports IronPdf.Engines.Chrome
Imports System

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

        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
        renderer.RenderingOptions.MarginTop = 10
        renderer.RenderingOptions.MarginBottom = 10

        Dim html As String = "<html><body><h1>Custom PDF</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)

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

Die Klasse RenderingOptions bietet einen einheitlichen Konfigurationsansatz, bei dem die Randwerte direkt in Millimetern ohne Wrapper-Objekte angegeben werden.

Thread-Sicherheit und Gleichzeitigkeit

Bei der serverseitigen PDF-Erzeugung ist die Thread-Sicherheit ein entscheidender Aspekt, und die beiden Bibliotheken verfolgen grundlegend unterschiedliche Ansätze.

TuesPechkin Thread-Management

TuesPechkin wirbt für einen thread-sicheren Betrieb durch seine ThreadSafeConverter, aber die Implementierung hat dokumentierte Einschränkungen:

// TuesPechkin- Even with ThreadSafeConverter, crashes under load
var converter = new TuesPechkin.ThreadSafeConverter(
    new TuesPechkin.RemotingToolset<PechkinBindings>());

// Under high load, applications may experience:
// - System.AccessViolationException
// - StackOverflowException
// - Process hangs indefinitely
// - Memory corruption

// TuesPechkin- Even with ThreadSafeConverter, crashes under load
var converter = new TuesPechkin.ThreadSafeConverter(
    new TuesPechkin.RemotingToolset<PechkinBindings>());

// Under high load, applications may experience:
// - System.AccessViolationException
// - StackOverflowException
// - Process hangs indefinitely
// - Memory corruption

' TuesPechkin- Even with ThreadSafeConverter, crashes under load
Dim converter = New TuesPechkin.ThreadSafeConverter(
    New TuesPechkin.RemotingToolset(Of PechkinBindings)())

' Under high load, applications may experience:
' - System.AccessViolationException
' - StackOverflowException
' - Process hangs indefinitely
' - Memory corruption

' TuesPechkin- Even with ThreadSafeConverter, crashes under load
Dim converter = New TuesPechkin.ThreadSafeConverter(
    New TuesPechkin.RemotingToolset(Of PechkinBindings)())

' Under high load, applications may experience:
' - System.AccessViolationException
' - StackOverflowException
' - Process hangs indefinitely
' - Memory corruption

Die zugrundeliegende wkhtmltopdf-Bibliothek wurde nicht für Szenarien mit hoher Gleichzeitigkeit entwickelt, und selbst mit Thread-Management auf Wrapper-Ebene gibt es bei starker Belastung Stabilitätsprobleme.

IronPDF Native Gleichzeitigkeit

IronPDF bietet native Thread-Sicherheit ohne jegliche Konfiguration:

//IronPDF- Native thread safety
var renderer = new ChromePdfRenderer();

// Safe for concurrent use across multiple threads
// No AccessViolationException
// No process hangs
// Stable under high load

//IronPDF- Native thread safety
var renderer = new ChromePdfRenderer();

// Safe for concurrent use across multiple threads
// No AccessViolationException
// No process hangs
// Stable under high load

'IronPDF- Native thread safety
Dim renderer As New ChromePdfRenderer()

' Safe for concurrent use across multiple threads
' No AccessViolationException
' No process hangs
' Stable under high load

'IronPDF- Native thread safety
Dim renderer As New ChromePdfRenderer()

' Safe for concurrent use across multiple threads
' No AccessViolationException
' No process hangs
' Stable under high load

Der ChromePdfRenderer verwaltet die Gleichzeitigkeit intern, sodass sich die Entwickler auf die Anwendungslogik und nicht auf die Thread-Synchronisierung konzentrieren können.

Moderne CSS- und JavaScript-Unterstützung

Die Unterschiede zwischen den Rendering-Engines von TuesPechkinund IronPDF werden bei der Arbeit mit modernen Webtechnologien am deutlichsten.

TuesPechkin Rendering Beschränkungen

Die Qt WebKit 4.8-Engine von TuesPechkinist älter als moderne CSS-Layout-Systeme:

<!-- This modern CSS doesn't work in TuesPechkin-->
<div style="display: flex; justify-content: space-between; gap: 20px;">
    <div style="flex: 1;">Column 1</div>
    <div style="flex: 1;">Column 2</div>
</div>

<div style="display: grid; grid-template-columns: repeat(3, 1fr);">
    <div>Grid Item 1</div>
    <div>Grid Item 2</div>
    <div>Grid Item 3</div>
</div>

<!-- This modern CSS doesn't work in TuesPechkin-->
<div style="display: flex; justify-content: space-between; gap: 20px;">
    <div style="flex: 1;">Column 1</div>
    <div style="flex: 1;">Column 2</div>
</div>

<div style="display: grid; grid-template-columns: repeat(3, 1fr);">
    <div>Grid Item 1</div>
    <div>Grid Item 2</div>
    <div>Grid Item 3</div>
</div>

HTML

Anwendungen, die TuesPechkinverwenden, müssen auf tabellenbasierte Layouts oder andere CSS2.1-Umgehungen zurückgreifen, um mehrspaltige Designs zu erreichen.

IronPDF Modernes Rendering

Die Chromium-Engine von IronPDF unterstützt alle modernen CSS und JavaScript:

// Modern CSS works correctly with IronPDF
var html = @"
    <div style='display: flex; justify-content: space-between;'>
        <div>Left</div>
        <div>Right</div>
    </div>";

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
// Renders correctly with full Flexbox support

// Modern CSS works correctly with IronPDF
var html = @"
    <div style='display: flex; justify-content: space-between;'>
        <div>Left</div>
        <div>Right</div>
    </div>";

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
// Renders correctly with full Flexbox support

Dim html As String = "
    <div style='display: flex; justify-content: space-between;'>
        <div>Left</div>
        <div>Right</div>
    </div>"

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
' Renders correctly with full Flexbox support

Dim html As String = "
    <div style='display: flex; justify-content: space-between;'>
        <div>Left</div>
        <div>Right</div>
    </div>"

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
' Renders correctly with full Flexbox support

Dies ermöglicht es den Entwicklern, dasselbe HTML/CSS sowohl für die Webanzeige als auch für die PDF-Generierung zu verwenden, ohne separate Vorlagen zu pflegen.

Wenn Teams Alternativen zu TuesPechkin in Betracht ziehen

Verschiedene Szenarien veranlassen Entwicklungsteams häufig dazu, Alternativen zu TuesPechkinzu prüfen:

Sicherheitsanforderungen

Da CVE-2022-35583 als kritisch eingestuft wurde (9.8/10) und die zugrundeliegende wkhtmltopdf-Bibliothek offiziell aufgegeben wurde, können Organisationen mit Sicherheitsanforderungen TuesPechkinnicht weiter verwenden. Die SSRF-Schwachstelle ermöglicht es Angreifern, auf interne Netzwerke zuzugreifen, Anmeldeinformationen zu stehlen und Daten über bösartige HTML-Inhalte zu exfiltrieren.

Moderne Webtechnologie Einführung

Teams, die moderne Frontend-Frameworks (React, Angular, Vue.js) oder CSS-Layout-Systeme (Flexbox, Grid) einsetzen, stellen fest, dass TuesPechkinihre Inhalte nicht korrekt wiedergeben kann. Der veralteten WebKit 4.8-Engine fehlt die Unterstützung für Technologien, die seit fast einem Jahrzehnt Standard sind.

Stabilität unter Last

Serverseitige Anwendungen, die bei gleichzeitiger PDF-Erzeugung Abstürze, Hänger oder AccessViolationException Fehler erleben, verfolgen diese Probleme häufig auf die Threading-Einschränkungen von TuesPechkinzurück. Selbst mit ThreadSafeConverter Konfiguration war die zugrunde liegende wkhtmltopdf-Bibliothek nicht für hochkonkurrente Umgebungen ausgelegt.

PDF-Funktionsanforderungen

TuesPechkin bietet nur die Konvertierung von HTML in PDF an. Teams, die PDF-Manipulationen (Zusammenführen, Teilen), digitale Signaturen, PDF/A-Konformität, Ausfüllen von Formularen oder Wasserzeichen benötigen, müssen zusätzliche Bibliotheken hinzufügen oder Alternativen wie IronPDF in Betracht ziehen, die diese Funktionen nativ bieten.

Vereinfachte Bereitstellung

Das Initialisierungsmuster von TuesPechkinmit RemotingToolset, Win64EmbeddedDeployment und TempFolderDeployment erhöht die Komplexität der Bereitstellung. Plattformspezifische native Binärdateien müssen für jede Zielumgebung korrekt konfiguriert werden.IronPDF beseitigt diese Komplexität mit einer Standard-NuGet-Installation.

API-Mapping-Referenz

Teams, die eine Umstellung von TuesPechkinauf IronPDF erwägen, werden dieses Mapping hilfreich finden, um Konzeptäquivalenzen zu verstehen:

TuesPechkin	IronPDF
`StandardConverter` / `ThreadSafeConverter`	`ChromePdfRenderer`
`HtmlToPdfDocument`	Parameter der Methode
`GlobalSettings.PaperSize`	`RenderingOptions.PaperSize`
`GlobalSettings.Orientation`	`RenderingOptions.PaperOrientation`
`GlobalSettings.Margins`	`RenderingOptions.MarginTop/Bottom/Left/Right`
`ObjectSettings.HtmlText`	`RenderHtmlAsPdf(html)`
`ObjectSettings.PageUrl`	`RenderUrlAsPdf(url)`
`RemotingToolset` + `Deployment`	Nicht erforderlich
`[page]` Platzhalter	`{page}` Platzhalter
`[toPage]` Platzhalter	`{total-pages}` Platzhalter

Zusätzliche PDF-Fähigkeiten

Neben der Konvertierung von HTML in PDF bietet IronPDF auch Funktionen zur Dokumentenbearbeitung, die TuesPechkinnicht bieten kann:

Zusammenführung von PDFs: Kombinieren Sie mehrere Dokumente zu einer einzigen Datei
Aufteilung von Dokumenten: Extrahieren von Seitenbereichen in separate PDFs
Digitale Signaturen: Anwendung kryptografischer Signaturen für die Authentizität von Dokumenten
Wasserzeichen: Hinzufügen von Text- oder Bild-Wasserzeichen über HTML/CSS
PDF/A-Konformität: Generieren von Dokumenten nach Archivierungsstandard
Formularausfüllung: Programmgesteuertes Ausfüllen von PDF-Formularfeldern
Kopf- und Fußzeilen: Volle HTML-Unterstützung mit Platzhaltern für Seitenzahlen
Passwortschutz: PDFs mit Benutzer- und Eigentümerpasswörtern verschlüsseln

.NET-Kompatibilität und Zukunftsfähigkeit

Der inaktive Entwicklungsstatus von TuesPechkinbedeutet, dass es keine Updates für neuere .NET-Versionen gibt.IronPDF wird aktiv weiterentwickelt und regelmäßig aktualisiert, um die Kompatibilität mit .NET 8, .NET 9 und zukünftigen Versionen, einschließlich .NET 10, das für 2026 erwartet wird, zu gewährleisten. Die async/await-Unterstützung in der gesamten API der Bibliothek entspricht den modernen C#-Entwicklungspraktiken, einschließlich der in C# 13 verfügbaren Funktionen und der voraussichtlichen C# 14-Funktionen.

Abschluss

TuesPechkin und IronPDF repräsentieren verschiedene Epochen der .NET-PDF-Generierung. TuesPechkinbietet einen kostenlosen, MIT-lizenzierten Wrapper für wkhtmltopdf, hat aber kritische Sicherheitslücken, eine veraltete Rendering-Engine, komplexe Anforderungen an die Thread-Verwaltung und Stabilitätsprobleme unter Last. Die zugrundeliegende Technologie wurde 2022 aufgegeben, und es sind keine Sicherheits-Patches in Sicht.

IronPDF bietet eine moderne, aktiv gepflegte Alternative mit einer Chromium-basierten Rendering-Engine, die aktuelle Webtechnologien unterstützt. Die systemeigene Thread-Sicherheit, die umfassenden PDF-Funktionen und das unkomplizierte API-Design beseitigen die Einschränkungen, die wkhtmltopdf-Wrapper mit sich bringen.

Für Teams, die derzeit TuesPechkinverwenden, ergibt sich die Entscheidung zur Migration häufig aus Sicherheitsanforderungen, Anforderungen an die Rendering-Qualität, Stabilitätsbedenken oder Anforderungen an PDF-Funktionen, die über die einfache HTML-Konvertierung hinausgehen. Die API-Zuordnung zwischen den beiden Bibliotheken ist einfach, wobei IronPDF aufgrund seiner vereinfachten Initialisierungs- und Konfigurationsmuster im Allgemeinen weniger Code benötigt.

Weitere Anleitungen zur Implementierung finden Sie in der IronPDF-Dokumentation und den Tutorials, die spezielle Anwendungsfälle und erweiterte Funktionen behandeln.

Hinweis:: TuesPechkin und wkhtmltopdf sind eingetragene Markenzeichen ihrer jeweiligen Eigentümer. Diese Seite ist nicht mit TuesPechkinoder wkhtmltopdf verbunden, befürwortet 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.