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 des PDF en utilisant iTextSharp en MVC vs IronPDF : Une comparaison complète

Curtis Chau
Curtis Chau
Publié:

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 d'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. Explorons ces deux approches pour vous aider à prendre une décision éclairée concernant vos besoins en matière de génération de PDF .NET .

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 iTextSharp via son package NuGet ou sa DLL. 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();

                        // Add metadata
                        document.AddTitle("Generated Report");
                        document.AddAuthor("Your Application");
                        document.AddCreationDate();

                        // Add content with error handling
                        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"));

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

                        document.Close();
                    }
                }

                byte[] pdfBytes = memoryStream.ToArray();

                // Proper response headers for production
                Response.Headers.Add("Content-Length", pdfBytes.Length.ToString());
                Response.Headers.Add("Content-Disposition", "inline; filename=report.pdf");
                Response.Headers.Add("Cache-Control", "no-cache, no-store, must-revalidate");

                _logger.LogInformation("PDF generated successfully, size: {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();

                        // Add metadata
                        document.AddTitle("Generated Report");
                        document.AddAuthor("Your Application");
                        document.AddCreationDate();

                        // Add content with error handling
                        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"));

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

                        document.Close();
                    }
                }

                byte[] pdfBytes = memoryStream.ToArray();

                // Proper response headers for production
                Response.Headers.Add("Content-Length", pdfBytes.Length.ToString());
                Response.Headers.Add("Content-Disposition", "inline; filename=report.pdf");
                Response.Headers.Add("Cache-Control", "no-cache, no-store, must-revalidate");

                _logger.LogInformation("PDF generated successfully, size: {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");
        }
    }
}
$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 pour la mise en forme de texte et de tableaux dans le cadre de la génération de PDF par programmation.

Ce code illustre l'approche fondamentale : créer une instance de Document, attacher un PdfWriter à un flux, ajouter du contenu à l'aide d'éléments et renvoyer le fichier PDF via une méthode d'action. L'implémentation gère correctement les modèles de gestion des erreurs et d'élimination des ressources essentiels pour les systèmes de production, vous permettant d'enregistrer des données sur le serveur ou d'autoriser les téléchargements des utilisateurs tout en gérant efficacement la mémoire . Pour des scénarios plus complexes, vous pourriez avoir besoin d'implémenter des formats de papier personnalisés , de gérer l'orientation des pages ou d'ajouter des numéros de page à vos documents générés.

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 HTMLWorker obsolète et son remplaçant XMLWorker ont une prise en charge CSS limitée et peinent à gérer le contenu web moderne, en particulier lorsqu'il s'agit de [CSS réactif](https://ironpdf.com/how-to/html-to-pdf-responsive-css/) et [de contenu rendu en JavaScript](https://ironpdf.com/how-to/javascript-to-pdf/) . Ces limitations deviennent particulièrement évidentes lorsqu'on travaille avec [des composants Bootstrap](https://ironpdf.com/troubleshooting/bootstrap-flex-css/) , [des polices modernes](https://ironpdf.com/how-to/manage-fonts/) ou [des graphiques SVG](https://ironpdf.com/how-to/SVGs/) . ```cs // Production-ready HTML conversion with iTextSharp - with limitations public class HtmlToPdfController : Controller { private readonly IMemoryCache _cache; private readonly ILogger _logger; public HtmlToPdfController(IMemoryCache cache, ILogger logger) { _cache = cache; _logger = logger; } public async Task ConvertHtmlAsync(string htmlContent) { // Validate input if (string.IsNullOrWhiteSpace(htmlContent)) { return BadRequest("HTML content is required"); } try { 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(); // Configure XMLWorker with limited CSS support var cssResolver = XMLWorkerHelper.GetInstance().GetDefaultCssResolver(true); var fontProvider = new XMLWorkerFontProvider(); var cssAppliers = new CssAppliersImpl(fontProvider); var htmlContext = new HtmlPipelineContext(cssAppliers); htmlContext.SetTagFactory(Tags.GetHtmlTagProcessorFactory()); // Create pipelines - limited CSS3 support var pdf = new PdfWriterPipeline(document, writer); var html = new HtmlPipeline(htmlContext, pdf); var css = new CssResolverPipeline(cssResolver, html); // Create XMLWorker var worker = new XMLWorker(css, true); var parser = new XMLParser(worker); using (var stringReader = new StringReader(htmlContent)) { parser.Parse(stringReader); } document.Close(); } } var pdfBytes = stream.ToArray(); // Consider caching for repeated requests var cacheKey = $"pdf_{htmlContent.GetHashCode()}"; _cache.Set(cacheKey, pdfBytes, TimeSpan.FromMinutes(5)); return File(pdfBytes, "application/pdf", "converted.pdf"); } }); } catch (Exception ex) { _logger.LogError(ex, "Failed to convert HTML to PDF"); return StatusCode(500, "Conversion failed"); } } } ``` ### Dans quelle mesure iTextSharp gère-t-il le rendu HTML ? [Visionneuse PDF affichant un document de test converti depuis HTML, présentant une 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, ce qui illustre les limitations de rendu CSS de XMLWorkerHelper.](/static-assets/pdf/blog/generate-pdf-itextsharp-mvc/generate-pdf-itextsharp-mvc-2.webp) Les limitations deviennent évidentes lorsqu'on travaille avec [des mises en page Bootstrap](https://ironpdf.com/troubleshooting/bootstrap-flex-css/) , du contenu rendu en JavaScript ou des styles CSS3 complexes. La création de PDF avec du HTML moderne nécessite de nombreuses solutions de contournement ou des approches alternatives. Les problèmes courants incluent l'absence [de polices web](https://ironpdf.com/how-to/webfonts-webicons/) , [des mises en page réactives](https://ironpdf.com/how-to/html-to-pdf-responsive-css/) défectueuses et le manque de prise en charge [des types de médias CSS](https://ironpdf.com/how-to/html-to-pdf-responsive-css/) . De plus, iTextSharp rencontre des difficultés avec [les langues internationales](https://ironpdf.com/troubleshooting/international-languages-and-cmjk/) , [l'encodage UTF-8](https://ironpdf.com/how-to/utf-8/) et [les marges personnalisées](https://ironpdf.com/how-to/custom-margins/) lors de la conversion de contenu HTML. ## Comment IronPDF simplifie-t-il la génération de PDF en ASP.NET MVC? IronPDF transforme la génération de PDF en utilisant un [moteur de rendu Chrome](https://ironpdf.com/how-to/ironpdf-2021-chrome-rendering-engine-eap/) , garantissant une conversion HTML vers PDF parfaite au pixel près. Installez le [package NuGet IronPDF](https://ironpdf.com/get-started/advanced-installation-nuget/) pour démarrer avec une approche simplifiée dans votre projet Visual Studio. La bibliothèque prend en charge les plateformes [Windows](https://ironpdf.com/get-started/windows/) , [Linux](https://ironpdf.com/get-started/linux/) , [macOS](https://ironpdf.com/get-started/macos/) et même [Android](https://ironpdf.com/get-started/android/) , ce qui la rend idéale pour le développement multiplateforme. ```cs using IronPdf; using Microsoft.Extensions.DependencyInjection; // Configure IronPDF in Startup.cs or Program.cs public class Startup { public void ConfigureServices(IServiceCollection services) { // Register IronPDF with dependency injection services.AddSingleton(provider => { var renderer = new ChromePdfRenderer(); // Configure rendering options for production renderer.RenderingOptions.MarginTop = 10; renderer.RenderingOptions.MarginBottom = 10; renderer.RenderingOptions.MarginLeft = 10; renderer.RenderingOptions.MarginRight = 10; renderer.RenderingOptions.EnableJavaScript = true; renderer.RenderingOptions.RenderDelay = 500; // Wait for JS renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print; return renderer; }); services.AddMemoryCache(); services.AddControllersWithViews(); } } // Production-ready controller with IronPDF public class ModernPdfController : Controller { private readonly ChromePdfRenderer _pdfRenderer; private readonly ILogger _logger; public ModernPdfController(ChromePdfRenderer pdfRenderer, ILogger logger) { _pdfRenderer = pdfRenderer; _logger = logger; } [HttpPost] public async Task GeneratePdfWithIronPDFAsync([FromBody] PdfRequest request) { try { // Validate request if (string.IsNullOrWhiteSpace(request?.HtmlContent)) { return BadRequest("HTML content is required"); } // Configure specific options for this request var renderOptions = new ChromePdfRenderOptions { MarginTop = request.MarginTop ?? 10, MarginBottom = request.MarginBottom ?? 10, PaperSize = PdfPaperSize.A4, Title = request.Title ?? "Generated Document", EnableJavaScript = true, WaitFor = new WaitFor() { RenderDelay = 1000, // Wait for content to render NetworkIdle = true // Wait for network requests } }; // Apply security headers renderOptions.CustomPdfSecuritySettings = new PdfSecuritySettings { AllowUserCopyPasteContent = true, AllowUserPrinting = PdfPrintSecurity.FullPrintRights, OwnerPassword = request.OwnerPassword }; // Render HTML with full CSS3 and JavaScript support var pdf = await Task.Run(() => _pdfRenderer.RenderHtmlAsPdf(request.HtmlContent, renderOptions) ); // Add metadata pdf.MetaData.Author = "Your Application"; pdf.MetaData.CreatedDate = DateTime.UtcNow; pdf.MetaData.Title = request.Title ?? "Document"; // Optional: Add headers/footers if (request.IncludeHeaders) { pdf.AddTextHeaders("{page} of {total-pages}", IronPdf.Editing.TextHeaderFooterOptions.CenterRight); pdf.AddTextFooters("Generated on {date} at {time}", IronPdf.Editing.TextHeaderFooterOptions.CenterBottom); } var pdfBytes = pdf.BinaryData; _logger.LogInformation("PDF generated successfully: {Size} bytes", pdfBytes.Length); // Return with appropriate headers Response.Headers.Add("X-PDF-Version", pdf.MetaData.PdfVersion.ToString()); return File(pdfBytes, "application/pdf", $"{request.FileName ?? "document"}_{DateTime.UtcNow:yyyyMMdd}.pdf"); } catch (Exception ex) { _logger.LogError(ex, "PDF generation failed"); return StatusCode(500, new { error = "PDF generation failed", message = ex.Message }); } } } public class PdfRequest { public string HtmlContent { get; set; } public string Title { get; set; } public string FileName { get; set; } public bool IncludeHeaders { get; set; } public string OwnerPassword { get; set; } public double? MarginTop { get; set; } public double? MarginBottom { get; set; } } ``` ### Quelle qualité pouvez-vous attendre du rendu Chrome d'IronPDF ? [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 ainsi les capacités avancées de rendu de dégradés CSS3 d'IronPDF.](/static-assets/pdf/blog/generate-pdf-itextsharp-mvc/generate-pdf-itextsharp-mvc-3.webp) `ChromePdfRenderer` gère sans effort les mises en page complexes, en préservant la fidélité visuelle de votre contenu HTML dans les documents PDF résultants. Il prend en charge des fonctionnalités modernes telles que [CSS Grid](https://ironpdf.com/troubleshooting/bootstrap-flex-css/) , [Flexbox](https://ironpdf.com/how-to/html-to-pdf-responsive-css/) , [les polices web](https://ironpdf.com/examples/google-fonts-htmltopdf/) et [le contenu WebGL](https://ironpdf.com/how-to/render-webgl/) . La bibliothèque excelle également dans le rendu [des graphiques JavaScript](https://ironpdf.com/examples/js-charts-to-pdf/) , la gestion [des paramètres de la fenêtre d'affichage](https://ironpdf.com/how-to/viewport-zoom/) et la gestion [des délais de rendu](https://ironpdf.com/how-to/waitfor/) pour le contenu dynamique. Pour des résultats optimaux, vous pouvez configurer [les options de rendu](https://ironpdf.com/how-to/rendering-options/) en fonction de vos besoins spécifiques.## Quelle approche offre une meilleure intégration MVC ? Les deux bibliothèques prennent en charge les modèles ASP.NET MVC, mais IronPDF se distingue par ses capacités de rendu de vues grâce au moteur Razor. Vous pouvez convertir des vues entières directement au format PDF grâce à une prise en charge complète de ViewBag, ViewData et de la liaison de modèles. La bibliothèque s'intègre parfaitement à ASP.NET Core, MVC Framework et Razor Pages, offrant une grande flexibilité pour différentes architectures .NET. Vous pouvez même générer du CSHTML en mode sans interface graphique pour la génération de PDF côté serveur, sans contexte d'interface utilisateur. ```cs // IronPDF - Production-ready Razor view to PDF with async support 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 DownloadInvoiceAsync(int id) { try { // Fetch invoice data asynchronously var invoice = await _invoiceService.GetInvoiceAsync(id); if (invoice == null) { return NotFound(); } // Render Razor view to string var htmlContent = await _razorRenderer.RenderViewToStringAsync( "Invoice/InvoiceTemplate", invoice); // Configure PDF generation options var renderOptions = new ChromePdfRenderOptions { PaperSize = PdfPaperSize.A4, MarginTop = 20, MarginBottom = 20, MarginLeft = 15, MarginRight = 15, PrintHtmlBackgrounds = true, CreatePdfFormsFromHtml = true }; // Add custom headers with invoice info var headerHtml = $@"
Invoice #{invoice.InvoiceNumber} | {invoice.Date:yyyy-MM-dd}
"; // Generate PDF from HTML var pdf = await Task.Run(() => _pdfRenderer.RenderHtmlAsPdf(htmlContent, renderOptions) ); // Add headers pdf.AddHtmlHeaders(headerHtml, new HtmlHeaderFooter { Height = 25, DrawDividerLine = true }); // Set metadata pdf.MetaData.Title = $"Invoice-{invoice.InvoiceNumber}"; pdf.MetaData.Subject = $"Invoice for {invoice.CustomerName}"; pdf.MetaData.Keywords = "invoice,billing,payment"; // Optional: Apply digital signature if (Request.Headers.ContainsKey("X-Sign-Document")) { pdf.Sign(new PdfSignature("certificate.pfx", "password")); } var fileName = $"Invoice-{invoice.InvoiceNumber}-{DateTime.UtcNow:yyyyMMdd}.pdf"; return File(pdf.BinaryData, "application/pdf", fileName); } catch (Exception ex) { _logger.LogError(ex, "Failed to generate invoice PDF for ID: {InvoiceId}", id); return StatusCode(500, "Failed to generate invoice"); } } } // Razor view renderer service public interface IRazorViewToStringRenderer { Task RenderViewToStringAsync(string viewName, TModel model); } public class RazorViewToStringRenderer : IRazorViewToStringRenderer { private readonly IRazorViewEngine _razorViewEngine; private readonly ITempDataProvider _tempDataProvider; private readonly IServiceProvider _serviceProvider; public RazorViewToStringRenderer( IRazorViewEngine razorViewEngine, ITempDataProvider tempDataProvider, IServiceProvider serviceProvider) { _razorViewEngine = razorViewEngine; _tempDataProvider = tempDataProvider; _serviceProvider = serviceProvider; } public async Task RenderViewToStringAsync(string viewName, TModel model) { var httpContext = new DefaultHttpContext { RequestServices = _serviceProvider }; var actionContext = new ActionContext(httpContext, new RouteData(), new ActionDescriptor()); using (var sw = new StringWriter()) { var viewResult = _razorViewEngine.FindView(actionContext, viewName, false); if (!viewResult.Success) { throw new ArgumentNullException($"{viewName} does not match any available view"); } var viewDictionary = new ViewDataDictionary( new EmptyModelMetadataProvider(), new ModelStateDictionary()) { Model = model }; var viewContext = new ViewContext( actionContext, viewResult.View, viewDictionary, new TempDataDictionary(actionContext.HttpContext, _tempDataProvider), sw, new HtmlHelperOptions()); await viewResult.View.RenderAsync(viewContext); return sw.ToString(); } } } ``` ### 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 affichant le menu de navigation, le titre de bienvenue et le pied de page avec le style Bootstrap conservé, démontrant comment la mise en page web se traduit au format PDF](/static-assets/pdf/blog/generate-pdf-itextsharp-mvc/generate-pdf-itextsharp-mvc-4.webp) Comparez cela à l'approche d'iTextSharp, qui nécessite de construire manuellement la structure du document dans le contrôleur. Cela signifie construire le document à partir du code source avec une prise en charge limitée des mises en page complexes. L'intégration Razor d'IronPDF vous permet d'utiliser des pages ASPX existantes, des fichiers HTML ou même des chaînes HTML 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. ```cs // iTextSharp - Manual PDF construction with thread safety considerations public class InvoiceTextSharpController : Controller { private readonly IInvoiceService _invoiceService; private readonly ILogger _logger; private static readonly object _lockObject = new object(); public async Task InvoicePdfTextSharp(int id) { try { var invoice = await _invoiceService.GetInvoiceAsync(id); if (invoice == null) { return NotFound(); } // Thread-safe PDF generation byte[] pdfBytes; // iTextSharp is not thread-safe, must synchronize lock (_lockObject) { using (var stream = new MemoryStream()) { using (var document = new Document(PageSize.A4, 50, 50, 25, 25)) { using (var writer = PdfWriter.GetInstance(document, stream)) { document.Open(); // Manually build invoice structure var titleFont = FontFactory.GetFont(FontFactory.HELVETICA_BOLD, 18); var headerFont = FontFactory.GetFont(FontFactory.HELVETICA_BOLD, 12); var normalFont = FontFactory.GetFont(FontFactory.HELVETICA, 10); // Add company logo var logo = Image.GetInstance("logo.png"); logo.ScaleToFit(100, 50); logo.Alignment = Element.ALIGN_RIGHT; document.Add(logo); // Add invoice header document.Add(new Paragraph($"INVOICE #{invoice.InvoiceNumber}", titleFont)); document.Add(new Paragraph($"Date: {invoice.Date:yyyy-MM-dd}", normalFont)); document.Add(new Paragraph($"Due Date: {invoice.DueDate:yyyy-MM-dd}", normalFont)); document.Add(new Paragraph(" ")); // Spacing // Add customer info document.Add(new Paragraph("Bill To:", headerFont)); document.Add(new Paragraph(invoice.CustomerName, normalFont)); document.Add(new Paragraph(invoice.CustomerAddress, normalFont)); document.Add(new Paragraph(" ")); // Create items table manually var table = new PdfPTable(4); table.WidthPercentage = 100; table.SetWidths(new float[] { 3f, 1f, 1f, 1f }); // Add table headers table.AddCell(new PdfPCell(new Phrase("Description", headerFont))); table.AddCell(new PdfPCell(new Phrase("Qty", headerFont))); table.AddCell(new PdfPCell(new Phrase("Price", headerFont))); table.AddCell(new PdfPCell(new Phrase("Total", headerFont))); // Add invoice items foreach (var item in invoice.Items) { table.AddCell(new Phrase(item.Description, normalFont)); table.AddCell(new Phrase(item.Quantity.ToString(), normalFont)); table.AddCell(new Phrase($"${item.UnitPrice:F2}", normalFont)); table.AddCell(new Phrase($"${item.Total:F2}", normalFont)); } // Add totals row table.AddCell(new PdfPCell(new Phrase("TOTAL", headerFont)) { Colspan = 3, HorizontalAlignment = Element.ALIGN_RIGHT }); table.AddCell(new PdfPCell(new Phrase($"${invoice.Total:F2}", headerFont))); document.Add(table); // Add footer document.Add(new Paragraph(" ")); document.Add(new Paragraph("Payment Terms: " + invoice.PaymentTerms, normalFont)); document.Close(); } } pdfBytes = stream.ToArray(); } } var fileName = $"Invoice-{invoice.InvoiceNumber}.pdf"; return File(pdfBytes, "application/pdf", fileName); } catch (Exception ex) { _logger.LogError(ex, "Failed to generate invoice with iTextSharp"); return StatusCode(500, "PDF generation failed"); } } } ``` ## 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. Voici un exemple de code pour la mise en œuvre du téléchargement de fichiers avec des en-têtes de disposition de contenu appropriés et une prise en charge du streaming pour les fichiers volumineux. 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. Vous pouvez également exporter vers différentes versions PDF ou créer des documents conformes à la norme PDF/A à des fins d'archivage. ```cs // Advanced streaming controller supporting both libraries public class StreamingPdfController : Controller { private readonly ChromePdfRenderer _ironPdfRenderer; private readonly IMemoryCache _cache; public StreamingPdfController(ChromePdfRenderer ironPdfRenderer, IMemoryCache cache) { _ironPdfRenderer = ironPdfRenderer; _cache = cache; } // Stream large PDFs efficiently [HttpGet] public async Task StreamLargePdf(string reportId) { // Check cache first var cacheKey = $"pdf_stream_{reportId}"; if (_cache.TryGetValue(cacheKey, out var cachedPdf)) { return File(cachedPdf, "application/pdf", $"report_{reportId}.pdf"); } // For very large PDFs, consider streaming directly to response Response.ContentType = "application/pdf"; Response.Headers.Add("Content-Disposition", $"attachment; filename=large_report_{reportId}.pdf"); await using (var stream = Response.BodyWriter.AsStream()) { // IronPDF approach - stream directly var html = await GenerateLargeHtmlReport(reportId); var pdf = _ironPdfRenderer.RenderHtmlAsPdf(html); // Save to stream pdf.SaveAs(stream); // Cache for future requests (if size permits) if (pdf.BinaryData.Length < 10_000_000) // 10MB limit { _cache.Set(cacheKey, pdf.BinaryData, TimeSpan.FromMinutes(30)); } } return new EmptyResult(); } // Support range requests for large PDFs [HttpGet] public IActionResult DownloadWithRangeSupport(string documentId) { var pdfBytes = GetPdfBytes(documentId); // Enable range processing for large files return File(pdfBytes, "application/pdf", $"document_{documentId}.pdf", enableRangeProcessing: true); } // Batch PDF generation with progress [HttpPost] public async Task BatchGeneratePdfs([FromBody] BatchPdfRequest request) { var results = new List(); var semaphore = new SemaphoreSlim(3); // Limit concurrent generations var tasks = request.Documents.Select(async doc => { await semaphore.WaitAsync(); try { var pdf = await GeneratePdfAsync(doc); return new BatchPdfResult { Id = doc.Id, Success = true, Size = pdf.Length }; } catch (Exception ex) { return new BatchPdfResult { Id = doc.Id, Success = false, Error = ex.Message }; } finally { semaphore.Release(); } }); results.AddRange(await Task.WhenAll(tasks)); return Ok(results); } } ``` 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. ## 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 votre implémentation soit également open source. Des licences commerciales sont disponibles pour les processus propriétaires. IronPDF propose un modèle de licence commerciale avec un essai gratuit pour le développement et les tests. Envisagez des extensions de licence et des options de mise à niveau pour les déploiements en entreprise. 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. Envisagez la mise en œuvre d'une désinfection des fichiers PDF pour la sécurité, de signatures numériques pour l'authenticité des documents et d'options de chiffrement pour les contenus sensibles. 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 qui utilisent déjà iTextSharp pour la création de PDF de base peuvent continuer avec leur implémentation existante, à moins que le rendu HTML ne devienne nécessaire. Lors de la planification des mises à niveau, tenez compte des voies de migration et des exigences de compatibilité. IronPDF fournit une documentation complète, des exemples de code et des guides de dépannage pour faciliter les transitions. La bibliothèque prend également en charge des fonctionnalités avancées telles que les formulaires PDF, les annotations, les filigranes et la génération de tables des matières. ## Choisir la bibliothèque PDF adaptée à votre projet ASP.NET MVC Alors [qu'iTextSharp](https://ironpdf.com/competitors/itext-vs-ironpdf/) offre un contrôle détaillé pour la création de PDF par programmation, IronPDF est excellent pour convertir du HTML en documents PDF professionnels avec [un rendu précis](https://ironpdf.com/tutorials/pixel-perfect-html-to-pdf/) . Votre choix dépendra de vos besoins spécifiques : optez pour iTextSharp pour une génération de PDF simple et pilotée par le code où vous gérez chaque élément, ou choisissez IronPDF pour une conversion HTML vers PDF fluide avec une prise en charge complète [de CSS3](https://ironpdf.com/how-to/html-to-pdf-responsive-css/) et [JavaScript](https://ironpdf.com/examples/javascript-html-to-pdf/) . Pour les applications ASP.NET de production, IronPDF offre [une gestion des erreurs](https://ironpdf.com/troubleshooting/quick-ironpdf-troubleshooting/) supérieure, [une prise en charge asynchrone](https://ironpdf.com/examples/async/) et une intégration avec les modèles .NET modernes, notamment [l'injection de dépendances](https://ironpdf.com/how-to/license-keys/) et [les pipelines middleware](https://ironpdf.com/how-to/headers-and-footers/) . Sa capacité à afficher [des vues Razor](https://ironpdf.com/how-to/cshtml-to-pdf-razor/) , à prendre en charge [les signatures numériques](https://ironpdf.com/how-to/signing/) et à gérer [des mises en page complexes](https://ironpdf.com/how-to/html-to-pdf-page-breaks/) en fait un choix privilégié pour les applications d'entreprise. La bibliothèque prend également en charge de manière fiable [les applications Blazor Server](https://ironpdf.com/how-to/blazor-tutorial/) , [les plateformes MAUI](https://ironpdf.com/how-to/pdf-viewing/) et [les frameworks Angular](https://ironpdf.com/examples/angular-to-pdf/) . Prêt à moderniser votre génération de PDF ? Commencez par [l'essai gratuit d'IronPDF](https://ironpdf.com/licensing/) et constatez la différence dans vos applications ASP.NET MVC. Consultez notre [documentation complète](https://ironpdf.com/docs/) , explorez [des exemples de code](https://ironpdf.com/examples/using-html-to-create-a-pdf/) et utilisez [le support entreprise](https://ironpdf.com/troubleshooting/engineering-support-for-ironpdf/) pour vos déploiements en production. Consultez nos [démonstrations de produits](https://ironpdf.com/demos/) , prenez connaissance [des mises à jour importantes](https://ironpdf.com/product-updates/milestones/) et accédez à la [documentation de l'API](https://ironpdf.com/object-reference/api/) pour découvrir tout le potentiel de la génération de PDF dans vos applications.
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 faites à titre d'information uniquement et reflètent les informations publiquement disponibles au moment de la rédaction.

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 est bien adapté à la génération de factures et d'autres documents PDF dans les applications ASP.NET MVC grâce à ses fonctions robustes de conversion de 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 de manière transparente avec les technologies web modernes, offrant une meilleure compatibilité et une plus grande précision de rendu 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