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

SelectPdf vs IronPDF : Guide de comparaison technique

Curtis Chau

Updated: 8 mai 2026

Lorsque les développeurs .NET évaluent les bibliothèques PDF pour la génération et la manipulation de documents, ZetPDFapparaît comme une option sous licence commerciale construite sur la base de PDFSharp. Cependant, son architecture héritée et ses limites soulèvent des considérations importantes pour les équipes qui créent des applications modernes. Cette comparaison technique examine ZetPDFaux côtés d'IronPDF pour aider les architectes et les développeurs à comprendre les différences fondamentales en matière de technologie de rendu, de conception d'API et d'exhaustivité des fonctionnalités.

Comprendre ZetPDF

ZetPDF est une bibliothèque PDF sous licence commerciale conçue pour gérer les fichiers PDF au sein d'applications C#. Construit sur la base de la bibliothèque open-source PDFSharp largement utilisée, il fournit une solution robuste pour créer, modifier et gérer des documents PDF avec un support commercial et des options de licences.

En tant que bibliothèque basée sur PDFSharp, elle hérite à la fois des capacités et des contraintes de sa base :

PDFSharp Foundation: Exploite les capacités de base de PDFSharp avec des licences commerciales
API basée sur les coordonnées : Il faut positionner manuellement les éléments avec des coordonnées exactes
Support commercial: Fournir un support prioritaire par le biais de licences commerciales
Licence flexible: Offre des modèles de licence pour les développeurs, les projets ou les OEM
Limitations héritées: Hérite des contraintes de PDFSharp, y compris les capacités limitées de HTML vers PDF

L'héritage de PDFSharp

Le modèle de programmation basé sur les coordonnées de ZetPDFoblige les développeurs à positionner chaque élément manuellement :

// ZetPDF: Manuel positioning with coordinates
graphics.DrawString("Name:", font, brush, new XPoint(50, 100));
graphics.DrawString("John Doe", font, brush, new XPoint(100, 100));
graphics.DrawString("Address:", font, brush, new XPoint(50, 120));
graphics.DrawString("123 Main St", font, brush, new XPoint(100, 120));
// ... hundreds of lines for a simple form

// ZetPDF: Manuel positioning with coordinates
graphics.DrawString("Name:", font, brush, new XPoint(50, 100));
graphics.DrawString("John Doe", font, brush, new XPoint(100, 100));
graphics.DrawString("Address:", font, brush, new XPoint(50, 120));
graphics.DrawString("123 Main St", font, brush, new XPoint(100, 120));
// ... hundreds of lines for a simple form

' ZetPDF: Manuel positioning with coordinates
graphics.DrawString("Name:", font, brush, New XPoint(50, 100))
graphics.DrawString("John Doe", font, brush, New XPoint(100, 100))
graphics.DrawString("Address:", font, brush, New XPoint(50, 120))
graphics.DrawString("123 Main St", font, brush, New XPoint(100, 120))
' ... hundreds of lines for a simple form

' ZetPDF: Manuel positioning with coordinates
graphics.DrawString("Name:", font, brush, New XPoint(50, 100))
graphics.DrawString("John Doe", font, brush, New XPoint(100, 100))
graphics.DrawString("Address:", font, brush, New XPoint(50, 120))
graphics.DrawString("123 Main St", font, brush, New XPoint(100, 120))
' ... hundreds of lines for a simple form

Cette approche peut s'avérer complexe pour les mises en page de documents qui doivent s'adapter à des longueurs de contenu variables ou qui nécessitent des modèles de conception réactifs.

Comprendre IronPDF

IronPDF adopte une approche fondamentalement différente, en utilisant la technologie basée sur Chromium pour offrir une conversion HTML vers PDF avec une prise en charge complète des standards du web. Plutôt que la programmation graphique basée sur les coordonnées, IronPDF permet aux développeurs d'utiliser les langages HTML et CSS familiers pour la création de documents.

Les principales caractéristiques sont les suivantes

Chromium Rendering Engine: Utilise la technologie moderne des navigateurs pour un rendu HTML/CSSprécis
Conception basée sur HTML/CSS: Exploite les compétences en matière de développement web pour la mise en page des documents
Prise en charge complète de JavaScript : Rendu du contenu web dynamique avec ES2024 JavaScript
Mise en page automatique: Le contenu s'écoule naturellement sans calcul manuel des coordonnées
Fonctionnalités PDF avancées: Prise en charge intégrée des filigranes, des en-têtes/pieds de page, de la fusion, etc

Comparaison des fonctionnalités

Le tableau suivant met en évidence les principales différences entre ZetPDFet IronPDF sur la base de leurs approches architecturales :

Fonction	ZetPDF	IronPDF
Basé sur PDFSharp	Oui	Non
Conversion HTML vers PDF	Limité	Oui (rendu complet de Chromium)
Licence commerciale	Oui, Perpetual	Oui
Open Source Foundation	PDFSharp (Licence MIT)	Basé sur Chromium
Différenciation de PDFSharp	Limité	HTML-to-PDF complet, capacités uniques
Simplicité et facilité d'utilisation	Modéré	Haut
Support pour les annotations PDF	Oui	Oui
Extraction de texte	Standard de l'entreprise	Niveau avancé
Soutien au filigrane	Oui	Oui

Comparaison détaillée des fonctionnalités

Fonction	ZetPDF	IronPDF
Création de contenu
HTML vers PDF	Limité	Oui
URL vers PDF	Limité	Oui
Support CSS	Non	CSS3 complet
JavaScript	Non	ES2024 complet
Mise en page
Mise en page automatique	Non	Oui
Sauts de page automatiques	Non	Oui
Tableaux	Dessin manuel	HTML `<table>`
Images	Placement manuel	`<img>` tag
Opérations PDF
En-têtes/Pieds de page	Manuel	HTML/CSS
Filigranes	Code manuel	Intégré
Fusionner des PDF	Oui	Oui
Diviser les PDF	Limité	Oui
Signatures numériques	Non	Oui
PDF/A	Non	Oui
Développement
Multiplateforme	Oui	Oui

Différences d'architecture des API

Les modèles d'API entre ZetPDFet IronPDF révèlent des philosophies de conception différentes autour de la génération de PDF.

ZetPDFHtmlToPdfConverter Pattern (Modèle de convertisseur HtmlToPdf)

La bibliothèque fournit une classe HtmlToPdfConverter pour la conversion de HTML en PDF :

// ZetPDF— download from zetpdf.com
using ZetPDF;
using System;

class Program
{
    static void Main()
    {
        var converter = new HtmlToPdfConverter();
        var htmlContent = "<html><body><h1>Hello World</h1></body></html>";
        converter.ConvertHtmlToPdf(htmlContent, "output.pdf");
        Console.WriteLine("PDF created successfully");
    }
}

// ZetPDF— download from zetpdf.com
using ZetPDF;
using System;

class Program
{
    static void Main()
    {
        var converter = new HtmlToPdfConverter();
        var htmlContent = "<html><body><h1>Hello World</h1></body></html>";
        converter.ConvertHtmlToPdf(htmlContent, "output.pdf");
        Console.WriteLine("PDF created successfully");
    }
}

Imports ZetPDF
Imports System

Class Program
    Shared Sub Main()
        Dim converter = New HtmlToPdfConverter()
        Dim htmlContent = "<html><body><h1>Hello World</h1></body></html>"
        converter.ConvertHtmlToPdf(htmlContent, "output.pdf")
        Console.WriteLine("PDF created successfully")
    End Sub
End Class

Imports ZetPDF
Imports System

Class Program
    Shared Sub Main()
        Dim converter = New HtmlToPdfConverter()
        Dim htmlContent = "<html><body><h1>Hello World</h1></body></html>"
        converter.ConvertHtmlToPdf(htmlContent, "output.pdf")
        Console.WriteLine("PDF created successfully")
    End Sub
End Class

La méthode ConvertHtmlToPdf prend le contenu HTML et un chemin de fichier de sortie, écrivant le résultat directement sur le disque.

Modèle IronPDF ChromePdfRenderer

IronPDF utilise la classe ChromePdfRenderer avec un rendu basé sur Chromium :

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

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

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

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

Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim htmlContent = "<html><body><h1>Hello World</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
        pdf.SaveAs("output.pdf")
        Console.WriteLine("PDF created successfully")
    End Sub
End Class

Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim htmlContent = "<html><body><h1>Hello World</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
        pdf.SaveAs("output.pdf")
        Console.WriteLine("PDF created successfully")
    End Sub
End Class

Le ChromePdfRenderer renvoie un objet PdfDocument qui offre des capacités de manipulation supplémentaires avant l'enregistrement. 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 direct en documents PDF démontre les capacités de l'approche de rendu web de chaque bibliothèque.

Mise en œuvre de ZetPDF

La bibliothèque gère également la conversion d'URL via sa classe HtmlToPdfConverter :

// ZetPDF— download from zetpdf.com
using ZetPDF;
using System;

class Program
{
    static void Main()
    {
        var converter = new HtmlToPdfConverter();
        var url = "https://www.example.com";
        converter.ConvertUrlToPdf(url, "webpage.pdf");
        Console.WriteLine("PDF from URL created successfully");
    }
}

// ZetPDF— download from zetpdf.com
using ZetPDF;
using System;

class Program
{
    static void Main()
    {
        var converter = new HtmlToPdfConverter();
        var url = "https://www.example.com";
        converter.ConvertUrlToPdf(url, "webpage.pdf");
        Console.WriteLine("PDF from URL created successfully");
    }
}

Imports ZetPDF
Imports System

Class Program
    Shared Sub Main()
        Dim converter As New HtmlToPdfConverter()
        Dim url As String = "https://www.example.com"
        converter.ConvertUrlToPdf(url, "webpage.pdf")
        Console.WriteLine("PDF from URL created successfully")
    End Sub
End Class

Imports ZetPDF
Imports System

Class Program
    Shared Sub Main()
        Dim converter As New HtmlToPdfConverter()
        Dim url As String = "https://www.example.com"
        converter.ConvertUrlToPdf(url, "webpage.pdf")
        Console.WriteLine("PDF from URL created successfully")
    End Sub
End Class

Mise en œuvre IronPDF

IronPDF fournit un rendu d'URL dédié avec Chromium :

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var url = "https://www.example.com";
        var pdf = renderer.RenderUrlAsPdf(url);
        pdf.SaveAs("webpage.pdf");
        Console.WriteLine("PDF from URL created successfully");
    }
}

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var url = "https://www.example.com";
        var pdf = renderer.RenderUrlAsPdf(url);
        pdf.SaveAs("webpage.pdf");
        Console.WriteLine("PDF from URL created successfully");
    }
}

Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim url = "https://www.example.com"
        Dim pdf = renderer.RenderUrlAsPdf(url)
        pdf.SaveAs("webpage.pdf")
        Console.WriteLine("PDF from URL created successfully")
    End Sub
End Class

Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim url = "https://www.example.com"
        Dim pdf = renderer.RenderUrlAsPdf(url)
        pdf.SaveAs("webpage.pdf")
        Console.WriteLine("PDF from URL created successfully")
    End Sub
End Class

La méthode RenderUrlAsPdf exploite le moteur de rendu de Chromium pour traiter les pages web avec une exécution complète de JavaScriptet une prise en charge moderne de CSS, produisant un résultat qui correspond à ce que les utilisateurs voient dans les navigateurs modernes.

Opérations de fusion de fichiers PDF

La combinaison de plusieurs documents PDF est une exigence courante dans les flux de travail d'assemblage de documents.

ZetPDFMerger Pattern (Modèle de fusion ZetPDF)

La bibliothèque fournit une classe PdfMerger pour combiner des documents :

// ZetPDF— download from zetpdf.com
using ZetPDF;
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var merger = new PdfMerger();
        var files = new List<string> { "document1.pdf", "document2.pdf" };
        merger.MergeFiles(files, "merged.pdf");
        Console.WriteLine("PDFs merged successfully");
    }
}

// ZetPDF— download from zetpdf.com
using ZetPDF;
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var merger = new PdfMerger();
        var files = new List<string> { "document1.pdf", "document2.pdf" };
        merger.MergeFiles(files, "merged.pdf");
        Console.WriteLine("PDFs merged successfully");
    }
}

Imports ZetPDF
Imports System
Imports System.Collections.Generic

Module Program
    Sub Main()
        Dim merger As New PdfMerger()
        Dim files As New List(Of String) From {"document1.pdf", "document2.pdf"}
        merger.MergeFiles(files, "merged.pdf")
        Console.WriteLine("PDFs merged successfully")
    End Sub
End Module

Imports ZetPDF
Imports System
Imports System.Collections.Generic

Module Program
    Sub Main()
        Dim merger As New PdfMerger()
        Dim files As New List(Of String) From {"document1.pdf", "document2.pdf"}
        merger.MergeFiles(files, "merged.pdf")
        Console.WriteLine("PDFs merged successfully")
    End Sub
End Module

La méthode MergeFiles accepte une liste de chemins de fichiers et un chemin de sortie, écrivant le résultat fusionné directement sur le disque.

Modèle de fusion statique IronPDF

IronPDF fournit une méthode statique Merge sur la classe PdfDocument :

// NuGet: Install-Package IronPdf
using IronPdf;
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var pdfs = new List<PdfDocument>
        {
            PdfDocument.FromFile("document1.pdf"),
            PdfDocument.FromFile("document2.pdf")
        };
        var merged = PdfDocument.Merge(pdfs);
        merged.SaveAs("merged.pdf");
        Console.WriteLine("PDFs merged successfully");
    }
}

// NuGet: Install-Package IronPdf
using IronPdf;
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var pdfs = new List<PdfDocument>
        {
            PdfDocument.FromFile("document1.pdf"),
            PdfDocument.FromFile("document2.pdf")
        };
        var merged = PdfDocument.Merge(pdfs);
        merged.SaveAs("merged.pdf");
        Console.WriteLine("PDFs merged successfully");
    }
}

Imports IronPdf
Imports System
Imports System.Collections.Generic

Module Program
    Sub Main()
        Dim pdfs As New List(Of PdfDocument) From {
            PdfDocument.FromFile("document1.pdf"),
            PdfDocument.FromFile("document2.pdf")
        }
        Dim merged = PdfDocument.Merge(pdfs)
        merged.SaveAs("merged.pdf")
        Console.WriteLine("PDFs merged successfully")
    End Sub
End Module

Imports IronPdf
Imports System
Imports System.Collections.Generic

Module Program
    Sub Main()
        Dim pdfs As New List(Of PdfDocument) From {
            PdfDocument.FromFile("document1.pdf"),
            PdfDocument.FromFile("document2.pdf")
        }
        Dim merged = PdfDocument.Merge(pdfs)
        merged.SaveAs("merged.pdf")
        Console.WriteLine("PDFs merged successfully")
    End Sub
End Module

La méthode PdfDocument.Merge renvoie un objet PdfDocument, permettant des opérations supplémentaires telles que l'ajout de filigranes, les paramètres de sécurité ou la modification des métadonnées avant l'enregistrement.

Référence de mappage d'API

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

ZetPDF	IronPDF
`new HtmlToPdfConverter()`	`new ChromePdfRenderer()`
`converter.ConvertHtmlToPdf()`	`renderer.RenderHtmlAsPdf()`
`converter.ConvertUrlToPdf()`	`renderer.RenderUrlAsPdf()`
`new PdfMerger()`	`PdfDocument.Merge()`
`merger.MergeFiles()`	`PdfDocument.Merge(list)`
`new PdfDocument()`	`new ChromePdfRenderer()`
`document.AddPage()`	Automatique
`XGraphics.FromPdfPage(page)`	N/A
`graphics.DrawString()`	Éléments de texte HTML
`graphics.DrawImage()`	`<img>` tag
`graphics.DrawLine()`	Bordures CSS
`graphics.DrawRectangle()`	CSS `border` + `div`
`new XFont()`	CSS `font-family`
`XBrushes.Black`	CSS `color`
`document.Save()`	`pdf.SaveAs()`
`PdfReader.Open()`	`PdfDocument.FromFile()`

Conception basée sur les coordonnées et conception basée sur HTML

La différence architecturale fondamentale entre ZetPDFet IronPDF réside dans leur approche de la mise en page des documents.

ZetPDFProgrammation graphique

La base PDFSharp de ZetPDFnécessite un positionnement basé sur les coordonnées :

using ZetPdf;
using ZetPdf.Drawing;

var document = new PdfDocument();
var page = document.AddPage();
var graphics = XGraphics.FromPdfPage(page);
var titleFont = new XFont("Arial", 24, XFontStyle.Bold);
var bodyFont = new XFont("Arial", 12);

graphics.DrawString("Company Report", titleFont, XBrushes.Navy,
    new XPoint(50, 50));
graphics.DrawString("This is the introduction paragraph.", bodyFont, XBrushes.Black,
    new XPoint(50, 80));
graphics.DrawString("Generated: " + DateTime.Now.ToString(), bodyFont, XBrushes.Gray,
    new XPoint(50, 100));

document.Save("report.pdf");

using ZetPdf;
using ZetPdf.Drawing;

var document = new PdfDocument();
var page = document.AddPage();
var graphics = XGraphics.FromPdfPage(page);
var titleFont = new XFont("Arial", 24, XFontStyle.Bold);
var bodyFont = new XFont("Arial", 12);

graphics.DrawString("Company Report", titleFont, XBrushes.Navy,
    new XPoint(50, 50));
graphics.DrawString("This is the introduction paragraph.", bodyFont, XBrushes.Black,
    new XPoint(50, 80));
graphics.DrawString("Generated: " + DateTime.Now.ToString(), bodyFont, XBrushes.Gray,
    new XPoint(50, 100));

document.Save("report.pdf");

Imports ZetPdf
Imports ZetPdf.Drawing

Dim document As New PdfDocument()
Dim page = document.AddPage()
Dim graphics = XGraphics.FromPdfPage(page)
Dim titleFont As New XFont("Arial", 24, XFontStyle.Bold)
Dim bodyFont As New XFont("Arial", 12)

graphics.DrawString("Company Report", titleFont, XBrushes.Navy, New XPoint(50, 50))
graphics.DrawString("This is the introduction paragraph.", bodyFont, XBrushes.Black, New XPoint(50, 80))
graphics.DrawString("Generated: " & DateTime.Now.ToString(), bodyFont, XBrushes.Gray, New XPoint(50, 100))

document.Save("report.pdf")

Imports ZetPdf
Imports ZetPdf.Drawing

Dim document As New PdfDocument()
Dim page = document.AddPage()
Dim graphics = XGraphics.FromPdfPage(page)
Dim titleFont As New XFont("Arial", 24, XFontStyle.Bold)
Dim bodyFont As New XFont("Arial", 12)

graphics.DrawString("Company Report", titleFont, XBrushes.Navy, New XPoint(50, 50))
graphics.DrawString("This is the introduction paragraph.", bodyFont, XBrushes.Black, New XPoint(50, 80))
graphics.DrawString("Generated: " & DateTime.Now.ToString(), bodyFont, XBrushes.Gray, New XPoint(50, 100))

document.Save("report.pdf")

Cette approche nécessite la création d'objets polices, d'objets pinceaux et la spécification de coordonnées X,Y exactes pour chaque élément.

Conception HTML/CSSd'IronPDF

IronPDF utilise des technologies web familières :

using IronPdf;

var html = $@"
<html>
<head>
    <style>
        body {{font-family: Arial, sans-serif; padding: 50px;}}
        h1 {{color: navy;}}
        .date {{color: gray;}}
    </style>
</head>
<body>
    <h1>Company Report</h1>
    <p>This is the introduction paragraph.</p>
    <p class='date'>Generated: {DateTime.Now}</p>
</body>
</html>";

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("report.pdf");

using IronPdf;

var html = $@"
<html>
<head>
    <style>
        body {{font-family: Arial, sans-serif; padding: 50px;}}
        h1 {{color: navy;}}
        .date {{color: gray;}}
    </style>
</head>
<body>
    <h1>Company Report</h1>
    <p>This is the introduction paragraph.</p>
    <p class='date'>Generated: {DateTime.Now}</p>
</body>
</html>";

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("report.pdf");

HTML gère automatiquement la mise en page - CSS assure la mise en forme sans gestion des objets de police, et le contenu s'écoule naturellement d'une page à l'autre.

Quand les équipes envisagent de passer de ZetPDFà IronPDF

Plusieurs scénarios incitent couramment les équipes de développement à évaluer IronPDF comme alternative à ZetPDF:

Exigences en matière de contenu Web moderne

Les équipes qui créent des applications générant des PDF à partir de modèles, de tableaux de bord ou de rapports basés sur le web trouvent que les approches basées sur la coordination sont limitées. Le moteur Chromium d'IronPDF assure le rendu des grilles CSS modernes, de Flexbox et des contenus pilotés par JavaScriptque les bibliothèques basées sur les coordonnées ne peuvent pas entièrement prendre en charge.

Compétences du développeur HTML/CSS

Les équipes disposant de solides compétences en matière de développement web trouvent que la courbe d'apprentissage de la génération de PDF par coordonnées est abrupte. HTML et CSS sont des technologies largement comprises, ce qui rend l'approche d'IronPDF plus accessible aux développeurs qui n'ont pas d'expertise spécialisée en programmation PDF ou graphique.

Réduction de la complexité du code

L'API basée sur les coordonnées produit un code verbeux qui devient difficile à maintenir au fur et à mesure que les mises en page des documents évoluent. Un rapport simple peut nécessiter des douzaines de DrawString et de calculs de coordonnées dans ZetPDFcontre quelques lignes de HTML/CSSavec IronPDF.

Sauts de page et mise en page automatiques

La bibliothèque nécessite le suivi manuel des positions Y et la création explicite de pages lorsque le contenu dépasse les limites de la page.IronPDF gère automatiquement les sauts de page en fonction des règles CSS et du flux de contenu :

//IronPDF- automatic page breaks
var html = @"
<div>Page 1 content</div>
<div style='page-break-after: always;'></div>
<div>Page 2 content</div>";

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("multipage.pdf");

//IronPDF- automatic page breaks
var html = @"
<div>Page 1 content</div>
<div style='page-break-after: always;'></div>
<div>Page 2 content</div>";

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("multipage.pdf");

Dim html As String = "
<div>Page 1 content</div>
<div style='page-break-after: always;'></div>
<div>Page 2 content</div>"

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("multipage.pdf")

Dim html As String = "
<div>Page 1 content</div>
<div style='page-break-after: always;'></div>
<div>Page 2 content</div>"

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("multipage.pdf")

Fonctionnalités PDF avancées

IronPDF offre un support intégré pour des fonctionnalités qui nécessitent une implémentation manuelle ou des outils externes avec l'approche basée sur les coordonnées :

Signatures numériques: Appliquer des signatures cryptographiques pour l'authenticité des documents
Watermarking: Prise en charge intégrée des filigranes au format HTML
**Conformité IronPDF/A:**Générer des documents conformes aux normes d'archivage
En-têtes et pieds de page: En-têtes et pieds de page automatiques au format HTML
Form Filling: Remplir par programme les champs d'un formulaire PDF
Protection par mot de passe: Chiffrer les PDF avec les mots de passe de l'utilisateur et du propriétaire

Forces et considérations

ZetPDFPoints forts

Support commercial: Fournir un support prioritaire par le biais de licences commerciales, en veillant à ce que les développeurs reçoivent une assistance en temps opportun
Intégration de PDFSharp : Exploite les capacités de base de PDFSharp, reconnues par de nombreux développeurs .NET

Considérations sur ZetPDF

Limitations héritées : Comme elle est basée sur PDFSharp, la bibliothèque hérite des contraintes du cadre sous-jacent.
Différentiation limitée : Comparé à l'utilisation directe de PDFSharp, la licence commerciale offre une valeur supplémentaire limitée.
Coordinate-Based Complexity: Les exigences de positionnement manuel augmentent la complexité du code pour les documents dynamiques

Les points forts d'IronPDF

Solution HTML-to-PDF complète: Fonctionnalité HTML-to-PDF complète essentielle pour l'automatisation des conversions de pages web
Rendu amélioré: Le rendu basé sur Chromium permet un traitement supérieur du contenu web, ce qui affecte directement la qualité de la sortie
Fonctionnalités avancées: Des fonctionnalités uniques telles que la gestion des formulaires PDF, le filigrane dynamique et les signatures numériques vont au-delà des manipulations PDF standard
Développement actif: Des mises à jour régulières garantissent la compatibilité avec les versions modernes de .NET

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

Les deux bibliothèques prennent en charge le développement .NET multiplateforme.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. L'approche HTML/CSSde la bibliothèque s'aligne sur les pratiques modernes de développement web, en tirant parti des compétences que les développeurs .NET possèdent déjà grâce à leur familiarité avec les technologies web.

Conclusion

ZetPDF et IronPDF représentent des approches différentes de la génération de PDF dans .NET. ZetPDF, avec sa base PDFSharp, constitue une solution fiable pour les développeurs familiarisés avec la programmation graphique basée sur les coordonnées. Sa licence commerciale offre soutien et fiabilité aux équipes investies dans l'écosystème PDFSharp.

L'approche d'IronPDF, basée sur Chromium, traite la génération de PDF comme un rendu web, permettant aux développeurs d'utiliser HTML, CSS et JavaScriptplutôt que d'apprendre des API graphiques basées sur les coordonnées. La mise en page automatique, les sauts de page et la prise en charge des normes web modernes (CSS Grid, Flexbox, ES2024 JavaScript) réduisent considérablement la complexité du code tout en produisant des résultats qui correspondent au rendu des navigateurs modernes.

Pour les équipes qui créent des applications générant des rapports, des tableaux de bord ou des documents dynamiques basés sur le web, l'approche d'IronPDF s'aligne naturellement sur les pratiques de développement modernes. Pour les équipes ayant déjà une expertise PDFSharp ou des besoins spécifiques autour du contrôle PDF de bas niveau, l'offre commerciale de ZetPDFfournit un support et des options de licence autour de la base PDFSharp familière.

Le choix dépend en fin de compte des exigences de votre équipe : si vos PDF proviennent de contenus web ou si vous préférez le HTML/CSSpour la conception des documents,IronPDF offre des avantages considérables en termes de productivité. Si vous vous appuyez sur des compétences PDFSharp existantes ou si vous avez besoin des modèles de licence spécifiques proposés par ZetPDF, cette voie peut répondre à vos besoins.

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: PDFSharp et ZetPDFsont des marques déposées de leurs propriétaires respectifs. Ce site n'est pas affilié à, approuvé par ou parrainé par ZetPDFou empira Software GmbH. 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.