Iron Suite for .NET

10 bibliothèques .NET. Une suite de documents complète.

Découvrez Iron Suite

IRONPDF

IRONWORD

IRONXL

IRONPPT

IRONOCR

IRONBARCODE

IRONQR

IRONPRINT

IRONZIP

IRONWEBSCRAPER

COMPARAISON

PuppeteerSharp vs IronPDF : Guide de comparaison technique

Curtis Chau

Updated: 21 avril 2026

Lorsque les développeurs .NET ont besoin de convertir du HTML en PDF, plusieurs bibliothèques d'encapsulation construites autour d'anciens moteurs de rendu apparaissent comme des options. TuesPechkinreprésente l'une de ces solutions, en enveloppant la bibliothèque wkhtmltopdf pour fournir des capacités de génération de PDF. Cette comparaison technique examine TuesPechkinaux côtés d'IronPDF pour aider les architectes et les développeurs à comprendre les compromis entre les wrappers hérités et les bibliothèques PDF modernes.

Comprendre TuesPechkin

TuesPechkin est une enveloppe thread-safe autour de la bibliothèque wkhtmltopdf, conçue pour aider les développeurs à générer des documents PDF à partir de contenu HTML. La bibliothèque tente de résoudre les défis de concurrence inhérents à wkhtmltopdf en fournissant une implémentation ThreadSafeConverter.

Cependant, TuesPechkinhérite des limites fondamentales de sa technologie sous-jacente :

Fondation abandonnée: TuesPechkinwraps wkhtmltopdf, dont la dernière mise à jour date de 2015 et qui a été officiellement abandonnée en décembre 2022
Moteur de rendu obsolète: Utilise Qt WebKit 4.8, un moteur de rendu datant d'avant l'ère Chrome
Gestion complexe des threads : Nécessite que les développeurs configurent manuellement la sécurité des threads via RemotingToolset et les modèles de déploiement
Stabilité sous charge : Même avec une configuration de sécurité des threads, la bibliothèque peut planter sous une forte concurrence avec AccessViolationException ou des suspensions de processus
Support CSS limité: Pas de support pour les fonctionnalités CSS modernes telles que Flexbox ou CSS Grid
Limites du JavaScript: Exécution JavaScript peu fiable sans prise en charge ES6+

Considérations de sécurité

TuesPechkin hérite de toutes les vulnérabilités de sécurité de wkhtmltopdf. CVE-2022-35583, classée comme critique (9.8/10), représente une vulnérabilité de type Server-Side Request Forgery qui affecte toutes les versions de TuesPechkin. Comme wkhtmltopdf a été abandonné, cette vulnérabilité ne sera jamais corrigée, ce qui signifie que les applications utilisant TuesPechkinrestent exposées en permanence.

Comprendre IronPDF

IronPDF adopte une approche fondamentalement différente en fournissant une bibliothèque PDF commerciale moderne avec une sécurité de thread native et un moteur de rendu basé sur Chromium. Plutôt que d'envelopper des outils hérités,IronPDF propose la génération de PDF comme objectif principal.

Les principales caractéristiques d'IronPDF sont les suivantes :

Moteur moderne Chromium: Prise en charge de HTML5, CSS3, Flexbox, CSS Grid, et ES6+ JavaScript
Native Thread Safety: Aucune gestion manuelle des threads n'est nécessaire - les opérations simultanées fonctionnent automatiquement
Développement actif: Mises à jour hebdomadaires et améliorations continues
Fonctionnalités PDF complètes: Au-delà de la génération, comprend la manipulation, les signatures numériques, la conformité PDF/A et le remplissage de formulaires
Intégration simple : Installation directe de NuGet sans déploiement de binaire natif

Comparaison des fonctionnalités

Le tableau suivant met en évidence les différences techniques entre TuesPechkinet IronPDF:

Fonction	TuesPechkin	IronPDF
Licence	Gratuit (Licence MIT)	Commercial
Sécurité des threads	Nécessite une gestion manuelle	Support natif
Monnaie fiduciaire	Limité, peut se bloquer sous charge	Robustesse, gestion d'une forte concurrence
Statut de développement	Inactif, dernière mise à jour en 2015	Améliorations actives et continues
Facilité d'utilisation	Configuration complexe	Convivialité des guides
Documentation	Basique	Nombreux exemples
Moteur de rendu	Qt WebKit 4.8 (périmé)	Chrome moderne
Support CSS3	Partiel	Prise en charge
Flexbox/Grid	Non pris en charge	Prise en charge
JavaScript	Peu fiable	ES6+ complet
Manipulation de PDF	Non disponible	Prise en charge
Signatures numériques	Non disponible	Prise en charge
Conformité PDF/A	Non disponible	Prise en charge
Remplissage de formulaires	Non disponible	Prise en charge
Marqueurs d'eau	Non disponible	Prise en charge
Fusion/Fractionnement	Non disponible	Prise en charge
En-têtes/Pieds de page	Texte de base uniquement	Prise en charge complète du HTML
Patchs de sécurité	Never (abandonné)	Mises à jour régulières

Différences d'architecture des API

Les différences architecturales entre TuesPechkinet IronPDF deviennent immédiatement évidentes lorsqu'on examine les modèles d'initialisation et l'utilisation de base.

TuesPechkinComplexité de l'initialisation

TuesPechkin nécessite un rituel d'initialisation complexe impliquant des convertisseurs, des ensembles d'outils et des configurations de déploiement :

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

Ce modèle nécessite la compréhension de plusieurs classes imbriquées : StandardConverter, RemotingToolset, Win64EmbeddedDeployment, et TempFolderDeployment. La configuration de déploiement doit également correspondre à l'architecture de la plateforme cible (x86/x64).

Approche simplifiée d'IronPDF

IronPDF élimine entièrement la complexité du déploiement grâce à une API simple :

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

La classe ChromePdfRenderer offre un accès immédiat à la génération de PDF sans configuration spécifique à la plateforme. Pour obtenir des conseils complets sur la conversion HTML, consultez le tutoriel HTML au PDF.

Conversion d'URL en PDF

La conversion de pages web en documents PDF démontre les différences d'utilisation de l'API entre les deux bibliothèques.

Mise en œuvre de TuesPechkin

TuesPechkin utilise la propriété PageUrl dans ObjectSettings pour spécifier l'URL :

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

La même complexité d'initialisation s'applique, et le moteur WebKit obsolète peut rendre les sites web modernes de manière incorrecte en raison de l'absence de support CSS3 et JavaScript.

Mise en œuvre IronPDF

IronPDF fournit une méthode dédiée au rendu des URL grâce à son moteur moderne Chromium :

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

La méthode RenderUrlAsPdf charge les pages dans un navigateur Chromium sans tête, en exécutant JavaScript et en appliquant tous les styles CSS modernes avec précision. Cela s'avère essentiel pour les applications web construites avec des frameworks comme React, Angular ou Vue.js que TuesPechkinne peut pas rendre correctement.

Paramètres de rendu personnalisés

La configuration des dimensions, des marges et de l'orientation des pages révèle différentes approches de la configuration des documents.

Configuration de TuesPechkin

TuesPechkin utilise les classes GlobalSettings et ObjectSettings avec une configuration imbriquée :

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

Configuration d'IronPDF

IronPDF centralise les paramètres dans la propriété RenderingOptions avec des noms de propriété intuitifs :

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

La classe RenderingOptions fournit une approche de configuration unifiée où les valeurs de marge sont spécifiées directement en millimètres sans objets enveloppants.

Sécurité des threads et concurence

La sécurité des threads est une considération essentielle pour la génération de PDF côté serveur, et les deux bibliothèques adoptent des approches fondamentalement différentes.

Gestion des Threads de TuesPechkin

TuesPechkin annonce une opération sécurisée pour les threads grâce à son ThreadSafeConverter, mais l'implémentation présente des limitations documentées :

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

La bibliothèque wkhtmltopdf sous-jacente n'a pas été conçue pour des scénarios à haute fréquence, et même avec une gestion des threads au niveau de l'enveloppe, des problèmes de stabilité persistent en cas de charge importante.

Concurrence Native d'IronPDF

IronPDF assure la sécurité native des threads sans aucune configuration :

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

Le ChromePdfRenderer gère la concurrence en interne, ce qui permet aux développeurs de se concentrer sur la logique de l'application plutôt que sur la synchronisation des threads.

Support CSS et JavaScript moderne

Les différences de moteur de rendu entre TuesPechkinet IronPDF deviennent plus apparentes lorsqu'on travaille avec des technologies web modernes.

Limitations du rendu de TuesPechkin

Le moteur Qt WebKit 4.8 de TuesPechkinest antérieur aux systèmes de mise en page CSS modernes :

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

Les applications utilisant TuesPechkindoivent s'appuyer sur des mises en page basées sur des tableaux ou d'autres solutions de contournement CSS2.1 pour réaliser des conceptions multi-colonnes.

Rendu Moderne d'IronPDF

Le moteur Chromium d'IronPDF prend en charge toutes les feuilles de style CSS et JavaScript modernes :

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

Cela permet aux développeurs d'utiliser le même HTML/CSS pour l'affichage sur le web et la génération de PDF sans avoir à maintenir des modèles distincts.

Quand les équipes envisagent des alternatives à TuesPechkin

Plusieurs scénarios incitent souvent les équipes de développement à évaluer des alternatives à TuesPechkin:

Exigences de sécurité

Avec la CVE-2022-35583 classée comme critique (9.8/10) et la bibliothèque wkhtmltopdf sous-jacente officiellement abandonnée, les organisations ayant des exigences de conformité en matière de sécurité ne peuvent pas continuer à utiliser TuesPechkin. La vulnérabilité SSRF permet aux attaquants d'accéder aux réseaux internes, de voler des informations d'identification et d'exfiltrer des données par le biais d'un contenu HTML malveillant.

Adoption des technologies web modernes

Les équipes qui adoptent des frameworks frontaux modernes (React, Angular, Vue.js) ou des systèmes de mise en page CSS (Flexbox, Grid) constatent que TuesPechkinne peut pas rendre leur contenu avec précision. Le moteur WebKit 4.8, obsolète, ne prend pas en charge des technologies standardisées depuis près d'une décennie.

Stabilité sous charge

Les applications côté serveur rencontrant des plantages, des suspensions ou des erreurs AccessViolationException sous une charge de génération de PDF concurrente attribuent souvent ces problèmes aux limitations de threading de TuesPechkin. Même avec la configuration ThreadSafeConverter, la bibliothèque sous-jacente wkhtmltopdf n'a pas été conçue pour des environnements à haute concurrence.

Exigences en matière de fonctionnalités du PDF

TuesPechkin propose uniquement la conversion de HTML en PDF. Les équipes qui ont besoin de manipuler des PDF (fusion, fractionnement), de procéder à des signatures numériques, de se conformer à la norme PDF/A, de remplir des formulaires ou d'apposer des filigranes doivent ajouter des bibliothèques supplémentaires ou envisager des alternatives telles qu'IronPDF qui fournissent ces fonctionnalités de manière native.

Déploiement simplifié

Le modèle d'initialisation TuesPechkinavec RemotingToolset, Win64EmbeddedDeployment, et TempFolderDeployment ajoute de la complexité au déploiement. Les binaires natifs spécifiques à la plate-forme doivent être correctement configurés pour chaque environnement cible.IronPDF élimine cette complexité grâce à une installation standard de NuGet.

Référence de mappage d'API

Les équipes qui évaluent une transition de TuesPechkinà IronPDF trouveront cette cartographie utile pour comprendre les équivalences de concepts :

TuesPechkin	IronPDF
`StandardConverter` / `ThreadSafeConverter`	`ChromePdfRenderer`
`HtmlToPdfDocument`	Paramètres de la méthode
`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`	Pas nécessaire
`[page]` placeholder	`{page}` placeholder
`[toPage]` placeholder	`{total-pages}` placeholder

Capacités PDF supplémentaires

Au-delà de la conversion HTML vers PDF,IronPDF offre des fonctionnalités de manipulation de documents que TuesPechkinne peut pas proposer :

Fusionner des PDF: Combiner plusieurs documents en un seul fichier
Division de documents: Extraire des plages de pages dans des PDF distincts
Signatures numériques: Appliquer des signatures cryptographiques pour l'authenticité des documents
Watermarking: Ajouter des filigranes de texte ou d'image via HTML/CSS
**Conformité IronPDF/A:**Générer des documents conformes aux normes d'archivage
Form Filling: Remplir par programme les champs d'un formulaire PDF
En-têtes et pieds de page: Prise en charge complète du HTML avec des espaces réservés aux numéros de page
Protection par mot de passe: Chiffrer les PDF avec les mots de passe de l'utilisateur et du propriétaire

Compatibilité .NET et préparation à l'avenir

Le statut de développement inactif de TuesPechkinsignifie qu'il n'y a pas de mise à jour pour les nouvelles versions de .NET.IronPDF maintient un développement actif avec des mises à jour régulières, garantissant la compatibilité avec .NET 8, .NET 9 et les futures versions, notamment .NET 10 prévue en 2026. La prise en charge async/await de la bibliothèque dans l'ensemble de son API s'aligne sur les pratiques de développement C# modernes, y compris les fonctionnalités disponibles dans C# 13 et les capacités anticipées de C# 14.

Conclusion

TuesPechkin et IronPDF représentent différentes époques de la génération de PDF .NET. TuesPechkinoffre un wrapper gratuit, sous licence MIT, autour de wkhtmltopdf, mais hérite de vulnérabilités de sécurité critiques, d'un moteur de rendu obsolète, d'exigences complexes en matière de gestion des threads et de problèmes de stabilité sous charge. La technologie sous-jacente a été abandonnée en 2022 et aucun correctif de sécurité n'est prévu.

IronPDF offre une alternative moderne, activement maintenue, avec un moteur de rendu basé sur Chromium qui prend en charge les technologies web actuelles. La sécurité native des threads, les fonctionnalités PDF complètes et la conception simple de l'API répondent aux limites inhérentes aux wrappers wkhtmltopdf.

Pour les équipes qui utilisent actuellement TuesPechkin, la décision de migrer découle souvent d'exigences de sécurité, de besoins en matière de qualité de rendu, de préoccupations liées à la stabilité ou de besoins en matière de fonctionnalités PDF allant au-delà de la conversion HTML de base. Le mappage des API entre les deux bibliothèques est simple,IronPDF nécessitant généralement moins de code en raison de ses modèles d'initialisation et de configuration simplifiés.

Pour des conseils de mise en œuvre supplémentaires, explorez la documentation IronPDF et les tutoriels couvrant des cas d'utilisation spécifiques et des fonctionnalités avancées.

Veuillez noter: TuesPechkin et wkhtmltopdf sont des marques déposées de leurs propriétaires respectifs. Ce site n'est pas affilié, soutenu, ni sponsorisé par TuesPechkinou wkhtmltopdf. Tous les noms de produits, logos et marques sont la propriété de leurs propriétaires respectifs. Les comparaisons sont à titre informatif uniquement et reflètent les informations publiquement disponibles au moment de l'écriture.