Question : Pouvez-vous créer des PDF dans ASP.NET avec iText, et y a-t-il une meilleure alternative ? Oui -- iText est une bibliothèque PDF .NET de longue date, mais IronPDF offre une approche moderne HTML-à-PDF qui élimine le besoin d'apprendre les structures de document PDF à bas niveau. Ce guide compare les deux bibliothèques avec des exemples de code fonctionnels afin que vous puissiez choisir l'outil adapté à votre projet.
iText est un portage .NET de la bibliothèque Java iText, offrant une création de PDF programmatique via sa classe de document et une manipulation de contenu PDF à bas niveau. Bien que puissant, l'utilisation d'iText nécessite la compréhension de la structure de document PDF, le travail avec des objets de document et le positionnement manuel des éléments en utilisant des coordonnées et des spécifications de taille de page. L'API est verbeuse par nécessité : la bibliothèque expose toute la complexité de la spécification PDF, ce qui signifie qu'il y a beaucoup à apprendre avant de produire un résultat impeccable.
IronPDF adopte une approche différente, en se concentrant sur la conversion HTML vers PDF à l'aide d'un moteur de rendu Chrome. Les développeurs peuvent générer des fichiers PDF en utilisant du HTML et du CSS familiers, ce qui rend la création de PDF aussi simple que la conception d'une page web. IronPDF gère la logique de génération de PDF en arrière-plan, vous permettant de produire des documents avec un style moderne et la prise en charge de JavaScript . Étant donné que le pipeline de rendu est alimenté par Chromium, toute mise en page fonctionnant dans un navigateur moderne sera fidèlement reproduite dans le fichier PDF, y compris les éléments flexbox, grid, les polices web et le contenu généré par JavaScript.
La conséquence pratique de cette différence architecturale est qu'iText récompense les développeurs qui veulent un contrôle précis au niveau des coordonnées sur chaque octet d'un fichier PDF, tandis qu'IronPDF récompense les développeurs qui veulent produire des documents visuellement polis rapidement en utilisant les compétences qu'ils possèdent déjà. Pour la plupart des scénarios d'applications Web (factures, rapports, confirmations de commande et exportations de données), l'approche HTML est plus rapide à mettre en œuvre et plus facile à maintenir.
| Caractéristique | iText | IronPDF |
|---|---|---|
| HTML en PDF | Limité (via l'extension XMLWorker) | Rendu complet du moteur Chrome |
| Support CSS | Partiel | Prise en charge complète de CSS3 |
| Support JavaScript | None | Oui (via le moteur Chrome) |
| Licence | AGPL (licence commerciale requise) | Usage commercial, sans redevance |
| Courbe d'apprentissage | Steep (connaissance de l'API PDF requise) | Faible (HTML/CSS suffisant) |
| Installer via NuGet | Install-Package iTextSharp | Install-Package IronPdf |
| Compatibilité .NET | .NET Framework, .NET Core | .NET 8, .NET 9, .NET 10, Framework |
L'installation de l'une ou l'autre bibliothèque commence par le gestionnaire de packages NuGet . Pour iText, notez que les versions plus récentes d'iText fonctionnent sous la licence AGPL, qui nécessite soit de rendre votre application open-source, soit d'acheter une licence commerciale :
# Install iTextSharp via Package Manager Console
Install-Package iTextSharpPour IronPDF, vous pouvez l'installer via la console du gestionnaire de packages NuGet , l'interface de ligne de commande .NET ou en effectuant une recherche directement dans l'interface utilisateur NuGet de Visual Studio :
Après l'installation, IronPDF est prêt à l'emploi avec une simple instruction using. Aucune configuration supplémentaire n'est requise pour la génération de PDF de base. Pour les scénarios avancés, tels que la définition d'une clé de licence , la configuration des options de rendu ou la génération de PDF dans un environnement cloud, consultez la documentation IronPDF . IronPDF prend en charge les déploiements Linux, macOS et Windows, y compris les environnements conteneurisés exécutés dans Docker ou Kubernetes, ce qui le rend parfaitement adapté aux applications ASP.NET modernes natives du cloud.
La manière la plus claire de comprendre la différence entre les API est de créer un simple PDF " Hello World " avec les deux bibliothèques côte à côte.
Avec iText, vous travaillez directement avec la classe Document et PdfWriter :
using iTextSharp.text;
using iTextSharp.text.pdf;
var memoryStream = new MemoryStream();
Document pdfDoc = new Document(PageSize.A4, 25, 25, 25, 15);
PdfWriter writer = PdfWriter.GetInstance(pdfDoc, memoryStream);
pdfDoc.Open();
var paragraph = new Paragraph("Hello World - PDF Document");
paragraph.Font = FontFactory.GetFont(FontFactory.HELVETICA, 16);
pdfDoc.Add(paragraph);
pdfDoc.Add(new Paragraph("Creating PDF documents with iTextSharp"));
pdfDoc.Close();
// Return as a downloadable file
var pdfBytes = memoryStream.ToArray();Imports iTextSharp.text
Imports iTextSharp.text.pdf
Dim memoryStream As New MemoryStream()
Dim pdfDoc As New Document(PageSize.A4, 25, 25, 25, 15)
Dim writer As PdfWriter = PdfWriter.GetInstance(pdfDoc, memoryStream)
pdfDoc.Open()
Dim paragraph As New Paragraph("Hello World - PDF Document")
paragraph.Font = FontFactory.GetFont(FontFactory.HELVETICA, 16)
pdfDoc.Add(paragraph)
pdfDoc.Add(New Paragraph("Creating PDF documents with iTextSharp"))
pdfDoc.Close()
' Return as a downloadable file
Dim pdfBytes As Byte() = memoryStream.ToArray()Cela nécessite de savoir comment Document, PdfWriter, Paragraph, et FontFactory interagissent -- un investissement non négligeable en apprentissage pour les développeurs novices en génération de PDF.
Avec IronPDF, la tâche équivalente utilise le HTML familier :
using IronPdf;
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(@"
<h1>Hello World - PDF Document</h1>
<p>Creating PDFs with IronPDF is straightforward!</p>
");
var pdfBytes = pdf.BinaryData;Imports IronPdf
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf("
<h1>Hello World - PDF Document</h1>
<p>Creating PDFs with IronPDF is straightforward!</p>
")
Dim pdfBytes = pdf.BinaryDataL'approche d'IronPDF vous permet d'écrire directement du code HTML, éliminant ainsi le besoin de manipuler des éléments PDF de bas niveau. La classe ChromePdfRenderer gère tout le rendu en interne à l'aide d'un moteur basé sur Chromium, garantissant un rendu précis au pixel près.
Les documents stylisés révèlent l'écart le plus significatif entre les deux bibliothèques. Lors de la génération de factures, de rapports ou de documents personnalisés, le style basé sur CSS dans IronPDF réduit considérablement la quantité de code nécessaire.
using IronPdf;
var html = @"
<style>
body { font-family: Arial, sans-serif; margin: 0; }
.invoice-header { background: #4CAF50; color: white; padding: 20px; }
.invoice-table { width: 100%; border-collapse: collapse; margin-top: 20px; }
.invoice-table th, .invoice-table td {
border: 1px solid #ddd; padding: 8px; text-align: left;
}
.invoice-table th { background-color: #f2f2f2; }
.total { font-size: 18px; font-weight: bold; margin-top: 16px; }
</style>
<div class='invoice-header'>
<h1>Invoice #2024-001</h1>
<p>Due: March 15, 2024</p>
</div>
<table class='invoice-table'>
<tr><th>Item</th><th>Quantity</th><th>Unit Price</th><th>Total</th></tr>
<tr><td>PDF License</td><td>1</td><td>$599</td><td>$599</td></tr>
<tr><td>Support Package</td><td>1</td><td>$199</td><td>$199</td></tr>
</table>
<p class='total'>Grand Total: $798</p>
";
var renderer = new ChromePdfRenderer();
var pdfDocument = renderer.RenderHtmlAsPdf(html);
var pdfBytes = pdfDocument.BinaryData;Imports IronPdf
Dim html As String = "
<style>
body { font-family: Arial, sans-serif; margin: 0; }
.invoice-header { background: #4CAF50; color: white; padding: 20px; }
.invoice-table { width: 100%; border-collapse: collapse; margin-top: 20px; }
.invoice-table th, .invoice-table td {
border: 1px solid #ddd; padding: 8px; text-align: left;
}
.invoice-table th { background-color: #f2f2f2; }
.total { font-size: 18px; font-weight: bold; margin-top: 16px; }
</style>
<div class='invoice-header'>
<h1>Invoice #2024-001</h1>
<p>Due: March 15, 2024</p>
</div>
<table class='invoice-table'>
<tr><th>Item</th><th>Quantity</th><th>Unit Price</th><th>Total</th></tr>
<tr><td>PDF License</td><td>1</td><td>$599</td><td>$599</td></tr>
<tr><td>Support Package</td><td>1</td><td>$199</td><td>$199</td></tr>
</table>
<p class='total'>Grand Total: $798</p>
"
Dim renderer As New ChromePdfRenderer()
Dim pdfDocument = renderer.RenderHtmlAsPdf(html)
Dim pdfBytes = pdfDocument.BinaryDataObtenir des résultats similaires avec iText nécessite de construire chaque élément visuel de manière programmatique :
using iTextSharp.text;
using iTextSharp.text.pdf;
var output = new MemoryStream();
var document = new Document(PageSize.A4);
PdfWriter.GetInstance(document, output);
document.Open();
// Header -- manual font and color setup
var titleFont = FontFactory.GetFont(FontFactory.HELVETICA_BOLD, 20,
new BaseColor(255, 255, 255));
var headerParagraph = new Paragraph("Invoice #2024-001", titleFont);
document.Add(headerParagraph);
// Table -- each cell must be created individually
PdfPTable table = new PdfPTable(4);
table.WidthPercentage = 100;
string[] headers = { "Item", "Quantity", "Unit Price", "Total" };
foreach (var h in headers)
{
var cell = new PdfPCell(new Phrase(h,
FontFactory.GetFont(FontFactory.HELVETICA_BOLD, 10)));
cell.BackgroundColor = new BaseColor(242, 242, 242);
table.AddCell(cell);
}
table.AddCell("PDF License");
table.AddCell("1");
table.AddCell("$599");
table.AddCell("$599");
document.Add(table);
var totalFont = FontFactory.GetFont(FontFactory.HELVETICA_BOLD, 14);
document.Add(new Paragraph("Grand Total: $798", totalFont));
document.Close();Imports iTextSharp.text
Imports iTextSharp.text.pdf
Dim output As New MemoryStream()
Dim document As New Document(PageSize.A4)
PdfWriter.GetInstance(document, output)
document.Open()
' Header -- manual font and color setup
Dim titleFont As Font = FontFactory.GetFont(FontFactory.HELVETICA_BOLD, 20, New BaseColor(255, 255, 255))
Dim headerParagraph As New Paragraph("Invoice #2024-001", titleFont)
document.Add(headerParagraph)
' Table -- each cell must be created individually
Dim table As New PdfPTable(4)
table.WidthPercentage = 100
Dim headers As String() = {"Item", "Quantity", "Unit Price", "Total"}
For Each h As String In headers
Dim cell As New PdfPCell(New Phrase(h, FontFactory.GetFont(FontFactory.HELVETICA_BOLD, 10)))
cell.BackgroundColor = New BaseColor(242, 242, 242)
table.AddCell(cell)
Next
table.AddCell("PDF License")
table.AddCell("1")
table.AddCell("$599")
table.AddCell("$599")
document.Add(table)
Dim totalFont As Font = FontFactory.GetFont(FontFactory.HELVETICA_BOLD, 14)
document.Add(New Paragraph("Grand Total: $798", totalFont))
document.Close()La différence est claire : IronPDF gère le CSS, le HTML moderne et le JavaScript, tandis qu'iText nécessite la création manuelle de chaque élément, la spécification des polices et la construction de tables cellule par cellule. Pour les applications gourmandes en documents générant des dizaines de modèles distincts, cette différence de volume de code s'accroît considérablement au fil du temps.
Les deux bibliothèques prennent en charge la génération de PDF côté serveur pour les applications ASP.NET . Le modèle de réponse pour renvoyer un PDF sous forme de fichier téléchargeable est similaire quelle que soit la bibliothèque qui génère les octets. Les principaux points à prendre en compte pour une utilisation en production sont la gestion de la mémoire, la sécurité des threads et la configuration des réponses. Les deux bibliothèques utilisent des flux en mémoire, vous devez donc veiller à ne pas conserver de gros fichiers PDF en mémoire plus longtemps que nécessaire. Le ChromePdfRenderer d'IronPDF est conçu pour être instancié par requête, de sorte qu'il n'y a pas d'état partagé à gérer entre les requêtes concurrentes.
using IronPdf;
using Microsoft.AspNetCore.Mvc;
[ApiController]
[Route("api/[controller]")]
public class PdfController : ControllerBase
{
[HttpGet("invoice/{id}")]
public IActionResult GenerateInvoice(int id)
{
var html = BuildInvoiceHtml(id); // your HTML template
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop = 20;
renderer.RenderingOptions.MarginBottom = 20;
var pdf = renderer.RenderHtmlAsPdf(html);
return File(pdf.BinaryData, "application/pdf", $"invoice-{id}.pdf");
}
private static string BuildInvoiceHtml(int id)
{
return $"<h1>Invoice #{id}</h1><p>Generated on {DateTime.UtcNow:yyyy-MM-dd}</p>";
}
}Imports IronPdf
Imports Microsoft.AspNetCore.Mvc
<ApiController>
<Route("api/[controller]")>
Public Class PdfController
Inherits ControllerBase
<HttpGet("invoice/{id}")>
Public Function GenerateInvoice(id As Integer) As IActionResult
Dim html As String = BuildInvoiceHtml(id) ' your HTML template
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4
renderer.RenderingOptions.MarginTop = 20
renderer.RenderingOptions.MarginBottom = 20
Dim pdf = renderer.RenderHtmlAsPdf(html)
Return File(pdf.BinaryData, "application/pdf", $"invoice-{id}.pdf")
End Function
Private Shared Function BuildInvoiceHtml(id As Integer) As String
Return $"<h1>Invoice #{id}</h1><p>Generated on {DateTime.UtcNow:yyyy-MM-dd}</p>"
End Function
End ClassPour les projets ASP.NET MVC (non-Core), retournez un FileResult de la même manière. IronPDF prend également en charge la génération de PDF à partir d'URL , ce qui est utile lors de la conversion de pages Web existantes plutôt que de la construction de chaînes HTML.
Vous pouvez également ajouter des en-têtes et des pieds de page , appliquer des signatures numériques , définir une protection par mot de passe ou fusionner plusieurs PDF à l'aide des API d'édition de documents d'IronPDF, le tout à partir du même package.
La migration d'un projet existant d'iText vers IronPDF suit un modèle simple :
Paragraph, PdfPTable, et PdfPCell, construisez une chaîne HTML ou chargez un fichier HTML. Vos feuilles de style CSS existantes et vos vues partielles Razor peuvent être réutilisées directement.PdfWriter.GetInstance(doc, stream) par new ChromePdfRenderer().RenderHtmlAsPdf(html).memoryStream.ToArray() par pdf.BinaryData.RenderingOptions et PdfDocument d'IronPDF.Pour les équipes disposant déjà de modèles HTML (provenant de générateurs d'e-mails, de vues Razor ou de générateurs de rapports), la migration peut souvent être effectuée en quelques heures plutôt qu'en quelques jours. IronPDF peut générer directement des vues Razor en PDF au sein ASP.NET Core, ce qui accélère encore la migration. Les équipes qui ont investi dans la conception de documents basée sur CSS (par exemple, en utilisant des feuilles de style d'impression pour contrôler les sauts de page et les marges) constateront que ces compétences sont directement transférables à IronPDF.
Consultez le guide de migration IronPDF pour des modèles détaillés couvrant le cryptage, le tamponnage, et d'autres fonctionnalités avancées d'iText.
Pour les développeurs démarrant de nouveaux projets ou migrer depuis iText, les facteurs suivants s'appliquent :
Licence: iText utilise la licence AGPL pour ses nouvelles versions, ce qui nécessite soit de rendre open-source votre application, soit d'acheter une licence commerciale auprès du groupe iText. IronPDF offre une licence commerciale simple sans obligation open-source. Si votre projet est à code source fermé ou commercial, cette distinction à elle seule peut déterminer votre choix.
Prise en main rapide : L'approche d'IronPDF, basée sur HTML, réduit le temps d'apprentissage des API spécifiques aux PDF. Si votre équipe maîtrise HTML et CSS, la génération de PDF avec IronPDF est immédiate. Il n'est pas nécessaire d'étudier les systèmes de coordonnées PDF, l'encodage des glyphes ou l'incorporation des polices : IronPDF gère tout cela de manière transparente.
Couverture des fonctionnalités : IronPDF prend en charge la conformité PDF/A, le remplissage de formulaires, le filigrane, et plus -- le tout à partir d'un seul package NuGet. Des fonctionnalités avancées telles que les signatures numériques et la fusion de PDF sont également incluses sans dépendances supplémentaires.
Migration Path: Passer d'iText à IronPDF implique de remplacer le code de manipulation des documents par des modèles HTML et de mettre à jour l'appel de rendu. La qualité du résultat est généralement supérieure car IronPDF utilise un moteur de navigateur complet, et le code résultant est nettement plus court et plus facile à maintenir.
Pour comprendre le fonctionnement des moteurs de rendu PDF et ce qui les différencie, la documentation de Mozilla sur les PDF et les ressources de spécification PDF d'Adobe fournissent un contexte utile. Le site officiel d'iText Group décrit en détail les termes de l'AGPL.
Pour commencer à utiliser IronPDF dans votre projet ASP.NET :
Install-Package IronPdfusing IronPdf; à votre fichierChromePdfRenderer et appelez RenderHtmlAsPdf() avec votre HTMLpdf.BinaryData comme un FileResult depuis votre contrôleurExplorez ces ressources pour aller plus loin :
Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes et créer des manuels bien structurés et visuellement attrayants.
IronPDF fait partie de IRONSUITE
10 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
