La bibliothèque PDF de C#
using IronPdf;
// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;
// Instantiate Renderer
var renderer = new ChromePdfRenderer();
// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");
// Export to a file or Stream
pdf.SaveAs("output.pdf");
// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");
Install-Package IronPdf
Dans les applications .NET modernes, la création et la gestion de fichiers PDF sont des exigences courantes—que vous génériez des rapports, des factures ou des enregistrements numériques. Les développeurs se tournent souvent vers des bibliothèques PDF tierces pour cette tâche, et deux des options les plus populaires dans l'écosystème .NET sont IronPDF et iText 7 (le successeur d'iTextSharp).
Chaque bibliothèque offre un ensemble d'outils puissant pour différents cas d'utilisation. Mais lequel est le mieux adapté pour générer un PDF à partir d'un tableau d'octets en C# ? Cet article décompose tout avec des comparaisons, des exemples de code et des idées pour aider les développeurs .NET à faire le bon choix.
Que vous développiez des applications de niveau entreprise ou de petits outils internes, choisir la bonne bibliothèque PDF peut vous faire gagner du temps de développement et garantir un résultat robuste. Explorons ce que chaque bibliothèque offre.
Les bibliothèques PDF en C# permettent aux développeurs de générer, manipuler et lire des fichiers PDF de manière programmatique. Ils servent une large gamme de cas d'utilisation, tels que :
Signature numérique de PDF
Ils jouent également un rôle crucial dans la portabilité des données et la conformité avec des normes telles que PDF/A pour l'archivage ou les exigences d'accessibilité.
Parmi les bibliothèques PDF .NET disponibles, iTextSharp et IronPDF se sont imposées comme des solutions de premier plan, chacune avec des atouts uniques :
Choisir entre les deux n’est pas seulement une question de préférence—cela affecte la productivité, la maintenance, les performances, et même la conformité aux licences légales. Les projets qui nécessitent un délai d'exécution rapide, des modifications fréquentes de format ou le rendu PDF à partir de modèles HTML bénéficient d'un développement rapide, tandis que les applications de niveau entreprise pourraient privilégier la conformité aux normes et la maintenabilité à long terme.
iText 7 est le successeur officiel de iTextSharp et propose une architecture entièrement repensée. C'est une bibliothèque puissante et extensible, adaptée à la création, l'édition et la validation de PDF dans des secteurs fortement réglementés comme le juridique, la finance et le gouvernement. La suite iText 7 inclut la prise en charge du PDF/A, PDF/UA, des signatures numériques, du caviardage et de la création de formulaires.
Bien qu'il reste open source sous la licence AGPL, une licence commerciale est disponible pour les projets propriétaires.
Idéal pour PDF/A, accessibilité, conformité
⚠️ Note : Vous devrez utiliser itext7 pour les opérations PDF de base et pouvez inclure des modules complémentaires optionnels tels que html2pdf séparément.
Pour télécharger le package principal d'iText 7 pour la génération de PDF :
Install-Package itextInstall-Package itext'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Install-Package itext
Vous pouvez également utiliser iText 7 via l'écran du gestionnaire de packages pour solution. Pour ce faire, vous devez d'abord aller dans le menu déroulant Outils, puis trouver "Gestionnaire de packages NuGet > Gérer les packages NuGet pour la solution".
Ensuite, recherchez simplement iText 7 et cliquez sur "Installer".
using System.IO;
using iText.Kernel.Pdf;
using iText.Layout;
using iText.Layout.Element;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.GeneratePdfWithIText7();
// Save the PDF to a file
File.WriteAllBytes("output.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] GeneratePdfWithIText7()
{
using (var ms = new MemoryStream())
{
PdfWriter writer = new PdfWriter(ms);
var pdf = new iText.Kernel.Pdf.PdfDocument(writer);
Document doc = new Document(pdf);
doc.Add(new Paragraph("Hello from iText 7 for .NET!"));
doc.Close(); // Always close the document to finalize content
return ms.ToArray();
}
}
}using System.IO;
using iText.Kernel.Pdf;
using iText.Layout;
using iText.Layout.Element;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.GeneratePdfWithIText7();
// Save the PDF to a file
File.WriteAllBytes("output.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] GeneratePdfWithIText7()
{
using (var ms = new MemoryStream())
{
PdfWriter writer = new PdfWriter(ms);
var pdf = new iText.Kernel.Pdf.PdfDocument(writer);
Document doc = new Document(pdf);
doc.Add(new Paragraph("Hello from iText 7 for .NET!"));
doc.Close(); // Always close the document to finalize content
return ms.ToArray();
}
}
}Imports System.IO
Imports iText.Kernel.Pdf
Imports iText.Layout
Imports iText.Layout.Element
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim pdfGenerator As New PdfGenerator()
Dim pdfBytes() As Byte = pdfGenerator.GeneratePdfWithIText7()
' Save the PDF to a file
File.WriteAllBytes("output.pdf", pdfBytes)
End Sub
End Class
Friend Class PdfGenerator
Public Function GeneratePdfWithIText7() As Byte()
Using ms = New MemoryStream()
Dim writer As New PdfWriter(ms)
Dim pdf = New iText.Kernel.Pdf.PdfDocument(writer)
Dim doc As New Document(pdf)
doc.Add(New Paragraph("Hello from iText 7 for .NET!"))
doc.Close() ' Always close the document to finalize content
Return ms.ToArray()
End Using
End Function
End ClassFichier PDF de sortie
Explication
Après l'appel à doc.Close(), le contenu PDF est complètement écrit et prêt à être retourné sous forme de tableau d'octets.
Cet exemple met en valeur l’API plus modulaire et lisible d’iText 7 par rapport à iTextSharp. Cependant, il manque toujours de support natif pour le rendu HTML/CSS à moins d'inclure pdfhtml, qui est licencié séparément.
Avantages :
Contrôle PDF Complet
iText 7 offre un contrôle complet sur les éléments PDF, tels que les tableaux, les formulaires et les signatures numériques. Cela le rend idéal pour les applications nécessitant une forte conformité qui exigent des normes PDF spécifiques, telles que PDF/A ou PDF/UA.
Modulaire et évolutif
iText 7 est modulaire, ce qui signifie que vous pouvez installer uniquement les modules spécifiques dont vous avez besoin (par exemple, pdfhtml pour la conversion de HTML en PDF). Cela permet une mise en œuvre plus légère si vous n'utilisez pas toutes les fonctionnalités.
Prend en charge les normes PDF complexes
iText 7 prend en charge les normes ISO telles que PDF/A (archivage), PDF/UA (accessibilité) et PDF/X (impression), ce qui le rend adapté aux environnements professionnels et juridiques où la conformité est cruciale.
Documentation riche et support
iText 7 dispose d'une documentation complète et d'une grande communauté. L'entreprise propose également un support professionnel, garantissant que les développeurs peuvent obtenir de l'aide en cas de besoin.
Version gratuite disponible (AGPL)
Les développeurs peuvent utiliser iText 7 gratuitement sous la licence AGPL, ce qui est idéal pour les projets open-source ou un usage personnel.
Inconvénients :
Licence AGPL pour utilisation commerciale
Bien qu'iText 7 propose une version gratuite, les utilisateurs commerciaux doivent se conformer à la licence AGPL, qui exige de publier le code source de tout logiciel utilisant iText 7 ou de payer pour une licence commerciale.
Courbe d'apprentissage abrupte
L'API d'iText 7 est plus complexe et riche en fonctionnalités, ce qui peut entraîner une courbe d'apprentissage plus abrupte par rapport à des bibliothèques plus simples comme IronPDF. Les développeurs doivent se familiariser avec sa structure de document de bas niveau et son architecture basée sur des modules.
Lourd pour des tâches simples
iText 7 peut sembler encombrant pour les tâches PDF de base, comme la création de documents simples ou la conversion HTML en PDF basique, surtout en comparaison avec des bibliothèques comme IronPDF, qui simplifient le processus.
Nécessite des modules externes pour la conversion HTML en PDF
La conversion HTML en PDF dans iText 7 n'est disponible que via le module supplémentaire pdfhtml, qui nécessite une installation séparée et peut ne pas gérer le contenu web moderne aussi facilement que IronPDF.
IronPDF est une bibliothèque .NET de haut niveau conçue pour simplifier la génération de documents PDF en mettant l'accent sur la productivité des développeurs. Il est particulièrement efficace pour le rendu du contenu HTML et le style, ce qui le rend idéal pour les workflows modernes de conversion web en PDF.
IronPDF peut également être installé via NuGet, en exécutant la commande suivante dans la console du gestionnaire de packages NuGet :
Install-Package IronPdfInstall-Package IronPdf'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Install-Package IronPdf
Alternativement, vous pouvez l'installer via le gestionnaire de packages NuGet pour l'écran de Solution. Pour ce faire, accédez à "Outils > Gestionnaire de packages NuGet > Gérer les packages NuGet pour la solution".
Ensuite, recherchez IronPDF et cliquez sur "Installer".
Après l'installation, vous pouvez commencer à rendre des pages HTML complètes en PDF en quelques secondes—aucun module supplémentaire n'est requis. Il prend en charge les CSS modernes, JavaScript, et même le contenu web interactif sans configuration supplémentaire.
using IronPdf;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.GeneratePdfWithIronPdf();
// Save the PDF to a file
File.WriteAllBytes("output.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] GeneratePdfWithIronPdf()
{
var renderer = new ChromePdfRenderer();
var pdfDoc = renderer.RenderHtmlAsPdf("<h1>Hello from IronPDF!</h1>");
return pdfDoc.BinaryData;
}
}using IronPdf;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.GeneratePdfWithIronPdf();
// Save the PDF to a file
File.WriteAllBytes("output.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] GeneratePdfWithIronPdf()
{
var renderer = new ChromePdfRenderer();
var pdfDoc = renderer.RenderHtmlAsPdf("<h1>Hello from IronPDF!</h1>");
return pdfDoc.BinaryData;
}
}Imports IronPdf
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim pdfGenerator As New PdfGenerator()
Dim pdfBytes() As Byte = pdfGenerator.GeneratePdfWithIronPdf()
' Save the PDF to a file
File.WriteAllBytes("output.pdf", pdfBytes)
End Sub
End Class
Friend Class PdfGenerator
Public Function GeneratePdfWithIronPdf() As Byte()
Dim renderer = New ChromePdfRenderer()
Dim pdfDoc = renderer.RenderHtmlAsPdf("<h1>Hello from IronPDF!</h1>")
Return pdfDoc.BinaryData
End Function
End ClassFichier PDF de sortie
Explication
Avantages :
Rendu HTML en PDF sans effort
Rendre le contenu HTML, CSS et JavaScript directement en PDF avec un style complet, y compris Bootstrap et des polices personnalisées—sans besoin de code de mise en page complexe ou de modules supplémentaires.
Démarrage rapide et API intuitive
Créez des fichiers PDF entièrement stylés en quelques lignes de code, avec une syntaxe claire et une compatibilité complète avec .NET Core et .NET Framework.
Assistance complète pour les technologies web
IronPDF prend en charge JavaScript, CSS modernes, SVG et requêtes média, ce que la plupart des bibliothèques ont du mal à faire à moins d'utiliser des navigateurs sans interface graphique comme Chromium (ce que IronPDF fait en interne).
Gestion intégrée des images et des ressources
Intégrez facilement des images, des fichiers locaux, ou même récupérez des éléments à partir d'URL distantes sans configuration supplémentaire.
Licences perpétuelles et pas d'AGPL
Contrairement à iText 7, IronPDF propose des licences commerciales flexibles sans les restrictions des obligations AGPL open-source.
Excellent pour les vues MVC et Razor
Convertit de manière transparente les vues Razor .cshtml dans les applications ASP.NET en PDFs imprimables.
Inconvénients :
L'utilisation commerciale nécessite une licence
Bien qu'il y ait un essai gratuit, IronPDF n'est pas open source. Les projets avec des budgets serrés peuvent avoir besoin d'évaluer les coûts de licence.
Taille Initiale du Paquet Plus Grande
Étant donné qu'il intègre un moteur Chromium sans tête, le package NuGet est plus lourd que certaines alternatives.
Les exemples de code suivants dans cette section démontrent ces bibliothèques en action, pendant lesquels nous comparerons IronPDF et iText 7 en utilisant les mêmes tâches. Les deux bibliothèques seront soumises aux mêmes scénarios : générer un PDF à partir d'une URL, rendre une image sous forme de PDF, et convertir du HTML stylisé en PDF, tout en utilisant des tableaux d'octets pour gérer notre contenu PDF. Cela permettra aux développeurs d'évaluer comment chaque bibliothèque aborde ces cas d'utilisation courants.
using IronPdf;
using System.IO;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.GeneratePdfFromUrlWithIronPdf();
// Save the PDF to a file
File.WriteAllBytes("ironpdf-from-url.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] GeneratePdfFromUrlWithIronPdf()
{
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.JavaScript(5000);
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
var pdf = renderer.RenderUrlAsPdf("https://www.apple.com");
return pdf.BinaryData;
}
}using IronPdf;
using System.IO;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.GeneratePdfFromUrlWithIronPdf();
// Save the PDF to a file
File.WriteAllBytes("ironpdf-from-url.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] GeneratePdfFromUrlWithIronPdf()
{
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.JavaScript(5000);
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
var pdf = renderer.RenderUrlAsPdf("https://www.apple.com");
return pdf.BinaryData;
}
}Imports IronPdf
Imports System.IO
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim pdfGenerator As New PdfGenerator()
Dim pdfBytes() As Byte = pdfGenerator.GeneratePdfFromUrlWithIronPdf()
' Save the PDF to a file
File.WriteAllBytes("ironpdf-from-url.pdf", pdfBytes)
End Sub
End Class
Friend Class PdfGenerator
Public Function GeneratePdfFromUrlWithIronPdf() As Byte()
Dim renderer = New ChromePdfRenderer()
renderer.RenderingOptions.EnableJavaScript = True
renderer.RenderingOptions.WaitFor.JavaScript(5000)
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print
Dim pdf = renderer.RenderUrlAsPdf("https://www.apple.com")
Return pdf.BinaryData
End Function
End ClassOutput PDF
✅ IronPDF utilise un moteur Chromium sans tête pour un rendu pixel-perfect des pages web avec un support complet de JavaScript et CSS.
using iText.Kernel.Pdf;
using iText.Layout;
using iText.Layout.Element;
using System.Net.Http;
using System.Threading.Tasks;
using iText.Html2pdf;
class Program
{
static async Task Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = await pdfGenerator.GeneratePdfFromUrlWithIText7Async();
// Save the PDF to a file
File.WriteAllBytes("itext7-from-url.pdf", pdfBytes);
}
}
class PdfGenerator
{
public async Task<byte[]> GeneratePdfFromUrlWithIText7Async()
{
using var httpClient = new HttpClient();
string html = await httpClient.GetStringAsync("https://www.apple.com");
using var stream = new MemoryStream();
HtmlConverter.ConvertToPdf(html, stream);
return stream.ToArray();
}
}using iText.Kernel.Pdf;
using iText.Layout;
using iText.Layout.Element;
using System.Net.Http;
using System.Threading.Tasks;
using iText.Html2pdf;
class Program
{
static async Task Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = await pdfGenerator.GeneratePdfFromUrlWithIText7Async();
// Save the PDF to a file
File.WriteAllBytes("itext7-from-url.pdf", pdfBytes);
}
}
class PdfGenerator
{
public async Task<byte[]> GeneratePdfFromUrlWithIText7Async()
{
using var httpClient = new HttpClient();
string html = await httpClient.GetStringAsync("https://www.apple.com");
using var stream = new MemoryStream();
HtmlConverter.ConvertToPdf(html, stream);
return stream.ToArray();
}
}Imports iText.Kernel.Pdf
Imports iText.Layout
Imports iText.Layout.Element
Imports System.Net.Http
Imports System.Threading.Tasks
Imports iText.Html2pdf
Friend Class Program
Shared Async Function Main(ByVal args() As String) As Task
Dim pdfGenerator As New PdfGenerator()
Dim pdfBytes() As Byte = Await pdfGenerator.GeneratePdfFromUrlWithIText7Async()
' Save the PDF to a file
File.WriteAllBytes("itext7-from-url.pdf", pdfBytes)
End Function
End Class
Friend Class PdfGenerator
Public Async Function GeneratePdfFromUrlWithIText7Async() As Task(Of Byte())
Dim httpClient As New HttpClient()
Dim html As String = Await httpClient.GetStringAsync("https://www.apple.com")
Dim stream = New MemoryStream()
HtmlConverter.ConvertToPdf(html, stream)
Return stream.ToArray()
End Function
End ClassSortie
⚠️ iText 7 récupère le HTML brut avec l'HttpClient et le rend à l'aide de HtmlConverter, mais il ne prend pas en charge JavaScript et dispose de capacités de style CSS limitées.
using IronPdf;
using System.IO;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.CreatePdfWithImage();
// Save the PDF to a file
File.WriteAllBytes("ironpdf-with-image.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] CreatePdfWithImage()
{
var pdf = ImageToPdfConverter.ImageToPdf("example.png");
return pdf.BinaryData;
}
}using IronPdf;
using System.IO;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.CreatePdfWithImage();
// Save the PDF to a file
File.WriteAllBytes("ironpdf-with-image.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] CreatePdfWithImage()
{
var pdf = ImageToPdfConverter.ImageToPdf("example.png");
return pdf.BinaryData;
}
}Imports IronPdf
Imports System.IO
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim pdfGenerator As New PdfGenerator()
Dim pdfBytes() As Byte = pdfGenerator.CreatePdfWithImage()
' Save the PDF to a file
File.WriteAllBytes("ironpdf-with-image.pdf", pdfBytes)
End Sub
End Class
Friend Class PdfGenerator
Public Function CreatePdfWithImage() As Byte()
Dim pdf = ImageToPdfConverter.ImageToPdf("example.png")
Return pdf.BinaryData
End Function
End ClassSortie
✅ Génération facile d'images en PDF avec l'outil ImageToPdfConverter de IronPDF. Avec cela, vous pouvez facilement créer des fichiers PDF à partir d'images telles que des fichiers PNG ou JPG.
using iText.Kernel.Pdf;
using iText.Layout;
using iText.IO.Image;
using iText.Layout.Element;
using System.IO;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.CreatePdfWithImage();
// Save the PDF to a file
File.WriteAllBytes("iText-with-image.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] CreatePdfWithImage()
{
using var ms = new MemoryStream();
using var writer = new PdfWriter(ms);
using var pdfDoc = new iText.Kernel.Pdf.PdfDocument(writer);
var document = new Document(pdfDoc);
var img = new Image(ImageDataFactory.Create("https://itextpdf.com/sites/default/files/2018-11/iText%207%20Product%20software%20-%20webimages_509x339px_V2_iText%207%20Core.png"));
document.Add(img);
document.Close();
return ms.ToArray();
}
}using iText.Kernel.Pdf;
using iText.Layout;
using iText.IO.Image;
using iText.Layout.Element;
using System.IO;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.CreatePdfWithImage();
// Save the PDF to a file
File.WriteAllBytes("iText-with-image.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] CreatePdfWithImage()
{
using var ms = new MemoryStream();
using var writer = new PdfWriter(ms);
using var pdfDoc = new iText.Kernel.Pdf.PdfDocument(writer);
var document = new Document(pdfDoc);
var img = new Image(ImageDataFactory.Create("https://itextpdf.com/sites/default/files/2018-11/iText%207%20Product%20software%20-%20webimages_509x339px_V2_iText%207%20Core.png"));
document.Add(img);
document.Close();
return ms.ToArray();
}
}Imports iText.Kernel.Pdf
Imports iText.Layout
Imports iText.IO.Image
Imports iText.Layout.Element
Imports System.IO
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim pdfGenerator As New PdfGenerator()
Dim pdfBytes() As Byte = pdfGenerator.CreatePdfWithImage()
' Save the PDF to a file
File.WriteAllBytes("iText-with-image.pdf", pdfBytes)
End Sub
End Class
Friend Class PdfGenerator
Public Function CreatePdfWithImage() As Byte()
Dim ms = New MemoryStream()
Dim writer = New PdfWriter(ms)
Dim pdfDoc = New iText.Kernel.Pdf.PdfDocument(writer)
Dim document As New Document(pdfDoc)
Dim img = New Image(ImageDataFactory.Create("https://itextpdf.com/sites/default/files/2018-11/iText%207%20Product%20software%20-%20webimages_509x339px_V2_iText%207%20Core.png"))
document.Add(img)
document.Close()
Return ms.ToArray()
End Function
End ClassSortie
🟡 Création manuelle de la mise en page du document et insertion explicite d'images en utilisant ImageDataFactory.
using iText.Kernel.Pdf;
using iText.Layout;
using iText.IO.Image;
using iText.Layout.Element;
using System.IO;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.CreateStyledPdf();
// Save the PDF to a file
File.WriteAllBytes("ironpdf-styled-html.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] CreateStyledPdf()
{
string html = @"
<html>
<head>
<style>
body {
background-color: #f0f0f0;
margin: 20px;
padding: 20px;
border-radius: 5px;
box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
}
h1 {
color: navy;
font-size: 32px;
text-align: center;
}
p {
font-size: 16px;
font-weight: bold;
}
</style>
</head>
<body>
<h1>Welcome to IronPDF</h1>
<p>This is a simple PDF document generated using IronPDF.</p>
</body>
</html>";
var pdf = new ChromePdfRenderer().RenderHtmlAsPdf(html);
return pdf.BinaryData;
}
}using iText.Kernel.Pdf;
using iText.Layout;
using iText.IO.Image;
using iText.Layout.Element;
using System.IO;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.CreateStyledPdf();
// Save the PDF to a file
File.WriteAllBytes("ironpdf-styled-html.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] CreateStyledPdf()
{
string html = @"
<html>
<head>
<style>
body {
background-color: #f0f0f0;
margin: 20px;
padding: 20px;
border-radius: 5px;
box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
}
h1 {
color: navy;
font-size: 32px;
text-align: center;
}
p {
font-size: 16px;
font-weight: bold;
}
</style>
</head>
<body>
<h1>Welcome to IronPDF</h1>
<p>This is a simple PDF document generated using IronPDF.</p>
</body>
</html>";
var pdf = new ChromePdfRenderer().RenderHtmlAsPdf(html);
return pdf.BinaryData;
}
}Imports iText.Kernel.Pdf
Imports iText.Layout
Imports iText.IO.Image
Imports iText.Layout.Element
Imports System.IO
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim pdfGenerator As New PdfGenerator()
Dim pdfBytes() As Byte = pdfGenerator.CreateStyledPdf()
' Save the PDF to a file
File.WriteAllBytes("ironpdf-styled-html.pdf", pdfBytes)
End Sub
End Class
Friend Class PdfGenerator
Public Function CreateStyledPdf() As Byte()
Dim html As String = "
<html>
<head>
<style>
body {
background-color: #f0f0f0;
margin: 20px;
padding: 20px;
border-radius: 5px;
box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
}
h1 {
color: navy;
font-size: 32px;
text-align: center;
}
p {
font-size: 16px;
font-weight: bold;
}
</style>
</head>
<body>
<h1>Welcome to IronPDF</h1>
<p>This is a simple PDF document generated using IronPDF.</p>
</body>
</html>"
Dim pdf = (New ChromePdfRenderer()).RenderHtmlAsPdf(html)
Return pdf.BinaryData
End Function
End ClassSortie
✅ IronPDF prend entièrement en charge le CSS dans les balises ou les feuilles de style externes grâce à son moteur Chromium.
using iText.Kernel.Pdf;
using iText.Layout;
using iText.IO.Image;
using iText.Layout.Element;
using System.IO;
using iText.Html2pdf;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.CreateStyledPdf();
// Save the new document to the specified file location
File.WriteAllBytes("iText-styled-html.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] CreateStyledPdf()
{
string html = @"
<html>
<head>
<style>
body {
background-color: #f0f0f0;
margin: 20px;
padding: 20px;
border-radius: 5px;
box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
}
h1 {
color: navy;
font-size: 32px;
text-align: center;
}
p {
font-size: 16px;
font-weight: bold;
}
</style>
</head>
<body>
<h1>Welcome to iText 7</h1>
<p>This is a simple PDF document generated using iText 7 and pdfHTML.</p>
</body>
</html>";
using var ms = new MemoryStream();
ConverterProperties properties = new ConverterProperties();
HtmlConverter.ConvertToPdf(new MemoryStream(System.Text.Encoding.UTF8.GetBytes(html)), ms, properties);
return ms.ToArray();
}
}using iText.Kernel.Pdf;
using iText.Layout;
using iText.IO.Image;
using iText.Layout.Element;
using System.IO;
using iText.Html2pdf;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.CreateStyledPdf();
// Save the new document to the specified file location
File.WriteAllBytes("iText-styled-html.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] CreateStyledPdf()
{
string html = @"
<html>
<head>
<style>
body {
background-color: #f0f0f0;
margin: 20px;
padding: 20px;
border-radius: 5px;
box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
}
h1 {
color: navy;
font-size: 32px;
text-align: center;
}
p {
font-size: 16px;
font-weight: bold;
}
</style>
</head>
<body>
<h1>Welcome to iText 7</h1>
<p>This is a simple PDF document generated using iText 7 and pdfHTML.</p>
</body>
</html>";
using var ms = new MemoryStream();
ConverterProperties properties = new ConverterProperties();
HtmlConverter.ConvertToPdf(new MemoryStream(System.Text.Encoding.UTF8.GetBytes(html)), ms, properties);
return ms.ToArray();
}
}Imports iText.Kernel.Pdf
Imports iText.Layout
Imports iText.IO.Image
Imports iText.Layout.Element
Imports System.IO
Imports iText.Html2pdf
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim pdfGenerator As New PdfGenerator()
Dim pdfBytes() As Byte = pdfGenerator.CreateStyledPdf()
' Save the new document to the specified file location
File.WriteAllBytes("iText-styled-html.pdf", pdfBytes)
End Sub
End Class
Friend Class PdfGenerator
Public Function CreateStyledPdf() As Byte()
Dim html As String = "
<html>
<head>
<style>
body {
background-color: #f0f0f0;
margin: 20px;
padding: 20px;
border-radius: 5px;
box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
}
h1 {
color: navy;
font-size: 32px;
text-align: center;
}
p {
font-size: 16px;
font-weight: bold;
}
</style>
</head>
<body>
<h1>Welcome to iText 7</h1>
<p>This is a simple PDF document generated using iText 7 and pdfHTML.</p>
</body>
</html>"
Dim ms = New MemoryStream()
Dim properties As New ConverterProperties()
HtmlConverter.ConvertToPdf(New MemoryStream(System.Text.Encoding.UTF8.GetBytes(html)), ms, properties)
Return ms.ToArray()
End Function
End ClassSortie
⚠️Nécessite l'installation de l'add-on payant pdfHTML pour gérer les tâches de conversion HTML.
Caractéristique IronPDF iText 7 (avec pdfHTML)
Rendre une URL en PDF ✅ Rendu Chromium complet ⚠️ Extraire HTML, pas de prise en charge native de JS
Ajouter une image ✅ Intégrer via HTML ou son outil dédié de tamponnage d'image ✅ Usine d'image manuelle
Rendre le HTML stylisé ✅ Prise en charge complète du CSS ⚠️ Prise en charge du CSS uniquement via pdfHTML
Renvoie un tableau de bytes ✅ Oui ✅ Oui
Complexité de Configuration ⭐ Simple ⭐⭐ Modéré (mise en page manuelle)
Qualité de sortie ⭐⭐⭐⭐⭐ Pixel-perfect ⭐⭐⭐ Bon mais statique
Choisir entre IronPDF et iText 7 dépend des besoins de votre projet — mais en ce qui concerne l'expérience du développeur, la facilité d'utilisation et la précision de rendu moderne, IronPDF se distingue clairement.
Si vous travaillez avec du contenu HTML dynamique, le rendu web, ou si vous avez besoin de créer des fichiers PDF à partir d'URLs avec un support complet de JavaScript et CSS, le moteur basé sur Chromium d'IronPDF offre une fidélité inégalée. Son API intuitive et son installation rapide le rendent idéal pour un développement rapide et une utilisation en production réelle — particulièrement lorsqu'il s'agit de travailler avec des tableaux d'octets, des flux de fichiers ou la génération de PDF basée sur le web.
D'un autre côté, iText 7 est une bibliothèque puissante et bien respectée avec une approche plus traditionnelle axée sur la mise en page. Il offre un contrôle solide sur la structure des documents et convient aux développeurs qui ont besoin d'une manipulation fine, mais il présente une courbe d'apprentissage plus raide et manque de capacités de rendu HTML modernes.
Voici l'essentiel :
Besoin d'outils de création PDF de bas niveau avec un contrôle granulaire ? iText 7 pourrait être le bon choix.
🚀 Prêt à commencer avec IronPDF ?
Téléchargez l'essai gratuit et découvrez à quel point il est facile de créer des PDF professionnels basés sur un tableau d'octets en C# avec seulement quelques lignes de code.
Install-Package IronPdf
Aucune carte de crédit n'est requise
Votre clé d'essai devrait se trouver dans l'email.
Le formulaire d'essai a été soumis
avec succès.
Si ce n'est pas le cas, veuillez contacter
support@ironsoftware.com
Aucune carte de crédit n'est requise
Commencez GRATUITEMENT
Aucune carte de crédit n'est requise
Testez en production sans filigranes.
Fonctionne là où vous en avez besoin.
Obtenez 30 jours de produit entièrement fonctionnel.
Faites-le fonctionner en quelques minutes.
Accès complet à notre équipe d'ingénieurs pendant la période d'essai du produit
Aucune carte de crédit ou création de compte n'est nécessaire
Votre clé d'essai devrait être dans l'e-mail.
Si ce n'est pas le cas, veuillez contacter
support@ironsoftware.com
Commencez GRATUITEMENT
Aucune carte de crédit n'est requise
Testez en production sans filigranes.
Fonctionne là où vous en avez besoin.
Obtenez 30 jours de produit entièrement fonctionnel.
Faites-le fonctionner en quelques minutes.
Accès complet à notre équipe d'ingénieurs pendant la période d'essai du produit
Licences à partir de 749 $. Vous avez une question ? Contactez-nous.
Réservez une démonstration personnelle de 30 minutes.
Pas de contrat, pas de détails de carte, pas d'engagements.
10 produits .NET API pour vos documents de bureau
