Iron Suite for .NET
10 bibliothèques .NET. Une suite de documents complète.
Telerik Document Processing vs IronPDF : Guide de comparaison technique
.NET 8 a introduit des changements au niveau de l'exécution qui rompent la compatibilité avec de nombreuses bibliothèques PDF traditionnelles. System.Drawing.Common est obsolète sur les plateformes non Windows, Native AOT impose de nouvelles contraintes sur les bibliothèques à forte réflexion, et le modèle de déploiement "container-first" expose des problèmes de dépendance qui n'apparaissaient pas sur les machines de développement Windows. Les bibliothèques qui fonctionnaient sous .NET Framework ou même .NET 6 peuvent échouer avec des erreurs NU1202, DllNotFoundException, ou PlatformNotSupportedException dans .NET 8.
Cet article indique quelles bibliothèques PDF fonctionnent avec .NET 8, montre les erreurs spécifiques que vous rencontrerez avec des bibliothèques incompatibles et fournit des configurations de déploiement pour Docker et Azure Functions.
Démarrage rapide : Générer un PDF à partir de HTML en .NET 8
using IronPdf;
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
var pdf = renderer.RenderHtmlAsPdf(@"
<html>
<head><style>
body { font-family: 'Segoe UI', sans-serif; padding: 40px; }
h1 { color: #2563eb; }
table { width: 100%; border-collapse: collapse; margin-top: 20px; }
th { background: #2563eb; color: white; padding: 12px; text-align: left; }
td { padding: 10px; border-bottom: 1px solid #e5e7eb; }
</style></head>
<body>
<h1>Q4 Report</h1>
<table>
<tr><th>Metric</th><th>Value</th><th>Change</th></tr>
<tr><td>Revenue</td><td>$1.2M</td><td>+12%</td></tr>
<tr><td>Users</td><td>45,230</td><td>+23%</td></tr>
</table>
</body></html>");
pdf.SaveAs("report.pdf");Imports IronPdf
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4
Dim pdf = renderer.RenderHtmlAsPdf("
<html>
<head><style>
body { font-family: 'Segoe UI', sans-serif; padding: 40px; }
h1 { color: #2563eb; }
table { width: 100%; border-collapse: collapse; margin-top: 20px; }
th { background: #2563eb; color: white; padding: 12px; text-align: left; }
td { padding: 10px; border-bottom: 1px solid #e5e7eb; }
</style></head>
<body>
<h1>Q4 Report</h1>
<table>
<tr><th>Metric</th><th>Value</th><th>Change</th></tr>
<tr><td>Revenue</td><td>$1.2M</td><td>+12%</td></tr>
<tr><td>Users</td><td>45,230</td><td>+23%</td></tr>
</table>
</body></html>")
pdf.SaveAs("report.pdf")Installez via NuGet : Install-Package IronPdf. Cible net8.0 sans configuration supplémentaire. Déploiement sur Windows, Linux, macOS, Docker et Azure sans configuration spécifique à la plateforme.
Pourquoi les anciennes bibliothèques PDF échouent-elles dans .NET 8?
iText— Non compatible avec .NET 8
iText (le portage original de iTextfor .NET) n'a pas été mis à jour depuis 2018. Il cible uniquement .NET Framework :
erreur NU1202 : Le paquet iTextSharp 5.5.13 n'est pas compatible avec net8.0Le chemin de migration est iText, qui a une API différente et nécessite soit la conformité avec l'AGPL (rendre votre application entière open-source) soit une licence commerciale. Le prix n'est pas publié - des données de tiers suggèrent 15 000 à 210 000 dollars par an.
wkhtmltopdf Wrappers - DLL Loading Failures on .NET 8 (en anglais)
Les wrappers C# autour de wkhtmltopdf (DinkToPdf, Rotativa, NReco.PdfGenerator) échouent avec des erreurs spécifiques à la plateforme qui sont propres au modèle de déploiement de .NET 8 :
DinkToPdf - bibliothèque native non trouvée :
System.DllNotFoundException : Impossible de charger la DLL 'libwkhtmltox'Rotativa.AspNetCore - nécessite une configuration manuelle du chemin binaire qui entre en conflit avec le déploiement en conteneur de .NET 8 :
// This pattern requires deploying wkhtmltopdf binaries alongside your app
// and breaks in Docker containers without explicit path configuration
RotativaConfiguration.Setup(env.WebRootPath, "wkhtmltopdf");' This pattern requires deploying wkhtmltopdf binaries alongside your app
' and breaks in Docker containers without explicit path configuration
RotativaConfiguration.Setup(env.WebRootPath, "wkhtmltopdf")TuesPechkin / NReco - inadéquation de l'architecture :
System.BadImageFormatException : Impossible de charger le fichier ou l'assemblageCes erreurs reflètent un problème plus profond : wkhtmltopdf a été archivé en juillet 2024 avec des CVE non corrigées. L'architecture binaire native est antérieure aux améliorations de la détection de plateforme de .NET 8. Il n'y a pas de solution - seulement une migration vers une autre bibliothèque.
PDFSharp— Échecs System.Drawing.Common sur Linux
PDFSharp dépend de System.Drawing.Common, que Microsoft a déprécié pour les plateformes autres que Windows dans .NET 6. Sous .NET 8, cela produit des échecs d'exécution lors du déploiement sur Linux ou Docker :
using PdfSharp.Pdf;
using PdfSharp.Drawing;
var document = new PdfDocument();
// PlatformNotSupportedException on Linux:
// System.Drawing.Common is not supported on this platformImports PdfSharp.Pdf
Imports PdfSharp.Drawing
Dim document As New PdfDocument()
' PlatformNotSupportedException on Linux:
' System.Drawing.Common is not supported on this platformPDFSharp 6.x travaille à supprimer cette dépendance, mais le support multiplateforme reste incomplet début 2026. Pour les déploiements uniquement sur Windows,PDFSharpfonctionne avec .NET 8. Pour Linux, Docker ou les déploiements cloud, il est peu fiable.
Quelles sont les bibliothèques PDF compatibles avec .NET 8?
IronPDF- Prise en charge complète de .NET 8, multiplateforme
IronPDF cible net8.0 nativement avec le rendu Chromium intégré. Pas de dépendance System.Drawing.Common, pas de gestion native des binaires, pas de configuration spécifique à la plateforme.
Intégration minimale des API (le principal modèle de .NET 8) :
using IronPdf;
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
app.MapGet("/invoice/{id}/pdf", async (int id, InvoiceService service) =>
{
var invoice = await service.GetInvoiceAsync(id);
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(invoice.ToHtml());
return Results.File(pdf.BinaryData, "application/pdf", $"invoice-{id}.pdf");
});
app.Run();Imports IronPdf
Dim builder = WebApplication.CreateBuilder(args)
Dim app = builder.Build()
app.MapGet("/invoice/{id}/pdf", Async Function(id As Integer, service As InvoiceService)
Dim invoice = Await service.GetInvoiceAsync(id)
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(invoice.ToHtml())
Return Results.File(pdf.BinaryData, "application/pdf", $"invoice-{id}.pdf")
End Function)
app.Run()Pour les équipes utilisant le modèle de contrôleur, le même code fonctionne à l'intérieur d'une action de contrôleur — RenderHtmlAsPdf renvoie un PdfDocument que vous pouvez convertir en octets avec .BinaryData.
Licences : Licence perpétuelle à partir de $liteLicense (Lite — 1 développeur, 1 projet). Professionnel : 1 499 $ (10 développeurs). Enterprise : 2 999 $ (Unlimited). Publié sur ironpdf.com.
QuestPDF - Compatible .NET 8, Pas de HTML
QuestPDF fonctionne avec .NET 8 sans dépendance de plateforme. Son API C# fluide construit des documents de manière programmatique - pas d'analyseur HTML, pas de moteur CSS, pas de moteur de navigateur :
using QuestPDF.Fluent;
using QuestPDF.Infrastructure;
QuestPDF.Settings.License = LicenseType.Community; // Free under $1M revenue
Document.Create(container =>
{
container.Page(page =>
{
page.Size(PageSizes.A4);
page.Margin(2, Unit.Centimetre);
page.Content().Column(col =>
{
col.Item().Text("Q4 Report").FontSize(24).Bold();
col.Item().Table(table =>
{
table.ColumnsDefinition(c => { c.RelativeColumn(2); c.RelativeColumn(1); c.RelativeColumn(1); });
table.Header(h =>
{
h.Cell().Text("Metric").Bold();
h.Cell().Text("Value").Bold();
h.Cell().Text("Change").Bold();
});
table.Cell().Text("Revenue"); table.Cell().Text("$1.2M"); table.Cell().Text("+12%");
table.Cell().Text("Users"); table.Cell().Text("45,230"); table.Cell().Text("+23%");
});
});
});
}).GeneratePdf("report.pdf");Imports QuestPDF.Fluent
Imports QuestPDF.Infrastructure
QuestPDF.Settings.License = LicenseType.Community ' Free under $1M revenue
Document.Create(Sub(container)
container.Page(Sub(page)
page.Size(PageSizes.A4)
page.Margin(2, Unit.Centimetre)
page.Content().Column(Sub(col)
col.Item().Text("Q4 Report").FontSize(24).Bold()
col.Item().Table(Sub(table)
table.ColumnsDefinition(Sub(c)
c.RelativeColumn(2)
c.RelativeColumn(1)
c.RelativeColumn(1)
End Sub)
table.Header(Sub(h)
h.Cell().Text("Metric").Bold()
h.Cell().Text("Value").Bold()
h.Cell().Text("Change").Bold()
End Sub)
table.Cell().Text("Revenue")
table.Cell().Text("$1.2M")
table.Cell().Text("+12%")
table.Cell().Text("Users")
table.Cell().Text("45,230")
table.Cell().Text("+23%")
End Sub)
End Sub)
End Sub)
End Sub).GeneratePdf("report.pdf")QuestPDF ne convertit pas le HTML. Si votre flux de travail utilise des modèles HTML (vues Razor, exportation de tableaux de bord, archivage de contenu web), vous avez besoin d'une autre bibliothèque. La licence communautaire couvre les entreprises dont le chiffre d'affaires annuel est inférieur à 1 million de dollars ; la traduction doit rester professionnelle, en préservant l'exactitude technique tout en expliquant les caractéristiques et les avantages de ces outils de développement.
iText— Compatible avec .NET 8, sous licence AGPL
iText (le successeur de iText) supporte .NET 8. L'add-on pdfHTML fournit une conversion HTML en PDF avec un analyseur personnalisé — ce n'est pas un moteur de navigateur, donc les fonctionnalités CSS modernes (Flexbox, Grid) ne s'affichent pas correctement.
Licence : AGPL pour l'utilisation de logiciels libres, licence commerciale (abonnement, prix non publié) pour les applications propriétaires. iTextest passé aux licences commerciales par abonnement en 2024.
Déploiement de Docker
Image Debian standard (recommandée)
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY ["MyApp.csproj", "."]
RUN dotnet restore
COPY . .
RUN dotnet publish -c Release -o /app/publish
FROM mcr.microsoft.com/dotnet/aspnet:8.0
WORKDIR /app
# IronPDF works without additional apt-get installs
# Chromium dependencies are handled internally
COPY --from=build /app/publish .
ENV DOTNET_RUNNING_IN_CONTAINER=true
EXPOSE 8080
ENTRYPOINT ["dotnet", "MyApp.dll"]Image alpine (plus petite empreinte)
FROM mcr.microsoft.com/dotnet/sdk:8.0-alpine AS build
WORKDIR /src
COPY ["MyApp.csproj", "."]
RUN dotnet restore
COPY . .
RUN dotnet publish -c Release -o /app/publish
FROM mcr.microsoft.com/dotnet/aspnet:8.0-alpine
WORKDIR /app
# Alpine requires explicit Chromium dependencies
RUN apk add --no-cache chromium nss freetype harfbuzz ca-certificates ttf-freefont
COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "MyApp.dll"]L'image Debian ne nécessite aucun paquet supplémentaire. L'image Alpine est plus petite mais nécessite l'installation explicite de la bibliothèque Chromium. Pour la plupart des déploiements, l'image Debian standard est plus simple et plus fiable.
Azure Functions (travailleur isolé)
les Azure Functions .NET 8 utilisent le modèle de travailleur isolé.IronPDF travaille avec ce modèle pour la génération de PDF à la demande :
using IronPdf;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;
namespace MyApp.Functions;
public class PdfFunctions
{
[Function("GenerateInvoice")]
public async Task<HttpResponseData> GenerateInvoice(
[HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req)
{
var invoice = await req.ReadFromJsonAsync<InvoiceRequest>();
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(BuildInvoiceHtml(invoice));
var response = req.CreateResponse(System.Net.HttpStatusCode.OK);
response.Headers.Add("Content-Type", "application/pdf");
response.Headers.Add("Content-Disposition",
$"attachment; filename=invoice-{invoice.Id}.pdf");
await response.Body.WriteAsync(pdf.BinaryData);
return response;
}
private string BuildInvoiceHtml(InvoiceRequest invoice)
{
return $@"<html><body>
<h1>Invoice #{invoice.Id}</h1>
<p>Amount: ${invoice.Amount:F2}</p>
</body></html>";
}
}
public record InvoiceRequest(string Id, decimal Amount);Imports IronPdf
Imports Microsoft.Azure.Functions.Worker
Imports Microsoft.Azure.Functions.Worker.Http
Namespace MyApp.Functions
Public Class PdfFunctions
<Function("GenerateInvoice")>
Public Async Function GenerateInvoice(
<HttpTrigger(AuthorizationLevel.Function, "post")> req As HttpRequestData) As Task(Of HttpResponseData)
Dim invoice = Await req.ReadFromJsonAsync(Of InvoiceRequest)()
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(BuildInvoiceHtml(invoice))
Dim response = req.CreateResponse(System.Net.HttpStatusCode.OK)
response.Headers.Add("Content-Type", "application/pdf")
response.Headers.Add("Content-Disposition", $"attachment; filename=invoice-{invoice.Id}.pdf")
Await response.Body.WriteAsync(pdf.BinaryData)
Return response
End Function
Private Function BuildInvoiceHtml(invoice As InvoiceRequest) As String
Return $"<html><body>
<h1>Invoice #{invoice.Id}</h1>
<p>Amount: ${invoice.Amount:F2}</p>
</body></html>"
End Function
End Class
Public Class InvoiceRequest
Public Property Id As String
Public Property Amount As Decimal
Public Sub New(id As String, amount As Decimal)
Me.Id = id
Me.Amount = amount
End Sub
End Class
End NamespacePrise en compte du déploiement: Le binaire Chromium d'IronPDF ajoute ~200MB au package de déploiement. Le plan de consommation Azure Functions a une limite de taille de déploiement de 1,5 Go - vérifiez la taille totale de votre package. Pour les plans Premium ou Dedicated, cette limite ne s'applique pas. La latence de démarrage à froid pour la première génération de PDF est de 2 à 5 secondes lors de l'initialisation de Chromium.
Compatibilité native avec AOT
.NET 8 a étendu la prise en charge de l'AOT native, mais les bibliothèques PDF sont confrontées à des contraintes fondamentales. Les bibliothèques basées sur Chromium (IronPDF, Puppeteer Sharp) ne peuvent pas compiler l'AOT car elles intègrent ou génèrent des processus de navigation. iTextutilise une réflexion extensive qui entre en conflit avec la réduction.
Statut actuel avec <PublishAot>true</PublishAot> :
| Bibliothèque | Statut de l'AOT | Raison |
|---|---|---|
| IronPDF | Non compatible | Embarque le moteur d'exécution Chromium |
| iText | Non compatible | Réflexion poussée, génération de code dynamique |
| QuestPDF | Partiel (avec TrimMode=partial) | Quelques exemples d'utilisation |
| PDFSharp | Non compatible | Dépendance System.Drawing.Common |
Si Native AOT est une exigence stricte, QuestPDF avec TrimMode=partial est l'option la plus proche — mais seulement pour la génération de documents programmatiques, pas pour la conversion HTML. Pour les scénarios HTML vers PDF, AOT n'est actuellement viable avec aucune bibliothèque.
Comparaison des licences
| Bibliothèque | Modèle | Coût | prise en charge de .NET 8 |
|---|---|---|---|
| IronPDF | Perpétuel | $liteLicense (Lite) / $1,499 (Pro) / $2,999 (Enterprise) | Complet |
| iText | AGPL ou abonnement | Non publié ($15K-$210K/an est.) | Complet |
| QuestPDF | Communauté / Commercial | Gratuit <1M$ de revenus, puis commercial | Complet |
| PDFSharp | MIT (gratuit) | $0 | Windows uniquement (Linux incomplet) |
| Aspose.PDF | Par développeur | ~$999+ | Complet (problèmes de mémoire sous Linux) |
Compatibilité ascendante de .NET 9
.NET 9 (publié en novembre 2025) poursuit les modèles établis dans .NET 8. Les bibliothèques qui fonctionnent avec .NET 8 fonctionnent généralement avec .NET 9 sans changement. Les principaux ajouts de .NET 9 concernant la génération de PDF sont l'amélioration des performances ARM64 (avantages du rendu basé sur Chromium sur Apple Silicon et AWS Graviton) et la poursuite des améliorations de Native AOT (bien que les contraintes fondamentales pour les bibliothèques PDF restent inchangées).
Si vous visez .NET 9 ou prévoyez une mise à niveau, le choix d'une bibliothèque prenant entièrement en charge le déploiement multiplateforme de .NET 8 est la voie la plus sûre. Les bibliothèques avec des problèmes spécifiques à la plateforme (PDFSharp sur Linux, Aspose avec libgdiplus) sont peu susceptibles de résoudre ces problèmes dans .NET 9 puisque la dépréciation des dépendances sous-jacentes est permanente.
Guide de migration
De iTextà IronPDF
// Before (iTextSharp — doesn't compile against net8.0)
using iTextSharp.text;
using iTextSharp.text.pdf;
var doc = new Document();
PdfWriter.GetInstance(doc, new FileStream("output.pdf", FileMode.Create));
doc.Open();
doc.Add(new Paragraph("Hello World"));
doc.Close();
// After (IronPDF — targets net8.0)
using IronPdf;
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<p>Hello World</p>");
pdf.SaveAs("output.pdf");Imports iTextSharp.text
Imports iTextSharp.text.pdf
Imports IronPdf
Imports System.IO
' Before (iTextSharp — doesn't compile against net8.0)
Dim doc As New Document()
PdfWriter.GetInstance(doc, New FileStream("output.pdf", FileMode.Create))
doc.Open()
doc.Add(New Paragraph("Hello World"))
doc.Close()
' After (IronPDF — targets net8.0)
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf("<p>Hello World</p>")
pdf.SaveAs("output.pdf")Du wkhtmltopdf Wrappers à IronPDF
// Before (DinkToPdf — DllNotFoundException on .NET 8)
var converter = new SynchronizedConverter(new PdfTools());
var doc = new HtmlToPdfDocument
{
Objects = { new ObjectSettings { HtmlContent = html } }
};
var bytes = converter.Convert(doc);
// After (IronPDF — native .NET 8 support)
using IronPdf;
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
var bytes = pdf.BinaryData;Imports IronPdf
' Before (DinkToPdf — DllNotFoundException on .NET 8)
Dim converter = New SynchronizedConverter(New PdfTools())
Dim doc = New HtmlToPdfDocument With {
.Objects = {New ObjectSettings With {.HtmlContent = html}}
}
Dim bytes = converter.Convert(doc)
' After (IronPDF — native .NET 8 support)
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
bytes = pdf.BinaryDataLa surface de l'API est plus simple dans les deux cas. Le principal coût de migration consiste à tester vos modèles HTML existants avec le nouveau moteur de rendu afin de vérifier que le résultat correspond aux attentes.
La recommandation
Pour les projets .NET 8 nécessitant une conversion HTML-PDF :IronPDF fournit un rendu Chromium intégré qui fonctionne sur toutes les plateformes sans configuration. Il gère le déploiement Docker, Azure Functions et les conteneurs Linux dès le départ.
Pour les projets .NET 8, créer des documents de manière programmatique à partir de données : L'API fluide de QuestPDF est bien conçue et compatible avec .NET 8, la Community License couvrant la plupart des startups et des petites équipes.
Pour la manipulation de PDF (fusion, division, formulaires) sous Windows :PDFSharpreste viable si votre cible de déploiement est uniquement Windows.
Évitez iText(non compatible), les wrappers wkhtmltopdf (archivés, CVEs), et toute bibliothèque dépendant de System.Drawing.Common pour le déploiement multiplateforme.
10 API .NET pour vos documents
Liens des produits
- - Créer, lire et modifier des PDF. HTML vers PDF pour .NET.
- - Modifier des fichiers DOCX. Sans Office Interop.
- - Modifier des fichiers Excel et CSV. Sans Office Interop.
- - Créer, lire et modifier des présentations. Sans Office Interop.
- - OCR en 125 langues.
- - Lire et écrire des codes QR et codes-barres.
- - Lire et écrire des QR codes.
- - Compressez et décompressez des archives.
- - Imprimer des documents avec .NET.
- - Extraire des données structurées des sites web.
