Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. Utilisation de IronPDF
  4. Générer un PDF iTextSharp MVC
COMPARAISONS DE PRODUITS

Générer un PDF dans ASP.NET MVC : Guide iTextSharp vs. IronPDF

Curtis Chau
Curtis Chau
Mis à jour:

Full Comparison

Looking for a detailed feature-by-feature breakdown? See how IronPDF stacks up against Itext on pricing, HTML support, and licensing.

View Full Comparison

IronPDF offre une excellente conversion HTML vers PDF avec une prise en charge complète de CSS3 et JavaScript grâce au rendu Chrome. En revanche, iTextSharp propose la création de PDF par programmation, mais peine à gérer la conversion HTML moderne, ce qui fait IronPDF un meilleur choix pour les applications ASP.NET MVC nécessitant des PDF conformes aux normes web.

La création de documents PDF dans les applications ASP.NET MVC est une exigence courante pour générer des rapports, des factures et du contenu téléchargeable. Bien qu'iTextSharp soit un choix populaire depuis des années, IronPDF offre une alternative moderne avec des capacités de rendu HTML supérieures. Cet article explore les deux approches pour vous aider à prendre une décision éclairée concernant vos besoins en matière de génération de PDF .NET .

Les deux bibliothèques résolvent le même problème fondamental — la génération de PDF dans un contexte web .NET — mais elles adoptent des approches fondamentalement différentes. iTextSharp génère des PDF par programmation via un modèle objet, tandis IronPDF convertit le HTML en PDF à l'aide d'un moteur de rendu Chrome complet. Comprendre cette différence architecturale est essentiel pour choisir l'outil adapté. Le framework ASP.NET MVC de Microsoft prend en charge les deux modèles d'intégration, et chaque bibliothèque peut être intégrée au pipeline contrôleur-action standard.

Comment installer chaque bibliothèque ?

Avant d'écrire la moindre ligne de code, vous devez intégrer chaque bibliothèque à votre projet. NuGet est le gestionnaire de packages standard pour .NET et gère les deux types d'installations de manière propre. Pour iTextSharp, installez l'ancien package via NuGet:

dotnet add package iTextSharp
dotnet add package iTextSharp
SHELL

Pour IronPDF, installez-le également via NuGet :

dotnet add package IronPdf
dotnet add package IronPdf
SHELL

IronPDF intègre le moteur de rendu Chrome au package, aucune installation de navigateur supplémentaire n'est donc requise sur votre serveur. La bibliothèque prend en charge nativement les environnements Windows, Linux, macOS et conteneurisés. Après l'installation, ajoutez votre clé de licence IronPDF lors du démarrage de l'application.

Comment générer un PDF en utilisant iTextSharp dans MVC?

Pour générer des fichiers PDF à l'aide d'iTextSharp dans votre application ASP.NET MVC, commencez par installer la bibliothèque via NuGet. La bibliothèque iTextSharp offre un contrôle de bas niveau sur la création de fichiers PDF grâce à sa classe Document et à son modèle objet.

Le code suivant illustre une implémentation prête pour la production permettant de créer des fichiers PDF avec iTextSharp dans un contrôleur MVC :

// Production-ready iTextSharp implementation with proper resource disposal
public class ReportController : Controller
{
    private readonly ILogger<ReportController> _logger;

    public ReportController(ILogger<ReportController> logger)
    {
        _logger = logger;
    }

    public ActionResult GeneratePDF()
    {
        try
        {
            using var memoryStream = new MemoryStream();
            using var document = new Document(PageSize.A4, 50, 50, 25, 25);
            using var writer = PdfWriter.GetInstance(document, memoryStream);

            document.Open();
            document.AddTitle("Generated Report");
            document.AddCreationDate();

            var titleFont = FontFactory.GetFont(FontFactory.HELVETICA_BOLD, 16);
            document.Add(new Paragraph("Hello World", titleFont));
            document.Add(new Paragraph("This is a PDF document created with iTextSharp"));

            var table = new PdfPTable(3);
            table.AddCell("Header 1");
            table.AddCell("Header 2");
            table.AddCell("Header 3");
            document.Add(table);

            document.Close();

            var pdfBytes = memoryStream.ToArray();
            Response.Headers.Add("Content-Disposition", "inline; filename=report.pdf");
            _logger.LogInformation("PDF generated: {Size} bytes", pdfBytes.Length);
            return File(pdfBytes, "application/pdf");
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error generating PDF");
            return StatusCode(500, "Error generating PDF document");
        }
    }
}
// Production-ready iTextSharp implementation with proper resource disposal
public class ReportController : Controller
{
    private readonly ILogger<ReportController> _logger;

    public ReportController(ILogger<ReportController> logger)
    {
        _logger = logger;
    }

    public ActionResult GeneratePDF()
    {
        try
        {
            using var memoryStream = new MemoryStream();
            using var document = new Document(PageSize.A4, 50, 50, 25, 25);
            using var writer = PdfWriter.GetInstance(document, memoryStream);

            document.Open();
            document.AddTitle("Generated Report");
            document.AddCreationDate();

            var titleFont = FontFactory.GetFont(FontFactory.HELVETICA_BOLD, 16);
            document.Add(new Paragraph("Hello World", titleFont));
            document.Add(new Paragraph("This is a PDF document created with iTextSharp"));

            var table = new PdfPTable(3);
            table.AddCell("Header 1");
            table.AddCell("Header 2");
            table.AddCell("Header 3");
            document.Add(table);

            document.Close();

            var pdfBytes = memoryStream.ToArray();
            Response.Headers.Add("Content-Disposition", "inline; filename=report.pdf");
            _logger.LogInformation("PDF generated: {Size} bytes", pdfBytes.Length);
            return File(pdfBytes, "application/pdf");
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error generating PDF");
            return StatusCode(500, "Error generating PDF document");
        }
    }
}
Imports System
Imports System.IO
Imports Microsoft.AspNetCore.Mvc
Imports Microsoft.Extensions.Logging
Imports iTextSharp.text
Imports iTextSharp.text.pdf

Public Class ReportController
    Inherits Controller

    Private ReadOnly _logger As ILogger(Of ReportController)

    Public Sub New(logger As ILogger(Of ReportController))
        _logger = logger
    End Sub

    Public Function GeneratePDF() As ActionResult
        Try
            Using memoryStream As New MemoryStream()
                Using document As New Document(PageSize.A4, 50, 50, 25, 25)
                    Using writer As PdfWriter = PdfWriter.GetInstance(document, memoryStream)
                        document.Open()
                        document.AddTitle("Generated Report")
                        document.AddCreationDate()

                        Dim titleFont As Font = FontFactory.GetFont(FontFactory.HELVETICA_BOLD, 16)
                        document.Add(New Paragraph("Hello World", titleFont))
                        document.Add(New Paragraph("This is a PDF document created with iTextSharp"))

                        Dim table As New PdfPTable(3)
                        table.AddCell("Header 1")
                        table.AddCell("Header 2")
                        table.AddCell("Header 3")
                        document.Add(table)

                        document.Close()

                        Dim pdfBytes As Byte() = memoryStream.ToArray()
                        Response.Headers.Add("Content-Disposition", "inline; filename=report.pdf")
                        _logger.LogInformation("PDF generated: {Size} bytes", pdfBytes.Length)
                        Return File(pdfBytes, "application/pdf")
                    End Using
                End Using
            End Using
        Catch ex As Exception
            _logger.LogError(ex, "Error generating PDF")
            Return StatusCode(500, "Error generating PDF document")
        End Try
    End Function
End Class
$vbLabelText   $csharpLabel

À quoi ressemble le résultat d'iTextSharp ?

Visionneuse PDF affichant un document simple avec l'en-tête " Hello World " et le sous-titre " Ceci est un document PDF créé avec iTextSharp " sur fond blanc, illustrant les fonctionnalités de base de la bibliothèque en matière de mise en forme de texte et de tableaux pour la génération de PDF par programmation.

Ce code illustre l'approche fondamentale : créer une instance Document, attacher un PdfWriter à un flux, ajouter du contenu à l'aide d'objets d'éléments et renvoyer le fichier via un résultat d'action. Cette implémentation gère les modèles de gestion des ressources essentiels aux systèmes de production. Pour des scénarios plus avancés, vous pouvez configurer des formats de papier personnalisés , gérer l'orientation des pages ou ajouter des numéros de page .

L'approche programmatique vous offre un contrôle précis sur chaque élément de la page. Cette précision est utile lors de la génération de documents à mise en page fixe, tels que les factures, les certificats ou les formulaires, dont la structure est toujours la même. Cependant, cela devient un fardeau dès lors que le contenu est dynamique ou piloté par un modèle HTML.

Quels sont les défis liés à la conversion de HTML en PDF avec la bibliothèque iTextSharp ?

Si iTextSharp excelle dans la création programmatique de PDF, la conversion de HTML en PDF présente des défis importants. La classe obsolète HTMLWorker et son remplaçant XMLWorker ont une prise en charge CSS limitée et ont du mal avec le contenu Web moderne, en particulier lorsqu'il s'agit de CSS réactif et de contenu rendu en JavaScript .

// HTML conversion with iTextSharp -- note the CSS limitations
public class HtmlToPdfController : Controller
{
    private readonly ILogger<HtmlToPdfController> _logger;

    public HtmlToPdfController(ILogger<HtmlToPdfController> logger)
    {
        _logger = logger;
    }

    public async Task<ActionResult> ConvertHtmlAsync(string htmlContent)
    {
        if (string.IsNullOrWhiteSpace(htmlContent))
            return BadRequest("HTML content is required");

        return await Task.Run(() =>
        {
            using var stream = new MemoryStream();
            using var document = new Document(PageSize.A4);
            using var writer = PdfWriter.GetInstance(document, stream);

            document.Open();

            var cssResolver = XMLWorkerHelper.GetInstance().GetDefaultCssResolver(true);
            var fontProvider = new XMLWorkerFontProvider();
            var cssAppliers = new CssAppliersImpl(fontProvider);
            var htmlContext = new HtmlPipelineContext(cssAppliers);
            htmlContext.SetTagFactory(Tags.GetHtmlTagProcessorFactory());

            // Pipeline with limited CSS3 support
            var pdf = new PdfWriterPipeline(document, writer);
            var html = new HtmlPipeline(htmlContext, pdf);
            var css = new CssResolverPipeline(cssResolver, html);

            var worker = new XMLWorker(css, true);
            var parser = new XMLParser(worker);

            using var stringReader = new StringReader(htmlContent);
            parser.Parse(stringReader);
            document.Close();

            return File(stream.ToArray(), "application/pdf", "converted.pdf");
        });
    }
}
// HTML conversion with iTextSharp -- note the CSS limitations
public class HtmlToPdfController : Controller
{
    private readonly ILogger<HtmlToPdfController> _logger;

    public HtmlToPdfController(ILogger<HtmlToPdfController> logger)
    {
        _logger = logger;
    }

    public async Task<ActionResult> ConvertHtmlAsync(string htmlContent)
    {
        if (string.IsNullOrWhiteSpace(htmlContent))
            return BadRequest("HTML content is required");

        return await Task.Run(() =>
        {
            using var stream = new MemoryStream();
            using var document = new Document(PageSize.A4);
            using var writer = PdfWriter.GetInstance(document, stream);

            document.Open();

            var cssResolver = XMLWorkerHelper.GetInstance().GetDefaultCssResolver(true);
            var fontProvider = new XMLWorkerFontProvider();
            var cssAppliers = new CssAppliersImpl(fontProvider);
            var htmlContext = new HtmlPipelineContext(cssAppliers);
            htmlContext.SetTagFactory(Tags.GetHtmlTagProcessorFactory());

            // Pipeline with limited CSS3 support
            var pdf = new PdfWriterPipeline(document, writer);
            var html = new HtmlPipeline(htmlContext, pdf);
            var css = new CssResolverPipeline(cssResolver, html);

            var worker = new XMLWorker(css, true);
            var parser = new XMLParser(worker);

            using var stringReader = new StringReader(htmlContent);
            parser.Parse(stringReader);
            document.Close();

            return File(stream.ToArray(), "application/pdf", "converted.pdf");
        });
    }
}
Imports System
Imports System.IO
Imports System.Threading.Tasks
Imports System.Web.Mvc
Imports iTextSharp.text
Imports iTextSharp.text.pdf
Imports iTextSharp.tool.xml
Imports iTextSharp.tool.xml.pipeline.css
Imports iTextSharp.tool.xml.pipeline.html
Imports iTextSharp.tool.xml.pipeline.end
Imports Microsoft.Extensions.Logging

' HTML conversion with iTextSharp -- note the CSS limitations
Public Class HtmlToPdfController
    Inherits Controller

    Private ReadOnly _logger As ILogger(Of HtmlToPdfController)

    Public Sub New(logger As ILogger(Of HtmlToPdfController))
        _logger = logger
    End Sub

    Public Async Function ConvertHtmlAsync(htmlContent As String) As Task(Of ActionResult)
        If String.IsNullOrWhiteSpace(htmlContent) Then
            Return BadRequest("HTML content is required")
        End If

        Return Await Task.Run(Function()
                                  Using stream As New MemoryStream()
                                      Using document As New Document(PageSize.A4)
                                          Using writer = PdfWriter.GetInstance(document, stream)
                                              document.Open()

                                              Dim cssResolver = XMLWorkerHelper.GetInstance().GetDefaultCssResolver(True)
                                              Dim fontProvider = New XMLWorkerFontProvider()
                                              Dim cssAppliers = New CssAppliersImpl(fontProvider)
                                              Dim htmlContext = New HtmlPipelineContext(cssAppliers)
                                              htmlContext.SetTagFactory(Tags.GetHtmlTagProcessorFactory())

                                              ' Pipeline with limited CSS3 support
                                              Dim pdf = New PdfWriterPipeline(document, writer)
                                              Dim html = New HtmlPipeline(htmlContext, pdf)
                                              Dim css = New CssResolverPipeline(cssResolver, html)

                                              Dim worker = New XMLWorker(css, True)
                                              Dim parser = New XMLParser(worker)

                                              Using stringReader As New StringReader(htmlContent)
                                                  parser.Parse(stringReader)
                                              End Using

                                              document.Close()
                                          End Using
                                      End Using
                                  End Using

                                  Return File(stream.ToArray(), "application/pdf", "converted.pdf")
                              End Function)
    End Function
End Class
$vbLabelText   $csharpLabel

Dans quelle mesure iTextSharp gère-t-il le rendu HTML ?

Visionneuse PDF affichant un document de test converti depuis HTML, montrant la mise en forme du texte préservée (gras, italique, texte en rouge) et une liste à puces, mais sans le fond jaune mentionné dans le contenu, illustrant les limitations de rendu CSS de XMLWorkerHelper

Les limites deviennent apparentes lorsque l'on travaille avec des mises en page Bootstrap, des contenus rendus par JavaScript ou des styles CSS3 complexes. Parmi les problèmes courants, on note l'absence de polices web , des mises en page adaptatives défectueuses et le manque de prise en charge des types média CSS. De plus, iTextSharp rencontre des difficultés avec les caractères des langues internationales et les graphiques SVG lors de la conversion de contenu HTML.

Ces limitations ne sont pas seulement d'ordre cosmétique. Lorsqu'une facture ou un rapport destiné au client s'affiche incorrectement, par exemple parce qu'une couleur de fond n'apparaît pas ou qu'une grille s'effondre, le PDF perd toute utilité. Pour les équipes qui gèrent des modèles HTML, recréer la même mise en page dans le modèle objet d'iTextSharp signifie maintenir deux versions de chaque conception de document. Cette duplication engendre des coûts supplémentaires et introduit un décalage entre l'affichage web et la sortie PDF.

Comment générer des PDF à partir de HTML en utilisant le moteur Chrome ?

IronPDF transforme la génération de PDF en utilisant un moteur de rendu Chrome, garantissant une conversion HTML vers PDF parfaite au pixel près. Installez le package NuGet IronPDF pour démarrer avec une approche simplifiée dans votre projet Visual Studio.

using IronPdf;

// Configure IronPDF in Program.cs (top-level statements, .NET 10)
var builder = WebApplication.CreateBuilder(args);

builder.Services.AddSingleton<ChromePdfRenderer>(_ =>
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.MarginTop = 10;
    renderer.RenderingOptions.MarginBottom = 10;
    renderer.RenderingOptions.EnableJavaScript = true;
    renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
    return renderer;
});

builder.Services.AddMemoryCache();
builder.Services.AddControllersWithViews();

var app = builder.Build();
app.MapControllers();
app.Run();
using IronPdf;

// Configure IronPDF in Program.cs (top-level statements, .NET 10)
var builder = WebApplication.CreateBuilder(args);

builder.Services.AddSingleton<ChromePdfRenderer>(_ =>
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.MarginTop = 10;
    renderer.RenderingOptions.MarginBottom = 10;
    renderer.RenderingOptions.EnableJavaScript = true;
    renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
    return renderer;
});

builder.Services.AddMemoryCache();
builder.Services.AddControllersWithViews();

var app = builder.Build();
app.MapControllers();
app.Run();
Imports IronPdf

' Configure IronPDF in Program.vb (top-level statements, .NET 10)
Dim builder = WebApplication.CreateBuilder(args)

builder.Services.AddSingleton(Function(_)
    Dim renderer = New ChromePdfRenderer()
    renderer.RenderingOptions.MarginTop = 10
    renderer.RenderingOptions.MarginBottom = 10
    renderer.RenderingOptions.EnableJavaScript = True
    renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print
    Return renderer
End Function)

builder.Services.AddMemoryCache()
builder.Services.AddControllersWithViews()

Dim app = builder.Build()
app.MapControllers()
app.Run()
$vbLabelText   $csharpLabel

Quelle qualité pouvez-vous attendre du rendu Chrome ?

Visionneuse PDF affichant un document avec un en-tête à dégradé violet indiquant " Génération PDF moderne " et un sous-titre relatif à la prise en charge de CSS3, Bootstrap et JavaScript , démontrant les capacités avancées de rendu de dégradés CSS3 d'IronPDF.

Le ChromePdfRenderer gère les mises en page complexes sans solutions de contournement manuelles. Il prend en charge CSS Grid, Flexbox, les polices web de Google Fonts et les graphiques JavaScript . La bibliothèque gère également les délais de rendu pour le contenu dynamique et prend en charge la configuration de la fenêtre d'affichage pour les pages réactives. Pour connaître l'ensemble des options de configuration, consultez la référence des options de rendu .

Comment convertir une vue Razor en PDF dans ASP.NET MVC ?

IronPDF se distingue par ses capacités de rendu d'images grâce au moteur Razor Engine. Vous pouvez convertir des vues Razor entières directement en PDF avec une prise en charge complète de ViewBag, ViewData et de la liaison de modèles. L'exemple suivant génère une vue de facture côté serveur et la renvoie sous forme de PDF téléchargeable :

// Production-ready Razor view to PDF
public class InvoiceController : Controller
{
    private readonly ChromePdfRenderer _pdfRenderer;
    private readonly IInvoiceService _invoiceService;
    private readonly IRazorViewToStringRenderer _razorRenderer;

    public InvoiceController(
        ChromePdfRenderer pdfRenderer,
        IInvoiceService invoiceService,
        IRazorViewToStringRenderer razorRenderer)
    {
        _pdfRenderer = pdfRenderer;
        _invoiceService = invoiceService;
        _razorRenderer = razorRenderer;
    }

    [HttpGet]
    public async Task<IActionResult> DownloadInvoiceAsync(int id)
    {
        var invoice = await _invoiceService.GetInvoiceAsync(id);
        if (invoice == null) return NotFound();

        var htmlContent = await _razorRenderer.RenderViewToStringAsync(
            "Invoice/InvoiceTemplate", invoice);

        var renderOptions = new ChromePdfRenderOptions
        {
            PaperSize = PdfPaperSize.A4,
            MarginTop = 20,
            MarginBottom = 20,
            PrintHtmlBackgrounds = true,
            CreatePdfFormsFromHtml = true
        };

        var pdf = await Task.Run(() =>
            _pdfRenderer.RenderHtmlAsPdf(htmlContent, renderOptions));

        pdf.MetaData.Title = $"Invoice-{invoice.InvoiceNumber}";
        pdf.MetaData.Subject = $"Invoice for {invoice.CustomerName}";

        var fileName = $"Invoice-{invoice.InvoiceNumber}-{DateTime.UtcNow:yyyyMMdd}.pdf";
        return File(pdf.BinaryData, "application/pdf", fileName);
    }
}
// Production-ready Razor view to PDF
public class InvoiceController : Controller
{
    private readonly ChromePdfRenderer _pdfRenderer;
    private readonly IInvoiceService _invoiceService;
    private readonly IRazorViewToStringRenderer _razorRenderer;

    public InvoiceController(
        ChromePdfRenderer pdfRenderer,
        IInvoiceService invoiceService,
        IRazorViewToStringRenderer razorRenderer)
    {
        _pdfRenderer = pdfRenderer;
        _invoiceService = invoiceService;
        _razorRenderer = razorRenderer;
    }

    [HttpGet]
    public async Task<IActionResult> DownloadInvoiceAsync(int id)
    {
        var invoice = await _invoiceService.GetInvoiceAsync(id);
        if (invoice == null) return NotFound();

        var htmlContent = await _razorRenderer.RenderViewToStringAsync(
            "Invoice/InvoiceTemplate", invoice);

        var renderOptions = new ChromePdfRenderOptions
        {
            PaperSize = PdfPaperSize.A4,
            MarginTop = 20,
            MarginBottom = 20,
            PrintHtmlBackgrounds = true,
            CreatePdfFormsFromHtml = true
        };

        var pdf = await Task.Run(() =>
            _pdfRenderer.RenderHtmlAsPdf(htmlContent, renderOptions));

        pdf.MetaData.Title = $"Invoice-{invoice.InvoiceNumber}";
        pdf.MetaData.Subject = $"Invoice for {invoice.CustomerName}";

        var fileName = $"Invoice-{invoice.InvoiceNumber}-{DateTime.UtcNow:yyyyMMdd}.pdf";
        return File(pdf.BinaryData, "application/pdf", fileName);
    }
}
Imports System
Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc

' Production-ready Razor view to PDF
Public Class InvoiceController
    Inherits Controller

    Private ReadOnly _pdfRenderer As ChromePdfRenderer
    Private ReadOnly _invoiceService As IInvoiceService
    Private ReadOnly _razorRenderer As IRazorViewToStringRenderer

    Public Sub New(pdfRenderer As ChromePdfRenderer, invoiceService As IInvoiceService, razorRenderer As IRazorViewToStringRenderer)
        _pdfRenderer = pdfRenderer
        _invoiceService = invoiceService
        _razorRenderer = razorRenderer
    End Sub

    <HttpGet>
    Public Async Function DownloadInvoiceAsync(id As Integer) As Task(Of IActionResult)
        Dim invoice = Await _invoiceService.GetInvoiceAsync(id)
        If invoice Is Nothing Then Return NotFound()

        Dim htmlContent = Await _razorRenderer.RenderViewToStringAsync("Invoice/InvoiceTemplate", invoice)

        Dim renderOptions As New ChromePdfRenderOptions With {
            .PaperSize = PdfPaperSize.A4,
            .MarginTop = 20,
            .MarginBottom = 20,
            .PrintHtmlBackgrounds = True,
            .CreatePdfFormsFromHtml = True
        }

        Dim pdf = Await Task.Run(Function() _pdfRenderer.RenderHtmlAsPdf(htmlContent, renderOptions))

        pdf.MetaData.Title = $"Invoice-{invoice.InvoiceNumber}"
        pdf.MetaData.Subject = $"Invoice for {invoice.CustomerName}"

        Dim fileName = $"Invoice-{invoice.InvoiceNumber}-{DateTime.UtcNow:yyyyMMdd}.pdf"
        Return File(pdf.BinaryData, "application/pdf", fileName)
    End Function
End Class
$vbLabelText   $csharpLabel

Comment la conversion de vues Razor se compare-t-elle à la construction manuelle ?

Rendu PDF de la page d'accueil d'une application web ASP.NET Core montrant le menu de navigation, le titre de bienvenue et le pied de page avec le style Bootstrap conservé, démontrant comment les mises en page web sont converties au format PDF

À l'inverse, l'approche d'iTextSharp nécessite la construction manuelle de la structure du document dans le code. Chaque titre, cellule de tableau, choix de police et ajustement d'espacement doit être exprimé sous forme d'objet C#. Il n'existe pas de modèle HTML sur lequel itérer dans un navigateur ; Chaque modification nécessite un cycle de compilation et de vérification par rapport au fichier PDF généré.

L'intégration Razor d'IronPDF vous permet de réutiliser des vues Razor , des fichiers HTML ou des chaînes HTML existants pour la génération de PDF. Vous pouvez également travailler avec des fichiers ZIP HTML ou implémenter des configurations d'URL de base pour le chargement des ressources. Le guide pratique de conversion CSHTML vers PDF décrit en détail le modèle de rendu Razor , y compris la configuration de l'injection de dépendances.

Comment gérer les téléchargements et les flux de fichiers pour créer un PDF?

Les deux bibliothèques prennent en charge différentes méthodes de sortie pour les fichiers PDF dans les applications web. IronPDF offre des fonctionnalités supplémentaires telles que la compression PDF, la linéarisation pour un affichage Web rapide et la rastérisation en images. Le contrôleur de flux ci-dessous illustre comment gérer les fichiers PDF volumineux avec prise en charge de la mise en cache et des requêtes de plage :

// Streaming controller for large PDFs
public class StreamingPdfController : Controller
{
    private readonly ChromePdfRenderer _ironPdfRenderer;
    private readonly IMemoryCache _cache;

    public StreamingPdfController(ChromePdfRenderer ironPdfRenderer, IMemoryCache cache)
    {
        _ironPdfRenderer = ironPdfRenderer;
        _cache = cache;
    }

    [HttpGet]
    public async Task<IActionResult> StreamLargePdf(string reportId)
    {
        var cacheKey = $"pdf_stream_{reportId}";
        if (_cache.TryGetValue<byte[]>(cacheKey, out var cachedPdf))
            return File(cachedPdf, "application/pdf", $"report_{reportId}.pdf");

        Response.ContentType = "application/pdf";
        Response.Headers.Add("Content-Disposition",
            $"attachment; filename=large_report_{reportId}.pdf");

        await using var stream = Response.BodyWriter.AsStream();
        var html = await GenerateLargeHtmlReport(reportId);
        var pdf = _ironPdfRenderer.RenderHtmlAsPdf(html);
        pdf.SaveAs(stream);

        if (pdf.BinaryData.Length < 10_000_000)
            _cache.Set(cacheKey, pdf.BinaryData, TimeSpan.FromMinutes(30));

        return new EmptyResult();
    }

    [HttpGet]
    public IActionResult DownloadWithRangeSupport(string documentId)
    {
        var pdfBytes = GetPdfBytes(documentId);
        return File(pdfBytes, "application/pdf",
            $"document_{documentId}.pdf", enableRangeProcessing: true);
    }
}
// Streaming controller for large PDFs
public class StreamingPdfController : Controller
{
    private readonly ChromePdfRenderer _ironPdfRenderer;
    private readonly IMemoryCache _cache;

    public StreamingPdfController(ChromePdfRenderer ironPdfRenderer, IMemoryCache cache)
    {
        _ironPdfRenderer = ironPdfRenderer;
        _cache = cache;
    }

    [HttpGet]
    public async Task<IActionResult> StreamLargePdf(string reportId)
    {
        var cacheKey = $"pdf_stream_{reportId}";
        if (_cache.TryGetValue<byte[]>(cacheKey, out var cachedPdf))
            return File(cachedPdf, "application/pdf", $"report_{reportId}.pdf");

        Response.ContentType = "application/pdf";
        Response.Headers.Add("Content-Disposition",
            $"attachment; filename=large_report_{reportId}.pdf");

        await using var stream = Response.BodyWriter.AsStream();
        var html = await GenerateLargeHtmlReport(reportId);
        var pdf = _ironPdfRenderer.RenderHtmlAsPdf(html);
        pdf.SaveAs(stream);

        if (pdf.BinaryData.Length < 10_000_000)
            _cache.Set(cacheKey, pdf.BinaryData, TimeSpan.FromMinutes(30));

        return new EmptyResult();
    }

    [HttpGet]
    public IActionResult DownloadWithRangeSupport(string documentId)
    {
        var pdfBytes = GetPdfBytes(documentId);
        return File(pdfBytes, "application/pdf",
            $"document_{documentId}.pdf", enableRangeProcessing: true);
    }
}
Imports System
Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc
Imports Microsoft.Extensions.Caching.Memory

' Streaming controller for large PDFs
Public Class StreamingPdfController
    Inherits Controller

    Private ReadOnly _ironPdfRenderer As ChromePdfRenderer
    Private ReadOnly _cache As IMemoryCache

    Public Sub New(ironPdfRenderer As ChromePdfRenderer, cache As IMemoryCache)
        _ironPdfRenderer = ironPdfRenderer
        _cache = cache
    End Sub

    <HttpGet>
    Public Async Function StreamLargePdf(reportId As String) As Task(Of IActionResult)
        Dim cacheKey = $"pdf_stream_{reportId}"
        Dim cachedPdf As Byte() = Nothing

        If _cache.TryGetValue(cacheKey, cachedPdf) Then
            Return File(cachedPdf, "application/pdf", $"report_{reportId}.pdf")
        End If

        Response.ContentType = "application/pdf"
        Response.Headers.Add("Content-Disposition", $"attachment; filename=large_report_{reportId}.pdf")

        Await Using stream = Response.BodyWriter.AsStream()
            Dim html = Await GenerateLargeHtmlReport(reportId)
            Dim pdf = _ironPdfRenderer.RenderHtmlAsPdf(html)
            pdf.SaveAs(stream)

            If pdf.BinaryData.Length < 10000000 Then
                _cache.Set(cacheKey, pdf.BinaryData, TimeSpan.FromMinutes(30))
            End If
        End Using

        Return New EmptyResult()
    End Function

    <HttpGet>
    Public Function DownloadWithRangeSupport(documentId As String) As IActionResult
        Dim pdfBytes = GetPdfBytes(documentId)
        Return File(pdfBytes, "application/pdf", $"document_{documentId}.pdf", enableRangeProcessing:=True)
    End Function
End Class
$vbLabelText   $csharpLabel

Pour les scénarios avancés, IronPDF prend en charge la génération parallèle de PDF, le traitement multithread et les opérations par lots . Vous pouvez implémenter une journalisation personnalisée , gérer l'authentification réseau, utiliser des cookies et ajouter des en-têtes de requête HTTP pour une génération de documents sécurisée.

Comment les deux bibliothèques se comparent-elles côte à côte ?

Le tableau ci-dessous résume les principales différences entre iTextSharp et IronPDF pour les projets ASP.NET MVC :

Comparaison des fonctionnalités d'iTextSharp et IronPDF pour ASP.NET MVC
Caractéristique iTextSharp IronPDF
rendu HTML en PDF Limité (XMLWorker, pas de CSS3 moderne) Moteur Chrome complet (CSS3, JS, Flexbox)
Prise en charge de Razor / CSHTML Aucune prise en charge native Rendu de vue Razor intégré
Sécurité des threads Nécessite un verrouillage manuel Thread-safe par défaut
API asynchrone Pas d'asynchrone natif Prise en charge complète du mode asynchrone
Linux / Docker Pris en charge Pris en charge
Type de licence AGPL (logiciel libre) ou commercial Publicité avec essai gratuit
Signatures numériques Oui Oui
Formulaires PDF Oui (manuel) Oui (à partir des éléments de formulaire HTML)

iTextSharp offre un contrôle précis pour la création de PDF par programmation, ce qui en fait une option viable lorsque la structure du document est simple et fixe. IronPDF est le choix idéal lorsque vous devez convertir des modèles HTML ou des vues Razor en documents PDF Professional avec un rendu précis , une prise en charge complète de CSS3 et l'exécution de JavaScript .

Pour les applications ASP.NET de production, IronPDF offre une prise en charge asynchrone supérieure et une intégration avec les modèles .NET modernes, notamment l'injection de dépendances et les pipelines middleware. Sa capacité à afficher des vues Razor , à prendre en charge les signatures numériques et à gérer des mises en page complexes en fait un choix privilégié pour les applications Enterprise . La bibliothèque prend également en charge les applications Blazor Server et la conformité PDF/A pour les documents d'archives.

Qu'en est-il de la licence et des considérations relatives au projet?

La bibliothèque iTextSharp utilise une licence AGPL pour sa version open source, ce qui exige que le code de votre application soit également open source. Des licences commerciales sont disponibles auprès d'iText Group pour les projets propriétaires. Cette considération relative aux licences est particulièrement importante pour les produits SaaS ou les outils internes Enterprise pour lesquels il est impossible de publier le code source.

IronPDF utilise un modèle de licence commerciale avec une version d'essai gratuite pour le développement et les tests. Les licences s'adaptent à l'environnement de déploiement : développeur, serveur unique ou options de déploiement illimitées. Lors de la mise en œuvre de l'une ou l'autre solution, tenez compte des scénarios de déploiement incluant les environnements Docker, Azure et Linux.

Les considérations de performance pour les scénarios à fort trafic incluent la mise en œuvre d'opérations asynchrones, une gestion appropriée de la mémoire et des stratégies de mise en cache. Le moteur Chrome d'IronPDF offre des performances supérieures pour le rendu HTML complexe, tandis qu'iTextSharp peut être plus efficace pour la génération de PDF programmatique simple sans HTML. Pour les applications qui génèrent des centaines de PDF par minute, l'évaluation des performances sous une charge réaliste est le guide le plus fiable pour déterminer quelle bibliothèque convient à votre infrastructure.

La migration d'iTextSharp vers IronPDF est simple pour la plupart des projets MVC. Le principal changement consiste à remplacer le code de génération manuelle des documents par un modèle HTML rendu par le moteur Chrome. IronPDF fournit une documentation complète , des exemples de code et un support technique pour faciliter la transition.

Quelles sont vos prochaines étapes ?

Pour les nouveaux projets nécessitant une conversion HTML vers PDF avec prise en charge des normes web modernes, IronPDF offre un avantage certain grâce à son rendu basé sur Chrome. Les projets existants utilisant déjà iTextSharp pour la création de PDF de base peuvent continuer avec leur implémentation actuelle, sauf si la précision du rendu HTML devient une exigence.

Commencez par l'essai gratuit d'IronPDF et testez-le directement avec vos vues Razor ou modèles HTML existants. Explorez la documentation complète et la référence API pour constater la rapidité avec laquelle l'intégration se met en place. Si vous avez des questions concernant la migration d'un projet existant basé sur iTextSharp ou si vous avez besoin de conseils sur la gestion des flux de mémoire PDF et la conformité PDF/A , l'équipe d'assistance est disponible pour vous aider.

Pour une comparaison plus détaillée entre IronPDF et la gamme de produits iText, consultez la page de comparaison dédiée iText vs. IronPDF .

Veuillez noteriTextSharp est une marque déposée de son propriétaire respectif. Ce site n'est pas affilié, approuvé ou sponsorisé par iTextSharp. 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.

Questions Fréquemment Posées

Quel est le principal avantage de l'utilisation d'IronPDF par rapport à iTextSharp pour la génération de PDF en ASP.NET MVC ?

IronPDF offre des capacités de rendu HTML supérieures à celles d'iTextSharp, ce qui facilite la génération de PDF de haute qualité à partir de contenus web.

Puis-je utiliser IronPDF pour générer des factures dans une application ASP.NET MVC ?

Oui, IronPDF convient parfaitement pour générer des factures et d'autres documents PDF dans les applications ASP.NET MVC grâce à ses fonctionnalités de conversion HTML en PDF.

Comment la mise en œuvre d'IronPDF se compare-t-elle à celle d'iTextSharp en termes de facilité d'utilisation ?

IronPDF est généralement considéré comme plus facile à mettre en œuvre qu'iTextSharp, en particulier pour les développeurs qui cherchent à intégrer rapidement des fonctionnalités de génération de PDF sans configuration approfondie.

IronPDF prend-il en charge la conversion de pages web complexes en PDF dans ASP.NET MVC ?

Oui, IronPDF excelle dans la conversion de pages web complexes en PDF, grâce à son moteur de rendu HTML avancé qui reproduit fidèlement le contenu web.

IronPDF est-il un bon choix pour générer du contenu téléchargeable à partir d'une application ASP.NET MVC ?

IronPDF est un excellent choix pour générer du contenu téléchargeable en raison de sa capacité à créer des PDF de haute qualité à partir d'un large éventail de contenus web.

Quels sont les scénarios idéaux pour l'utilisation d'IronPDF dans la génération de PDF ?

IronPDF est idéal pour les scénarios qui nécessitent des conversions HTML vers PDF de haute qualité, comme la génération de rapports, de factures ou de documents téléchargeables à partir de contenu web.

IronPDF offre-t-il une meilleure prise en charge des technologies web modernes par rapport à iTextSharp ?

Oui, IronPDF est conçu pour fonctionner avec les technologies web modernes, offrant une meilleure compatibilité et une précision de rendu supérieure par rapport à iTextSharp.

Comment IronPDF gère-t-il les images et les feuilles de style CSS lors de la génération de PDF ?

IronPDF traite les images et les feuilles de style CSS avec une grande fidélité, ce qui garantit que le PDF résultant correspond étroitement au contenu HTML d'origine, y compris les mises en page et les styles complexes.

IronPDF peut-il être intégré facilement dans des projets ASP.NET MVC existants ?

Oui, IronPDF peut être facilement intégré dans des projets ASP.NET MVC existants, offrant une API simple aux développeurs pour mettre en œuvre des fonctionnalités de génération de PDF.

Quels sont les principaux cas d'utilisation d'IronPDF for .NET dans les applications ASP.NET MVC ?

Les principaux cas d'utilisation d'IronPDF pour les applications ASP.NET MVC comprennent la génération de rapports, de factures et de tout autre document pour lequel une conversion précise de HTML en PDF est essentielle.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

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

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit

Équipe de soutien Iron

Nous sommes en ligne 24 heures sur 24, 5 jours sur 7.
Chat
Email
Appelez-moi