Ícono de mensaje
Saltar al pie de página
  1. IronPDF
  2. Blog de IronPDF
  3. Usando IronPDF
  4. Convertir HTML a PDF ASP.NET C#
USANDO IRONPDF

Convertir HTML a PDF en ASP.NET Core con C# -- Guía de IronPDF

Curtis Chau
Curtis Chau
Actualizado:

IronPDF convierte HTML a PDF en ASP.NET utilizando un motor de renderizado basado en Chrome que transforma sus cadenas HTML, archivos o URL en documentos PDF con píxeles perfectos con solo unas pocas líneas de código C#.

Cuando su aplicación ASP.NET necesita generar facturas, informes o documentos de cumplimiento a pedido, la calidad del resultado en PDF es importante. Los usuarios finales esperan una salida formateada que se vea exactamente como el HTML original, completa con su estilo CSS, fuentes personalizadas y diseños de tabla. El desafío es encontrar una biblioteca que maneje esta conversión sin requerir soluciones alternativas complejas para contenido moderno con mucho uso de CSS o JavaScript.

IronPDF es una biblioteca PDF de C# creada para este desafío. Su motor de renderizado basado en Chrome procesa HTML de la misma manera que lo hace un navegador real, lo que significa que las propiedades CSS3, las consultas de medios y el contenido renderizado en JavaScript aparecen correctamente en el documento final. Las secciones a continuación explican la instalación, los tres métodos de representación principales, el manejo de datos de formularios, las funciones de formato avanzadas y el soporte de autenticación: todo lo necesario para integrar la generación de PDF lista para producción en su aplicación ASP.NET Core .

¿Cómo convertir rápidamente HTML a PDF en ASP.NET Core?

Para comenzar a convertir HTML a PDF en ASP.NET Core solo se necesitan unas pocas líneas de código. Primero, instale IronPDF a través del Administrador de paquetes NuGet :

Install-Package IronPdf

Una vez instalado, la clase ChromePdfRenderer es el punto de entrada principal para todas las operaciones de renderizado. Aquí hay un ejemplo completo que muestra cómo convertir una cadena HTML en un PDF descargable dentro de un controlador ASP.NET Core MVC:

  1. Instala IronPDF con el Administrador de Paquetes NuGet

    PM > Install-Package IronPdf

  2. Copie y ejecute este fragmento de código.

    using IronPdf;
using Microsoft.AspNetCore.Mvc;

// program.cs
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();
var app = builder.Build();
app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");
app.Run();

// PdfController.cs
public class PdfController : Controller
{
    public IActionResult GeneratePdf()
    {
        var renderer = new ChromePdfRenderer();
        string html = @"
            <h1>Invoice #2024-001</h1>
            <p>Generated on: " + DateTime.Now.ToString("yyyy-MM-dd") + @"</p>
            <table>
                <tr><th>Item</th><th>Price</th></tr>
                <tr><td>Professional License</td><td>$799</td></tr>
            </table>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        return File(pdf.BinaryData, "application/pdf", "invoice.pdf");
    }
}

  3. Despliegue para probar en su entorno real

    Comienza a usar IronPDF en tu proyecto hoy mismo con una prueba gratuita

    arrow pointer

¿Qué aspecto tiene el PDF generado?

PDF viewer displaying a simple invoice document with number #2024-001, showing an invoice header, generation date, and a table with Item and Price columns containing a Professional License entry for $799

La clase ChromePdfRenderer maneja toda la representación compleja, garantizando que la estructura HTML, los estilos CSS e incluso JavaScript se representen correctamente en la salida PDF final. El valor de retorno es un objeto PdfDocument cuya propiedad BinaryData puedes transmitir directamente al navegador como una descarga de archivo.

¿Cómo elegir el método de renderizado adecuado para su fuente?

IronPDF ofrece tres métodos de renderizado principales, cada uno diseñado para una fuente de contenido específica. Comprender qué método se adapta a su escenario evita complejidad innecesaria y mantiene limpio el código de su controlador.

Métodos de representación de IronPDF según la fuente de contenido
Tipo de fuente Método Mejor para
Cadena HTML en memoria `RenderHtmlAsPdf` Informes basados ​​en bases de datos, facturas con plantillas y contenido dinámico
Archivo HTML en el disco `RenderHtmlFileAsPdf` Plantillas estáticas en wwwroot, diseños proporcionados por agencias de diseño
URL web en vivo `RenderUrlAsPdf` Archivar páginas, capturar SPA después de renderizar JavaScript

¿Cómo convertir cadenas HTML dinámicas?

Cuando trabajes con contenido dinámico como informes basados en bases de datos, utiliza RenderHtmlAsPdf para convertir cadenas HTML directamente. Este método acepta cualquier marcado HTML válido y devuelve un PDF completamente renderizado:

var renderer = new ChromePdfRenderer();
string htmlContent = BuildDynamicHtml(); // your method to generate HTML
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs("dynamic-report.pdf");
var renderer = new ChromePdfRenderer();
string htmlContent = BuildDynamicHtml(); // your method to generate HTML
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs("dynamic-report.pdf");
Dim renderer As New ChromePdfRenderer()
Dim htmlContent As String = BuildDynamicHtml() ' your method to generate HTML
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
pdf.SaveAs("dynamic-report.pdf")
$vbLabelText   $csharpLabel

Informe de prueba de IronPDF que muestra contenido HTML renderizado con estilo CSS, incluyendo un encabezado azul que dice 'Informe de Prueba de IronPDF', texto de párrafo estilizado en verde y una tabla de datos formateada que contiene información de productos con ítems como widgets y herramientas

Este enfoque funciona bien para generar documentos PDF a partir de plantillas HTML rellenas con datos en tiempo real, envíos de formularios o cualquier contenido generado dinámicamente. El motor de renderizado conserva todo el estilo CSS, incluidas las fuentes, los colores y el formato de tabla personalizados. Cuando tu HTML hace referencia a hojas de estilo externas o imágenes usando rutas relativas, pasa un baseUrl como el segundo argumento para que el renderizador pueda resolver esos recursos correctamente.

¿Cómo convertir archivos HTML estáticos desde el disco?

Para plantillas HTML almacenadas como archivos físicos, utiliza RenderHtmlFileAsPdf para convertirlas sin cargarlas primero en memoria. Esto es eficiente para plantillas grandes y evita la concatenación de cadenas:

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlFileAsPdf("wwwroot/templates/report-template.html");
pdf.SaveAs("report.pdf");
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlFileAsPdf("wwwroot/templates/report-template.html");
pdf.SaveAs("report.pdf");
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlFileAsPdf("wwwroot/templates/report-template.html")
pdf.SaveAs("report.pdf")
$vbLabelText   $csharpLabel

Este método resuelve automáticamente las rutas relativas de las hojas de estilo CSS, imágenes y otros recursos externos referenciados en el archivo. Funciona bien cuando el equipo de diseño mantiene archivos de plantilla HTML separados fuera del código base de C# de la aplicación. El método admite consultas de medios de impresión CSS y fuentes personalizadas , por lo que las plantillas creadas para entornos de impresión se representan fielmente sin configuración adicional.

¿Cómo convertir la URL de una página web a PDF?

Para capturar una página web en vivo o renderizar una página accesible por URL como un PDF, utiliza RenderUrlAsPdf. Este método inicia el motor de Chrome, navega hasta la URL, espera a que la página se cargue por completo y luego captura la salida renderizada:

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.RenderDelay(1000);
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Screen;
var pdf = renderer.RenderUrlAsPdf("https://en.wikipedia.org/wiki/PDF");
pdf.SaveAs("webpage.pdf");
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.RenderDelay(1000);
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Screen;
var pdf = renderer.RenderUrlAsPdf("https://en.wikipedia.org/wiki/PDF");
pdf.SaveAs("webpage.pdf");
Dim renderer = New ChromePdfRenderer()
renderer.RenderingOptions.EnableJavaScript = True
renderer.RenderingOptions.WaitFor.RenderDelay(1000)
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Screen
Dim pdf = renderer.RenderUrlAsPdf("https://en.wikipedia.org/wiki/PDF")
pdf.SaveAs("webpage.pdf")
$vbLabelText   $csharpLabel

Página principal de Wikipedia mostrada en un visor de PDF mostrando el diseño completo de la página web con navegación, secciones de contenido, vista previa de artículo destacado y logo de Wikipedia, demostrando una conversión exitosa de HTML a PDF con formato e imágenes preservadas

La opción WaitFor.RenderDelay indica al renderizador que pause después de cargar la página antes de capturar. Esto es valioso para aplicaciones de una sola página que construyen su DOM a través de JavaScript después de que llega la respuesta HTML inicial. Configurar EnableJavaScript = true activa el motor JavaScript completo de Chrome, de modo que gráficos, cuadrículas de datos y otros componentes renderizados por JavaScript aparecen en el PDF tal como lo hacen en un navegador.

¿Cómo se gestionan los datos del formulario y las solicitudes POST?

El procesamiento de datos de formulario antes de la generación del PDF es un patrón común en las aplicaciones ASP.NET : las confirmaciones de pedidos, los recibos de entrega y los recibos siguen este modelo. El enfoque es vincular los datos del formulario publicado a un modelo, crear una cadena HTML a partir de ese modelo y luego representar la cadena como PDF:

[HttpPost]
public IActionResult ProcessFormToPdf(OrderModel model)
{
    var renderer = new ChromePdfRenderer();
    string html = $@"
        <h2>Order Confirmation</h2>
        <p>Customer: {model.CustomerName}</p>
        <p>Order Date: {model.OrderDate:yyyy-MM-dd}</p>
        <ul>
            {string.Join("", model.Items.Select(i => $"<li>{i.Name} -- ${i.Price}</li>"))}
        </ul>
        <p><strong>Total: ${model.Total}</strong></p>";
    var pdf = renderer.RenderHtmlAsPdf(html);
    string fileName = $"order-{model.OrderId}.pdf";
    return File(pdf.BinaryData, "application/pdf", fileName);
}
[HttpPost]
public IActionResult ProcessFormToPdf(OrderModel model)
{
    var renderer = new ChromePdfRenderer();
    string html = $@"
        <h2>Order Confirmation</h2>
        <p>Customer: {model.CustomerName}</p>
        <p>Order Date: {model.OrderDate:yyyy-MM-dd}</p>
        <ul>
            {string.Join("", model.Items.Select(i => $"<li>{i.Name} -- ${i.Price}</li>"))}
        </ul>
        <p><strong>Total: ${model.Total}</strong></p>";
    var pdf = renderer.RenderHtmlAsPdf(html);
    string fileName = $"order-{model.OrderId}.pdf";
    return File(pdf.BinaryData, "application/pdf", fileName);
}
Imports System
Imports System.Linq
Imports Microsoft.AspNetCore.Mvc

<HttpPost>
Public Function ProcessFormToPdf(model As OrderModel) As IActionResult
    Dim renderer = New ChromePdfRenderer()
    Dim html As String = $"
        <h2>Order Confirmation</h2>
        <p>Customer: {model.CustomerName}</p>
        <p>Order Date: {model.OrderDate:yyyy-MM-dd}</p>
        <ul>
            {String.Join("", model.Items.Select(Function(i) $"<li>{i.Name} -- ${i.Price}</li>"))}
        </ul>
        <p><strong>Total: ${model.Total}</strong></p>"
    Dim pdf = renderer.RenderHtmlAsPdf(html)
    Dim fileName As String = $"order-{model.OrderId}.pdf"
    Return File(pdf.BinaryData, "application/pdf", fileName)
End Function
$vbLabelText   $csharpLabel

¿Cómo se ve la interfaz del formulario?

Interfaz de formulario web mostrando una página de creación de pedidos con sección de detalles del cliente que contiene el campo de nombre 'Jane Doe' y fecha '19/11/2025', sección de artículos del pedido mostrando 'Laptop' con precio de '1300', resumen del pedido mostrando total y un botón azul 'Generar PDF'

¿Cómo aparecen los datos del formulario en el PDF generado?

PDF viewer showing a clean order confirmation document with header 'Order Confirmation', customer name 'Jane Doe', order date '2025-11-19', itemized list showing laptop purchase for $1300, demonstrating successful form-to-PDF conversion

Para escenarios de documentos más avanzados, puede integrar formularios PDF o editar plantillas PDF existentes con campos precargados. La biblioteca también admite firmas digitales para documentos legales y contratos, lo que le permite agregar firmas criptográficamente verificables a cualquier documento generado.

Una consideración importante al incrustar datos de usuario en cadenas HTML es la desinfección. Siempre escape las cadenas proporcionadas por el usuario antes de insertarlas en HTML para evitar problemas de inyección. Una simple llamada System.Web.HttpUtility.HtmlEncode(model.CustomerName) en cada campo mantiene la plantilla segura antes de pasarla al renderizador.

¿Cómo agregar formato profesional, encabezados y marcas de agua?

¿Cómo configurar encabezados, pies de página y marcas de agua?

Los documentos PDF profesionales a menudo requieren encabezados y pies de página en cada página, junto con marcas de agua para borradores o documentos confidenciales. IronPDF maneja ambos a través de propiedades en el objeto RenderingOptions y el método ApplyWatermark en el PdfDocument resultante:

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    MaxHeight = 25,
    HtmlFragment = "<div style='text-align:center'>Annual Report 2024</div>"
};
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    MaxHeight = 20,
    HtmlFragment = "<div style='text-align:center'>Page {page} of {total-pages}</div>"
};
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.ApplyWatermark("<h2 style='color:red;opacity:0.3'>CONFIDENTIAL</h2>",
    30, VerticalAlignment.Middle, HorizontalAlignment.Center);
pdf.SaveAs("report-with-watermark.pdf");
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    MaxHeight = 25,
    HtmlFragment = "<div style='text-align:center'>Annual Report 2024</div>"
};
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    MaxHeight = 20,
    HtmlFragment = "<div style='text-align:center'>Page {page} of {total-pages}</div>"
};
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.ApplyWatermark("<h2 style='color:red;opacity:0.3'>CONFIDENTIAL</h2>",
    30, VerticalAlignment.Middle, HorizontalAlignment.Center);
pdf.SaveAs("report-with-watermark.pdf");
Imports IronPdf

Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter With {
    .MaxHeight = 25,
    .HtmlFragment = "<div style='text-align:center'>Annual Report 2024</div>"
}
renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter With {
    .MaxHeight = 20,
    .HtmlFragment = "<div style='text-align:center'>Page {page} of {total-pages}</div>"
}
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
pdf.ApplyWatermark("<h2 style='color:red;opacity:0.3'>CONFIDENTIAL</h2>", 30, VerticalAlignment.Middle, HorizontalAlignment.Center)
pdf.SaveAs("report-with-watermark.pdf")
$vbLabelText   $csharpLabel

Informe de prueba de IronPDF mostrando un documento PDF con encabezado azul personalizado 'Informe de Prueba de IronPDF', formato de texto en línea en verde, una tabla de datos con información de productos y una marca de agua 'CONFIDENTIAL' en rojo posicionada diagonalmente a través de la página

Los marcadores de posición {page} y {total-pages} en HTML del pie de página se reemplazan automáticamente en el momento de renderizado, por lo que obtienes números de página correctos sin procesamiento posterior. También puede agregar números de página , imágenes de fondo o superposiciones de primer plano y sellos de texto o imágenes personalizados .

¿Cómo utilizar medios de impresión CSS para controlar el diseño de PDF?

Para asegurar que la salida PDF coincida con las expectativas, usa reglas CSS @media print y el ajuste PdfCssMediaType.Print. IronPDF admite totalmente el control de saltos de página y tamaños de papel personalizados :

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
renderer.RenderingOptions.ViewPortWidth = 1024;
renderer.RenderingOptions.MarginTop = 10;
renderer.RenderingOptions.MarginBottom = 10;
renderer.RenderingOptions.MarginLeft = 10;
renderer.RenderingOptions.MarginRight = 10;
string html = @"
    <style>
        @media print {
            .no-print { display: none; }
            body { font-size: 12pt; }
            .page-break { page-break-after: always; }
        }
        @page {
            size: A4;
            margin: 1cm;
        }
    </style>
    <div class='content'>
        <h1>Professional Report</h1>
        <div class='page-break'></div>
        <h2>Section 2</h2>
    </div>";
var pdf = renderer.RenderHtmlAsPdf(html);
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
renderer.RenderingOptions.ViewPortWidth = 1024;
renderer.RenderingOptions.MarginTop = 10;
renderer.RenderingOptions.MarginBottom = 10;
renderer.RenderingOptions.MarginLeft = 10;
renderer.RenderingOptions.MarginRight = 10;
string html = @"
    <style>
        @media print {
            .no-print { display: none; }
            body { font-size: 12pt; }
            .page-break { page-break-after: always; }
        }
        @page {
            size: A4;
            margin: 1cm;
        }
    </style>
    <div class='content'>
        <h1>Professional Report</h1>
        <div class='page-break'></div>
        <h2>Section 2</h2>
    </div>";
var pdf = renderer.RenderHtmlAsPdf(html);
Imports IronPdf

Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print
renderer.RenderingOptions.ViewPortWidth = 1024
renderer.RenderingOptions.MarginTop = 10
renderer.RenderingOptions.MarginBottom = 10
renderer.RenderingOptions.MarginLeft = 10
renderer.RenderingOptions.MarginRight = 10

Dim html As String = "
    <style>
        @media print {
            .no-print { display: none; }
            body { font-size: 12pt; }
            .page-break { page-break-after: always; }
        }
        @page {
            size: A4;
            margin: 1cm;
        }
    </style>
    <div class='content'>
        <h1>Professional Report</h1>
        <div class='page-break'></div>
        <h2>Section 2</h2>
    </div>"

Dim pdf = renderer.RenderHtmlAsPdf(html)
$vbLabelText   $csharpLabel

Visor de documentos PDF mostrando un informe profesional de dos páginas con un zoom del 76% con el título 'Informe Profesional' en la página 1 y el encabezado 'Sección 2' en la página 2, mostrando un diseño limpio con saltos de página adecuados y formato CSS aplicado

El uso de CSS de impresión garantiza que los documentos PDF mantengan un formato profesional a la vez que se ocultan elementos web innecesarios, como menús de navegación o botones interactivos. Configurar CssMediaType = PdfCssMediaType.Print le dice al renderizador aplicar tus reglas @media print en lugar de los estilos de pantalla, lo que típicamente elimina decoraciones de fondo y ajusta la tipografía para la salida de impresión. También puede configurar márgenes personalizados por página y controlar la orientación y rotación de la página para informes de formato ancho o rotados.

La especificación de W3C CSS Páginas Medias define cómo deben comportarse propiedades como @page, page-break-before y widows en la salida paginada. El motor Chrome de IronPDF sigue esta especificación de cerca, por lo que los estilos escritos según el estándar CSS se traducen con precisión al PDF sin necesidad de ajustes manuales.

¿Cómo se gestiona la autenticación para páginas protegidas?

Para aplicaciones seguras, IronPDF admite varios métodos de autenticación, incluidas cookies , encabezados de solicitud HTTP y credenciales de red . Esto le permite representar páginas que requieren una sesión iniciada o autenticación básica:

var renderer = new ChromePdfRenderer();
renderer.RequestContext.Cookies.Add(new Cookie
{
    Name = "SessionId",
    Value = "your-session-token",
    Domain = "example.com"
});
renderer.ChromePdfRenderOptions.HttpLoginCredentials = new HttpLoginCredentials
{
    Username = "user",
    Password = "password"
};
var pdf = renderer.RenderUrlAsPdf("https://app.example.com/protected/report");
var renderer = new ChromePdfRenderer();
renderer.RequestContext.Cookies.Add(new Cookie
{
    Name = "SessionId",
    Value = "your-session-token",
    Domain = "example.com"
});
renderer.ChromePdfRenderOptions.HttpLoginCredentials = new HttpLoginCredentials
{
    Username = "user",
    Password = "password"
};
var pdf = renderer.RenderUrlAsPdf("https://app.example.com/protected/report");
Dim renderer = New ChromePdfRenderer()
renderer.RequestContext.Cookies.Add(New Cookie With {
    .Name = "SessionId",
    .Value = "your-session-token",
    .Domain = "example.com"
})
renderer.ChromePdfRenderOptions.HttpLoginCredentials = New HttpLoginCredentials With {
    .Username = "user",
    .Password = "password"
}
Dim pdf = renderer.RenderUrlAsPdf("https://app.example.com/protected/report")
$vbLabelText   $csharpLabel

También puede cifrar el PDF resultante con una contraseña de propietario y una contraseña de usuario, restringiendo acciones como imprimir, copiar o editar. La combinación de la representación basada en autenticación con permisos a nivel de PDF le brinda control sobre quién puede generar un documento y qué pueden hacer los destinatarios con él una vez que lo tienen.

Para entornos empresariales, considere utilizar la API de representación asincrónica al generar archivos PDF dentro de los controladores de solicitudes web. La representación asincrónica mantiene libre el grupo de subprocesos ASP.NET mientras el motor Chrome procesa el documento, lo que mejora el rendimiento bajo carga simultánea. La biblioteca también admite la representación multiproceso para escenarios de generación de documentos por lotes.

¿Por qué es importante el motor de renderizado Chrome para convertir HTML a PDF?

La mayoría de las bibliotecas de generación de PDF funcionan analizando HTML mediante un motor personalizado. Esto significa que solo admiten un subconjunto de propiedades CSS, carecen de ejecución de JavaScript y presentan dificultades con técnicas de diseño modernas como CSS Grid o Flexbox. IronPDF adopta un enfoque diferente al incorporar el motor Chrome, la misma tecnología que impulsa el navegador Google Chrome.

El resultado práctico es que cualquier página HTML que se muestre correctamente en Chrome se representará correctamente como PDF a través de IronPDF. Esto elimina una clase común de errores en los que la salida del PDF difiere de la apariencia esperada porque el motor de renderizado interpreta el CSS de manera diferente al navegador que el desarrollador utilizó durante el diseño.

La referencia de MDN Web Docs para CSS Paged Media y la documentación de ASP.NET Core de Microsoft describen características que IronPDF admite a través de su base basada en Chrome. Los desarrolladores que ya están familiarizados con HTML, CSS y JavaScript estándar pueden aplicar ese conocimiento directamente a la generación de PDF sin tener que aprender un lenguaje de diseño de documentos independiente.

Las opciones de representación de IronPDF exponen controles para el tamaño del papel, los márgenes, la ejecución de JavaScript y los retrasos en la representación. La biblioteca maneja texto UTF-8 y conjuntos de caracteres internacionales, fuentes web referenciadas a través de Google Fonts o archivos locales, e incluso puede convertir documentos Markdown a PDF . Para requisitos de cumplimiento de archivo o accesibilidad, admite los formatos de salida PDF/A y PDF/UA . La biblioteca se ejecuta en Windows, Linux y macOS y se implementa en Azure y AWS sin configuración adicional.

¿Cuales son tus próximos pasos?

Convertir HTML a PDF en ASP.NET C# con IronPDF proporciona a su aplicación un flujo de trabajo de generación de documentos fiable y preciso para el navegador. Los tres métodos de renderizado (cadena HTML, archivo HTML y URL) abarcan toda la gama de fuentes de contenido que encontrará en la práctica. Funciones avanzadas como encabezados, pies de página, marcas de agua y CSS de impresión le permiten generar resultados profesionales sin posprocesar el PDF manualmente.

El siguiente paso es instalar el paquete NuGet y ejecutar el ejemplo de inicio rápido de la primera sección de esta guía. A partir de ahí, explore el tutorial completo de PDF en C# para profundizar en la estructura del documento o revise la guía de edición de PDF para aprender a fusionar, dividir, anotar y extraer contenido de archivos PDF existentes.

Si su proyecto apunta a Blazor, el tutorial en PDF de Blazor lo guía a través de la integración del lado del servidor y de WebAssembly. Para proyectos MVC, la guía de PDF para MVC Core y la guía de Razor Pages cubren la renderización basada en plantillas con vistas de .cshtml. Para la depuración y el ajuste del rendimiento, IronPDF proporciona un registro personalizado y una guía de rendimiento que ayudan a identificar cuellos de botella en flujos de trabajo de generación de documentos de gran volumen.

Comienza una prueba gratuita para probar cada característica de la biblioteca en tu propio proyecto antes de comprometerte con una licencia. Para implementaciones de producción, hay opciones de licencia disponibles para desarrolladores individuales, equipos y escenarios de redistribución empresarial.

Preguntas Frecuentes

¿Cómo puedo convertir HTML a PDF en ASP.NET Core?

Instala IronPDF a través de NuGet, crea una instancia de ChromePdfRenderer y llama a RenderHtmlAsPdf con tu cadena HTML. El renderizador devuelve un PdfDocument cuyo BinaryData puedes transmitir al navegador.

¿Qué hace que IronPDF sea adecuado para la conversión de HTML a PDF?

IronPDF incluye el motor de renderizado Chrome, por lo que cualquier página HTML que se muestre correctamente en Chrome se renderiza correctamente como PDF. Esto incluye CSS3, contenido renderizado por JavaScript, fuentes web y diseños responsivos.

¿Es posible generar facturas e informes con IronPDF en ASP.NET?

Sí. Crea una cadena HTML a partir de tu modelo de datos, pásala a RenderHtmlAsPdf y devuelve el BinaryData como una descarga de archivo. IronPDF preserva el formato de las tablas, las fuentes personalizadas y el estilo CSS en la salida.

¿IronPDF admite consultas de medios de impresión CSS?

Sí. Configura RenderingOptions.CssMediaType = PdfCssMediaType.Print para activar las reglas @media print, que ocultan elementos de navegación y aplican tipografía optimizada para impresión.

¿IronPDF puede manejar contenido renderizado por JavaScript?

Sí. Configura RenderingOptions.EnableJavaScript = true y utiliza WaitFor.RenderDelay para pausar después de la carga de la página, dando tiempo al motor de JavaScript para construir el DOM antes de capturar el PDF.

¿Cómo maneja IronPDF la autenticación para páginas protegidas?

IronPDF admite cookies de sesión, encabezados HTTP y credenciales de autenticación básica a través de las propiedades RequestContext.Cookies y ChromePdfRenderOptions.HttpLoginCredentials.

¿Qué plataformas soporta IronPDF?

IronPDF funciona en Windows, Linux y macOS, y se puede desplegar en Azure y AWS. Está dirigido a .NET 6, .NET 7, .NET 8 y .NET Framework 4.6.2 y versiones superiores.

¿IronPDF admite la salida PDF/A para archivo?

Sí. IronPDF admite el cumplimiento de PDF/A para archivo a largo plazo y PDF/UA para accesibilidad. Estos modos de salida se pueden configurar mediante los métodos SaveAsPdfA y SaveAsPdfUA.

Curtis Chau
Curtis Chau
  Chatea con el equipo de ingeniería ahora
Escritor Técnico

Curtis Chau tiene una licenciatura en Ciencias de la Computación (Carleton University) y se especializa en el desarrollo front-end con experiencia en Node.js, TypeScript, JavaScript y React. Apasionado por crear interfaces de usuario intuitivas y estéticamente agradables, disfruta trabajando con frameworks modernos y creando manuales bien ...

Leer más

Artículos Relacionados

Prueba de 30 días → Producto completo. Sin límites. Sin tarjeta. Prueba gratis

Equipo de soporte de Iron

Estamos disponibles online las 24 horas, 5 días a la semana.
Chat
Email
Llámame