Generar PDF en ASP.NET MVC: Guía de 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.
IronPDF ofrece una excelente conversión de HTML a PDF con soporte completo de CSS3 y JavaScript mediante renderizado de Chrome. Por el contrario, iTextSharp ofrece creación de PDF programática pero tiene dificultades con la conversión a HTML moderno, lo que hace que IronPDF sea una mejor opción para aplicaciones ASP.NET MVC que requieren PDF estándar web.
La creación de documentos PDF en aplicaciones ASP.NET MVC es un requisito común para generar informes, facturas y contenido descargable. Si bien iTextSharp ha sido una opción popular durante años, IronPDF ofrece una alternativa moderna con capacidades superiores de representación HTML . Este artículo explora ambos enfoques para ayudarle a tomar una decisión informada para sus necesidades de generación de PDF .NET .
Ambas bibliotecas resuelven el mismo problema central (generar archivos PDF en un contexto web .NET ), pero adoptan enfoques fundamentalmente diferentes. iTextSharp crea archivos PDF mediante programación mediante un modelo de objetos, mientras que IronPDF convierte HTML a PDF mediante un motor de renderizado completo de Chrome. Comprender esta diferencia arquitectónica es clave para seleccionar la herramienta adecuada. El marco ASP.NET MVC de Microsoft admite ambos patrones de integración y cualquiera de las bibliotecas se puede conectar a la canalización de acción del controlador estándar.
¿Cómo instalar cada biblioteca?
Antes de escribir cualquier código, debes incluir cada biblioteca en tu proyecto. NuGet es el administrador de paquetes estándar para .NET y maneja ambas instalaciones de forma limpia. Para iTextSharp, instale el paquete heredado a través de NuGet:
dotnet add package iTextSharpdotnet add package iTextSharpPara IronPDF, instálelo también mediante NuGet :
dotnet add package IronPdfdotnet add package IronPdfIronPDF incluye el motor de renderizado Chrome en el paquete, por lo que no se requiere la instalación de ningún navegador adicional en su servidor. La biblioteca es compatible con entornos Windows, Linux, macOS y contenedores de forma inmediata. Después de la instalación, agregue su clave de licencia de IronPDF durante el inicio de la aplicación.
¿Cómo generar PDF con iTextSharp en MVC?
Para generar archivos PDF utilizando iTextSharp en su aplicación ASP.NET MVC, primero instale la biblioteca a través de NuGet. La biblioteca iTextSharp proporciona control de bajo nivel sobre la creación de PDF a través de su clase de documento y su modelo de objetos.
El siguiente código demuestra una implementación lista para producción para crear archivos PDF con iTextSharp en un 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 Class¿Cómo se ve la salida de iTextSharp?
Este código demuestra el enfoque fundamental: crear una instancia Document, adjuntar un PdfWriter a una secuencia, agregar contenido usando objetos de elementos y devolver el archivo a través del resultado de una acción. La implementación maneja patrones de eliminación de recursos esenciales para los sistemas de producción. Para escenarios más avanzados, puede configurar tamaños de papel personalizados , administrar la orientación de la página o agregar números de página .
El enfoque programático le brinda un control detallado sobre cada elemento de la página. Esa precisión es útil cuando se generan documentos con diseños fijos, como facturas, certificados o formularios, donde la estructura es siempre la misma. Sin embargo, se convierte en una carga tan pronto como el contenido es dinámico o está controlado por una plantilla HTML.
¿Cuáles son los retos de la conversión de HTML a PDF con la biblioteca iTextSharp?
Aunque iTextSharp destaca en la creación programática de PDF, la conversión de HTML a PDF presenta importantes retos. La clase obsoleta HTMLWorker y su reemplazo XMLWorker tienen un soporte CSS limitado y tienen dificultades con el contenido web moderno, en particular cuando se trata de CSS responsivo y contenido renderizado 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¿Qué tan bien maneja iTextSharp la representación HTML?
Las limitaciones se hacen evidentes cuando se trabaja con diseños Bootstrap, contenido renderizado en JavaScript o estilos CSS3 complejos. Los problemas comunes incluyen la falta de fuentes web , diseños adaptables defectuosos y la falta de compatibilidad con tipos de medios CSS. Además, iTextSharp tiene problemas con caracteres de idiomas internacionales y gráficos SVG al convertir contenido HTML.
Estas limitaciones no son sólo cosméticas. Cuando una factura o un informe dirigido al cliente se representa incorrectamente porque no aparece un color de fondo o una cuadrícula se contrae, el PDF pierde su propósito. Para los equipos que mantienen plantillas HTML, reconstruir el mismo diseño en el modelo de objetos de iTextSharp significa mantener dos versiones de cada diseño de documento. Esa duplicación agrega costos e introduce una desviación entre la vista web y la salida PDF.
¿Cómo generar archivos PDF a partir de HTML utilizando Chrome Engine?
IronPDF transforma la generación de PDF utilizando un motor de renderizado de Chrome, lo que garantiza una conversión de HTML a PDF perfecta. Instale el paquete NuGet IronPDF para comenzar con un enfoque simplificado en su proyecto de 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()¿Qué calidad puedes esperar de la representación de Chrome?
El ChromePdfRenderer maneja diseños complejos sin necesidad de soluciones manuales. Es compatible con CSS Grid, Flexbox, fuentes web de Google Fonts y gráficos de JavaScript . La biblioteca también administra los retrasos de renderizado para contenido dinámico y admite la configuración de la ventana gráfica para páginas responsivas. Para conocer las opciones de configuración completas, consulte la referencia de opciones de renderizado .
¿Cómo convertir una vista Razor a PDF en ASP.NET MVC?
IronPDF se destaca por sus capacidades de representación de vistas Razor Engine. Puede convertir vistas completas de Razor directamente a PDF con soporte completo para ViewBag, ViewData y vinculación de modelos. El siguiente ejemplo representa una vista de factura del lado del servidor y la devuelve como un PDF descargable:
// 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¿Cómo se compara la conversión de Razor View con la creación manual?
Compare esto con el enfoque de iTextSharp, que requiere construir manualmente la estructura del documento en el código. Cada encabezado, celda de tabla, elección de fuente y ajuste de espaciado debe expresarse como un objeto C#. No existe ninguna plantilla HTML que se pueda iterar en un navegador; Cada cambio requiere un ciclo de compilación y verificación con la salida PDF.
La integración de Razor de IronPDF le permite reutilizar vistas de Razor , archivos HTML o cadenas HTML existentes para la generación de PDF. También puede trabajar con archivos ZIP HTML o implementar configuraciones de URL base para la carga de activos. La guía práctica de conversión de CSHTML a PDF explica todo el patrón de representación de Razor , incluida la configuración de la inyección de dependencia.
¿Cómo se gestionan las descargas de archivos y el streaming para crear un PDF?
Ambas bibliotecas admiten varios métodos de salida para archivos PDF en aplicaciones web. IronPDF ofrece funciones adicionales como compresión de PDF, linealización para visualización web rápida y rasterización de imágenes. El controlador de transmisión a continuación demuestra cómo manejar archivos PDF grandes con almacenamiento en caché y soporte de solicitud de rango:
// 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 escenarios avanzados, IronPDF admite la generación de PDF en paralelo, el procesamiento de múltiples subprocesos y las operaciones por lotes . Puede implementar un registro personalizado , manejar la autenticación de red, trabajar con cookies y agregar encabezados de solicitud HTTP para la generación segura de documentos.
¿Cómo se comparan las dos bibliotecas una al lado de la otra?
La siguiente tabla resume las diferencias clave entre iTextSharp y IronPDF para proyectos ASP.NET MVC:
| Función | iTextSharp | IronPDF |
|---|---|---|
| renderizado de HTML a PDF | Limitado (XMLWorker, sin CSS3 moderno) | Motor Chrome completo (CSS3, JS, Flexbox) |
| Compatibilidad con Razor y CSHTML | Sin soporte nativo | Representación de vista Razor incorporada |
| Seguridad de hilos | Requiere bloqueo manual | Hilos seguros por defecto |
| API asíncrona | Sin asincrónico nativo | Soporte asincrónico completo |
| Linux / Docker | Soportado | Soportado |
| Tipo de licencia | AGPL (código abierto) o comercial | Comercial con prueba gratuita |
| Firmas digitales | Sí | Sí |
| formularios PDF | Sí (manual) | Sí (desde elementos de formulario HTML) |
iTextSharp ofrece un control detallado para la creación programática de PDF, lo que lo convierte en una opción viable cuando la estructura del documento es simple y fija. IronPDF es la opción más sólida cuando necesita convertir plantillas HTML o vistas Razor en documentos PDF profesionales con representación precisa , compatibilidad total con CSS3 y ejecución de JavaScript .
Para aplicaciones ASP.NET de producción, IronPDF ofrece soporte asincrónico superior e integración con patrones .NET modernos, incluidas inyección de dependencia y canalizaciones de middleware. Su capacidad para representar vistas Razor , admitir firmas digitales y manejar diseños complejos lo convierten en la opción preferida para aplicaciones empresariales. La biblioteca también admite aplicaciones Blazor Server y compatibilidad con PDF/A para documentos de archivo.
¿Qué pasa con las licencias y los proyectos?
La biblioteca iTextSharp utiliza una licencia AGPL para su versión de código abierto, lo que requiere que el código de su aplicación también sea de código abierto. iText Group ofrece licencias comerciales para proyectos propietarios. Esta consideración de licencia es particularmente importante para productos SaaS o herramientas empresariales internas donde no se puede publicar el código fuente.
IronPDF utiliza un modelo de licencia comercial con una prueba gratuita para desarrollo y pruebas. Las licencias se escalan según el entorno de implementación: desarrollador, servidor único u opciones de implementación ilimitadas. Al implementar cualquiera de las soluciones, considere escenarios de implementación que incluyan entornos Docker, Azure y Linux.
Las consideraciones de rendimiento para escenarios de alto tráfico incluyen la implementación de operaciones asincrónicas, administración adecuada de la memoria y estrategias de almacenamiento en caché. El motor Chrome de IronPDF ofrece un rendimiento superior para la representación de HTML complejo, mientras que iTextSharp puede ser más eficiente para la generación de PDF programático simple sin HTML involucrado. Para las aplicaciones que generan cientos de archivos PDF por minuto, la evaluación comparativa bajo una carga realista es la guía más confiable para saber qué biblioteca se adapta a su infraestructura.
La migración de iTextSharp a IronPDF es sencilla para la mayoría de los proyectos MVC. El cambio principal consiste en reemplazar el código de creación manual de documentos con una plantilla HTML generada por el motor de Chrome. IronPDF proporciona documentación exhaustiva , ejemplos de código y soporte de ingeniería para facilitar las transiciones.
¿Cuales son tus próximos pasos?
Para proyectos nuevos que requieren conversión de HTML a PDF con soporte para estándares web modernos, IronPDF ofrece una clara ventaja con su renderizado basado en Chrome. Los proyectos heredados que ya utilizan iTextSharp para la creación básica de PDF pueden continuar con su implementación actual a menos que la precisión de la representación HTML se convierta en un requisito.
Comience con la prueba gratuita de IronPDF y pruébelo directamente con sus vistas Razor o plantillas HTML existentes. Explore la documentación completa y la referencia API para ver qué tan rápido se realiza la integración. Si tiene preguntas sobre la migración de un proyecto existente basado en iTextSharp o necesita orientación sobre el manejo del flujo de memoria PDF y la conformidad con PDF/A , el equipo de soporte está disponible para ayudarlo.
Para obtener una visión más amplia de cómo se compara IronPDF con la familia de productos iText, consulte la página de comparación dedicada a iText vs. IronPDF .
Preguntas Frecuentes
¿Cuál es la principal ventaja de utilizar IronPDF sobre iTextSharp para la generación de PDF en ASP.NET MVC?
IronPDF ofrece capacidades de renderizado HTML superiores a las de iTextSharp, lo que facilita la generación de PDF de alta calidad a partir de contenido web.
¿Puedo utilizar IronPDF para generar facturas en una aplicación ASP.NET MVC?
Sí, IronPDF es muy adecuado para generar facturas y otros documentos PDF en aplicaciones ASP.NET MVC debido a sus funciones de conversión de HTML a PDF.
¿Cómo es la implementación de IronPDF en comparación con iTextSharp en términos de facilidad de uso?
En general, se considera que IronPDF es más fácil de implementar que iTextSharp, sobre todo para los desarrolladores que buscan integrar rápidamente funciones de generación de PDF sin necesidad de una configuración exhaustiva.
¿Es IronPDF compatible con la conversión de páginas web complejas a PDF en ASP.NET MVC?
Sí, IronPDF destaca en la conversión de páginas web complejas a PDF, gracias a su avanzado motor de renderizado HTML que reproduce con precisión el contenido web.
¿Es IronPDF una buena opción para generar contenido descargable desde una aplicación ASP.NET MVC?
IronPDF es una excelente opción para generar contenidos descargables gracias a su capacidad para crear PDF de alta calidad a partir de una amplia gama de contenidos web.
¿Qué escenarios son ideales para utilizar IronPDF en la generación de PDF?
IronPDF es ideal para situaciones que requieren conversiones de HTML a PDF de alta calidad, como la generación de informes, facturas o documentos descargables a partir de contenido web.
¿Es IronPDF más compatible con las tecnologías web modernas que iTextSharp?
Sí, IronPDF está diseñado para trabajar con tecnologías web modernas, proporcionando mejor compatibilidad y precisión de renderizado en comparación con iTextSharp.
¿Cómo gestiona IronPDF las imágenes y CSS al generar archivos PDF?
IronPDF gestiona las imágenes y CSS con gran fidelidad, garantizando que el PDF resultante se ajuste al contenido HTML original, incluidos los diseños y estilos complejos.
¿Puede integrarse IronPDF fácilmente en los proyectos ASP.NET MVC existentes?
Sí, IronPDF puede integrarse fácilmente en proyectos ASP.NET MVC existentes, ofreciendo una API sencilla para que los desarrolladores implementen funciones de generación de PDF.
¿Cuáles son los principales casos de uso de IronPDF en aplicaciones ASP.NET MVC?
Los principales casos de uso de IronPDF en aplicaciones ASP.NET MVC incluyen la generación de informes, facturas y cualquier otro documento en el que sea fundamental una conversión precisa de HTML a PDF.
Comience gratis
Comience gratis
Reserve demostración en vivo gratis
No se requiere tarjeta de crédito ni creación de cuenta
