O IronPDF oferece excelente conversão de HTML para PDF com suporte completo a CSS3 e JavaScript , utilizando a renderização do Chrome. Em contraste, o iText oferece criação programática de PDF, mas enfrenta dificuldades com conversão moderna de HTML, tornando o IronPDF uma escolha melhor para aplicativos ASP.NET MVC que requerem PDFs de padrão 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. Enquanto iText tem sido uma escolha popular por anos, IronPDF oferece uma alternativa moderna com capacidades superiores de renderização de 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 iText constrói PDFs programaticamente através de um modelo de objeto, enquanto o IronPDF converte HTML em PDF usando um motor de renderização Chrome completo. Compreender essa diferença arquitetônica é a chave 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.
Antes de escrever qualquer código, você precisa adicionar cada biblioteca ao seu projeto. O NuGet é o gerenciador de pacotes padrão para .NET e lida com ambas as instalações de forma eficiente. Para iText, instale o pacote legado via NuGet:
dotnet add package iTextSharpPara o IronPDF, instale também através do NuGet :
O 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.
Para gerar arquivos PDF usando iText em sua aplicação ASP.NET MVC, primeiro instale a biblioteca através do NuGet. A biblioteca iText oferece controle de baixo nível sobre a criação de PDF através de sua classe Document e modelo de objetos.
O código a seguir demonstra uma implementação pronta para produção para criar PDFs com iText 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");
}
}
}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
Este código demonstra a abordagem fundamental: criar uma instância Document, anexar um PdfWriter a um fluxo, adicionar conteúdo usando objetos de elemento, e retornar o arquivo através 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.
Embora o iText se destaque na criação programática de PDF, converter HTML em PDF apresenta desafios significativos. A classe HTMLWorker obsoleta e sua substituição XMLWorker têm suporte limitado a CSS e enfrentam dificuldades com conteúdo web moderno, particularmente ao lidar com CSS responsivo e conteúdo renderizado em 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");
});
}
}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
As limitações tornam-se evidentes ao trabalhar com layouts do Bootstrap, conteúdo renderizado por JavaScript ou estilos CSS3 complexos. Problemas comuns incluem fontes web ausentes, layouts responsivos quebrados e falta de suporte para tipos de mídia CSS. Além disso, o iText tem 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, reconstruir o mesmo layout no modelo de objeto do iText 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.
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();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()
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 .
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);
}
}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
Contraste isso com a abordagem do iText, que requer a construção manual da estrutura do documento no 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.
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);
}
}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.
A tabela abaixo resume as principais diferenças entre iText e IronPDF para projetos ASP.NET MVC:
| Recurso | iText | 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 de threads | 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 iText oferece controle detalhado para criação programática de PDF, tornando-o 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.
A biblioteca iText usa uma licença AGPL para sua versão de código aberto, que requer que o código de sua aplicação 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 motor Chrome do IronPDF fornece desempenho superior para renderização de HTML complexo, enquanto o iText pode ser mais eficiente para geração programática simples de PDF sem HTML envolvido. 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 iText para o IronPDF é direta 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.
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 já usando iText para criação básica de PDF podem continuar com sua implementação existente, a menos que a precisão de 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 baseado em iText existente ou precisar de orientação sobre manipulação de fluxo de memória de PDF e conformidade com PDF/A, a equipe de suporte está disponível 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 .
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronPDF faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
Quando você precisa que seu PDF tenha a aparência de HTML, rapidamente.
