Gerar PDF em ASP.NET MVC: Guia iTextSharp vs. IronPDF
Full Comparison
Looking for a detailed feature-by-feature breakdown? See how IronPDF stacks up against Itext on pricing, HTML support, and licensing.
O IronPDF oferece excelente conversão de HTML para PDF com suporte completo a CSS3 e JavaScript , utilizando a renderização do Chrome. Em contrapartida, o iTextSharp oferece criação programática de PDFs, mas apresenta dificuldades com a conversão para HTML moderno, tornando o IronPDF uma opção melhor para aplicações ASP.NET MVC que exigem PDFs compatíveis com os padrões da web.
A criação de documentos PDF em aplicações ASP.NET MVC é um requisito comum para gerar relatórios, faturas e conteúdo para download. Embora o iTextSharp seja uma escolha popular há anos, o IronPDF oferece uma alternativa moderna com recursos superiores de renderização HTML . Este artigo explora ambas as abordagens para ajudá-lo a tomar uma decisão informada para suas necessidades de geração de PDFs em .NET .
Ambas as bibliotecas resolvem o mesmo problema central — gerar PDFs em um contexto web .NET — mas adotam abordagens fundamentalmente diferentes. O iTextSharp cria PDFs programaticamente por meio de um modelo de objetos, enquanto o IronPDF converte HTML em PDF usando um mecanismo de renderização completo do Chrome. Compreender essa diferença arquitetônica é fundamental para selecionar a ferramenta certa. O framework ASP.NET MVC da Microsoft suporta ambos os padrões de integração, e qualquer uma das bibliotecas pode ser integrada ao pipeline padrão de controlador-ação.
Como instalar cada biblioteca?
Antes de escrever qualquer código, você precisa adicionar cada biblioteca ao seu projeto. O NuGet é o gerenciador de pacotes padrão for .NET e lida com ambas as instalações de forma eficiente. Para o iTextSharp, instale o pacote legado via NuGet:
dotnet add package iTextSharpdotnet add package iTextSharpPara o IronPDF, instale também através do NuGet :
dotnet add package IronPdfdotnet add package IronPdfO IronPDF inclui o mecanismo de renderização do Chrome no pacote, portanto, nenhuma instalação adicional de navegador é necessária em seu servidor. A biblioteca oferece suporte nativo a ambientes Windows, Linux, macOS e contêineres. Após a instalação, adicione sua chave de licença do IronPDF durante a inicialização do aplicativo.
Como gerar um PDF usando o iTextSharp em um ambiente MVC?
Para gerar arquivos PDF usando o iTextSharp em sua aplicação ASP.NET MVC, primeiro instale a biblioteca através do NuGet. A biblioteca iTextSharp oferece controle de baixo nível sobre a criação de PDFs por meio de sua classe Document e modelo de objeto.
O código a seguir demonstra uma implementação pronta para produção para a criação de PDFs com iTextSharp em um controlador 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 ClassQual é a aparência da saída do iTextSharp?
Este código demonstra a abordagem fundamental: criar uma instância de Document, anexar um PdfWriter a um fluxo, adicionar conteúdo usando objetos de elemento e retornar o arquivo por meio de um resultado de ação. A implementação lida com padrões de descarte de recursos essenciais para sistemas de produção. Para cenários mais avançados, você pode configurar tamanhos de papel personalizados , gerenciar a orientação da página ou adicionar números de página .
A abordagem programática oferece controle preciso sobre cada elemento da página. Essa precisão é útil na geração de documentos com layouts fixos, como faturas, certificados ou formulários, cuja estrutura é sempre a mesma. No entanto, isso se torna um problema assim que o conteúdo é dinâmico ou baseado em um modelo HTML.
Quais são os desafios da conversão de HTML para PDF com a biblioteca iTextSharp?
Embora o iTextSharp seja excelente na criação programática de PDFs, a conversão de HTML para PDF apresenta desafios significativos. A classe obsoleta HTMLWorker e sua substituta XMLWorker têm suporte limitado a CSS e apresentam dificuldades com conteúdo web moderno, particularmente ao lidar com CSS responsivo e conteúdo renderizado por 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 ClassQuão bem o iTextSharp lida com a renderização de HTML?
As limitações tornam-se evidentes ao trabalhar com layouts do Bootstrap, conteúdo renderizado por JavaScript ou estilos CSS3 complexos. Problemas comuns incluem a ausência de fontes da web , layouts responsivos quebrados e falta de suporte para tipos de mídia CSS. Além disso, o iTextSharp apresenta dificuldades com caracteres de idiomas internacionais e gráficos SVG ao converter conteúdo HTML.
Essas limitações não são apenas estéticas. Quando uma fatura ou relatório destinado ao cliente é exibido incorretamente porque uma cor de fundo não aparece ou uma grade se desfaz, o PDF perde sua função. Para equipes que mantêm modelos HTML, recriar o mesmo layout no modelo de objetos do iTextSharp significa manter duas versões de cada design de documento. Essa duplicação aumenta os custos e introduz uma discrepância entre a visualização na web e a saída em PDF.
Como gerar PDFs a partir de HTML usando o mecanismo do Chrome?
O IronPDF transforma a geração de PDFs usando um mecanismo de renderização do Chrome, garantindo uma conversão de HTML para PDF com perfeição de pixels. Instale o pacote NuGet IronPDF para começar com uma abordagem simplificada em seu projeto do 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()Que qualidade você pode esperar da renderização do Chrome?
O ChromePdfRenderer lida com layouts complexos sem soluções alternativas manuais. Ele oferece suporte a CSS Grid, Flexbox, fontes da web do Google Fonts e gráficos em JavaScript . A biblioteca também gerencia atrasos de renderização para conteúdo dinâmico e oferece suporte à configuração da área de visualização para páginas responsivas. Para obter informações completas sobre as opções de configuração, consulte a referência de opções de renderização .
Como converter uma Razor View em PDF no ASP.NET MVC?
O IronPDF se destaca por seus recursos de renderização de visualização com o Razor Engine. Você pode converter visualizações Razor inteiras diretamente para PDF com suporte completo para ViewBag, ViewData e vinculação de modelo. O exemplo a seguir renderiza uma visualização de fatura no servidor e a retorna como um PDF para download:
// 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 ClassComo a conversão de visualizações Razor se compara à construção manual?
Compare isso com a abordagem do iTextSharp, que exige a construção manual da estrutura do documento em código. Cada cabeçalho, célula de tabela, escolha de fonte e ajuste de espaçamento deve ser expresso como um objeto C#. Não existe um modelo HTML para iterar em um navegador; Cada alteração requer um ciclo de compilação e verificação em relação à saída em PDF.
A integração do IronPDF com o Razor permite reutilizar visualizações Razor existentes, arquivos HTML ou strings HTML para geração de PDFs. Você também pode trabalhar com arquivos HTML ZIP ou implementar configurações de URL base para carregamento de recursos. O guia prático de conversão de CSHTML para PDF aborda todo o padrão de renderização Razor , incluindo a configuração de injeção de dependência.
Como você lida com downloads e streaming de arquivos para criar um PDF?
Ambas as bibliotecas suportam vários métodos de saída para arquivos PDF em aplicações web. O IronPDF oferece recursos adicionais como compressão de PDF, linearização para visualização rápida na web e rasterização de imagens. O controlador de streaming abaixo demonstra como lidar com PDFs grandes com suporte a cache e solicitações de intervalo:
// 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 ClassPara cenários avançados, o IronPDF oferece suporte à geração paralela de PDFs, processamento multithread e operações em lote . Você pode implementar registro de logs personalizado , lidar com autenticação de rede, trabalhar com cookies e adicionar cabeçalhos de requisição HTTP para geração segura de documentos.
Como as duas bibliotecas se comparam lado a lado?
A tabela abaixo resume as principais diferenças entre o iTextSharp e o IronPDF para projetos ASP.NET MVC:
| Recurso | iTextSharp | IronPDF |
|---|---|---|
| Conversão de HTML para PDF | Limitado (XMLWorker, sem CSS3 moderno) | Motor Chrome completo (CSS3, JS, Flexbox) |
| Suporte a Razor /CSHTML | Sem suporte nativo | Renderização de visualização Razor integrada |
| Segurança da rosca | Requer travamento manual | Seguro para threads por padrão |
| API assíncrona | Não há assincronia nativa | Suporte completo para operações assíncronas |
| Linux / Docker | Apoiado | Apoiado |
| Tipo de licença | AGPL (código aberto) ou comercial | Comercial com período de teste gratuito |
| Assinaturas digitais | Sim | Sim |
| Formulários em PDF | Sim (manual) | Sim (a partir de elementos de formulário HTML) |
O iTextSharp oferece controle detalhado para a criação programática de PDFs, tornando-se uma opção viável quando a estrutura do documento é simples e fixa. O IronPDF é a melhor opção quando você precisa converter modelos HTML ou visualizações Razor em documentos PDF profissionais com renderização precisa , suporte completo a CSS3 e execução de JavaScript .
Para aplicações ASP.NET em produção, o IronPDF oferece suporte assíncrono superior e integração com padrões .NET modernos, incluindo injeção de dependência e pipelines de middleware. Sua capacidade de renderizar visualizações Razor , suportar assinaturas digitais e lidar com layouts complexos a torna uma escolha preferencial para aplicações empresariais. A biblioteca também oferece suporte a aplicativos Blazor Server e à conformidade com o padrão PDF/A para documentos de arquivo.
E quanto ao licenciamento e às considerações do projeto?
A biblioteca iTextSharp utiliza uma licença AGPL para sua versão de código aberto, o que exige que o código do seu aplicativo também seja de código aberto. Licenças comerciais estão disponíveis no iText Group para projetos proprietários. Essa consideração sobre licenciamento é particularmente importante para produtos SaaS ou ferramentas corporativas internas, onde não é possível publicar o código-fonte.
O IronPDF utiliza um modelo de licenciamento comercial com um período de teste gratuito para desenvolvimento e testes. As licenças são escaláveis de acordo com o ambiente de implantação: opções para desenvolvedores, servidor único ou implantação ilimitada. Ao implementar qualquer uma das soluções, considere cenários de implantação que incluam ambientes Docker, Azure e Linux.
Considerações de desempenho para cenários de alto tráfego incluem a implementação de operações assíncronas, gerenciamento adequado de memória e estratégias de cache. O mecanismo Chrome do IronPDF oferece desempenho superior para renderização de HTML complexo, enquanto o iTextSharp pode ser mais eficiente para geração programática simples de PDFs sem o uso de HTML. Para aplicações que geram centenas de PDFs por minuto, a realização de testes de desempenho sob carga realista é o guia mais confiável para determinar qual biblioteca é mais adequada à sua infraestrutura.
A migração do iTextSharp para o IronPDF é simples para a maioria dos projetos MVC. A principal mudança consiste em substituir o código manual de criação de documentos por um modelo HTML renderizado pelo mecanismo do Chrome. O IronPDF oferece ampla documentação , exemplos de código e suporte técnico para garantir uma transição tranquila.
Quais são os seus próximos passos?
Para novos projetos que exigem conversão de HTML para PDF com suporte a padrões web modernos, o IronPDF oferece uma clara vantagem com sua renderização baseada no Chrome. Projetos legados que já utilizam o iTextSharp para a criação básica de PDFs podem continuar com sua implementação atual, a menos que a precisão na renderização de HTML se torne um requisito.
Comece com o teste gratuito do IronPDF e experimente-o diretamente com suas visualizações Razor ou modelos HTML existentes. Explore a documentação completa e a referência da API para ver como a integração é rápida. Se você tiver dúvidas sobre a migração de um projeto existente baseado em iTextSharp ou precisar de orientação sobre o gerenciamento de fluxos de memória em PDF e a conformidade com o PDF/A , a equipe de suporte está à disposição para ajudar.
Para uma análise mais abrangente de como o IronPDF se compara com a família de produtos iText, consulte a página dedicada à comparação entre iText e IronPDF .
Perguntas frequentes
Qual é a principal vantagem de usar o IronPDF em vez do iTextSharp para geração de PDFs em ASP.NET MVC?
O IronPDF oferece recursos superiores de renderização HTML em comparação com o iTextSharp, facilitando a geração de PDFs de alta qualidade a partir de conteúdo da web.
Posso usar o IronPDF para gerar faturas em uma aplicação ASP.NET MVC?
Sim, o IronPDF é bem adequado para gerar faturas e outros documentos PDF em aplicações ASP.NET MVC devido aos seus recursos de conversão de HTML para PDF.
Como a implementação do IronPDF se compara à do iTextSharp em termos de facilidade de uso?
O IronPDF é geralmente considerado mais fácil de implementar do que o iTextSharp, especialmente para desenvolvedores que desejam integrar rapidamente recursos de geração de PDF sem configurações complexas.
O IronPDF suporta a conversão de páginas web complexas para PDF em ASP.NET MVC?
Sim, o IronPDF se destaca na conversão de páginas da web complexas para PDF, graças ao seu mecanismo avançado de renderização HTML que replica com precisão o conteúdo da web.
O IronPDF é uma boa opção para gerar conteúdo para download a partir de uma aplicação ASP.NET MVC?
O IronPDF é uma excelente opção para gerar conteúdo para download devido à sua capacidade de criar PDFs de alta qualidade a partir de uma ampla variedade de conteúdo da web.
Quais são os cenários ideais para usar o IronPDF na geração de PDFs?
O IronPDF é ideal para cenários que exigem conversões de HTML para PDF de alta qualidade, como a geração de relatórios, faturas ou documentos para download a partir de conteúdo da web.
O IronPDF oferece melhor suporte para tecnologias web modernas em comparação com o iTextSharp?
Sim, o IronPDF é projetado para funcionar com tecnologias web modernas, oferecendo melhor compatibilidade e precisão de renderização em comparação com o iTextSharp.
Como o IronPDF lida com imagens e CSS ao gerar PDFs?
O IronPDF processa imagens e CSS com alta fidelidade, garantindo que o PDF resultante corresponda fielmente ao conteúdo HTML original, incluindo layouts e estilos complexos.
O IronPDF pode ser facilmente integrado a projetos ASP.NET MVC existentes?
Sim, o IronPDF pode ser facilmente integrado a projetos ASP.NET MVC existentes, oferecendo uma API simples para que os desenvolvedores implementem recursos de geração de PDF.
Quais são os principais casos de uso do IronPDF em aplicações ASP.NET MVC?
Os principais casos de uso do IronPDF em aplicações ASP.NET MVC incluem a geração de relatórios, faturas e quaisquer outros documentos onde a conversão precisa de HTML para PDF seja essencial.
Comece GRATUITAMENTE
Comece GRATUITAMENTE
Agende uma demonstração ao vivo gratuita
Não é necessário cartão de crédito nem criação de conta.
