1. IronPDF
  2. Tutoriales
  3. Generación de PDF .NET Core
Cómo generar archivos PDF en .NET Core

Convertir HTML a PDF en .NET Core usando C# con IronPDF

Jacob Mellor, Director de Tecnología @ Team Iron
Jacob Mellor
Actualizado:
This article was translated from English: Does it need improvement?
Translated
View the article in English

Generar PDFs de alta fidelidad directamente desde HTML es un requerimiento rutinario en aplicaciones modernas de .NET: informes, facturas y boletos necesitan una salida perfecta de píxeles que coincida con la interfaz de usuario web. IronPDF agiliza este flujo de trabajo al ofrecer una única API de C# para renderizar HTML, vistas Razor y sitios web completos en documentos PDF que cumplen con los estándares. Al final de esta guía, un desarrollador podrá convertir URLs, HTML sin procesar o vistas MVC en un proyecto ASP.NET Core y desplegar el mismo código en entornos de Windows, Linux, Docker o sin servidor.

ConsejosPara problemas de diseño, IronPDF proporciona un depurador de Chrome sin cabeza que ayuda a diagnosticar peculiaridades de CSS, JavaScript, y consultas de medios antes de que el PDF sea renderizado. Revisa la guía dedicada HTML a PDF de píxeles perfectos para técnicas detalladas.

Inicio rápido: crear un PDF a partir de HTML en .NET Core

Convierte sin esfuerzo HTML a PDF en .NET Core usando la biblioteca IronPDF. Esta guía proporciona un ejemplo simple para comenzar rápidamente renderizando contenido HTML en un PDF de alta calidad con código mínimo. Perfecto para desarrolladores que buscan integrar la creación de PDF en sus aplicaciones con facilidad.

  1. Instala IronPDF con el Administrador de Paquetes NuGet

    PM > Install-Package IronPdf

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

    var pdf = new IronPdf.ChromePdfRenderer().RenderHtmlAsPdf("<h1>Hello World</h1>");

  3. Despliegue para probar en su entorno real

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

    arrow pointer

Flujo de trabajo mínimo (5 pasos)

  1. Instale el paquete NuGet IronPDF
  2. Convertir laURLde un sitio web con RenderUrlAsPdf
  3. Renderizar HTML sin procesar mediante RenderizarHtmlAsPdf
  4. Exportar una vista MVC a PDF
  5. Ajustar el tamaño del papel, los márgenes, los encabezados y los pies de página

Lista de inicio rápido

  1. Instalar – Install-Package IronPdf
  2. Renderizar una URL – ChromePdfRenderer.RenderUrlAsPdf()
  3. Renderizar HTML bruto – ChromePdfRenderer.RenderHtmlAsPdf()
  4. Exportar una vista Razor – ChromePdfRenderer.RenderHtmlAsPdfAsync()
  5. Ajustar finamente el resultado – aprovechar ChromePdfRenderer.RenderingOptions

Qué cubre este tutorial

  • Conversión de URL, cadena HTML y vista Razor
  • Configuración de papel, márgenes y tipo de medio
  • Despliegue multiplataforma (Windows, Linux, Docker)
  • Post-procesamiento: fusionar, marca de agua, proteger con contraseña, y firmar digitalmente PDFs
  • Ejemplo completo: aplicación MVC de reserva de boletos

¿Cómo se instala la biblioteca PDF en .NET Core?

Instalar la biblioteca es una sola línea en cualquier proyecto .NET 8 y sigue siendo compatible con .NET 9 preview y el próximo lanzamiento de .NET 10. Usa la Consola del Administrador de Paquetes de NuGet y el administrador de paquetes resolverá automáticamente cada dependencia para los objetivos Windows, Linux, Docker y sin servidor.

PM> Install-Package IronPdf             # .NET 8 LTS and higher
PM> Install-Package IronPdf             # .NET 8 LTS and higher
SHELL

Por favor nota¿Necesitas CLI? El mismo comando funciona con dotnet add package IronPdf dentro de tu carpeta del proyecto.

Una vez instalado, confirma que todo esté conectado convirtiendo cualquierURLpública:

// Program.cs — .NET 8 LTS
using IronPdf;

var renderer = new ChromePdfRenderer();

// Render a live website to PDF
using PdfDocument pdf = renderer.RenderUrlAsPdf("https://example.com");

// Persist to disk
pdf.SaveAs("website-snapshot.pdf");
// Program.cs — .NET 8 LTS
using IronPdf;

var renderer = new ChromePdfRenderer();

// Render a live website to PDF
using PdfDocument pdf = renderer.RenderUrlAsPdf("https://example.com");

// Persist to disk
pdf.SaveAs("website-snapshot.pdf");
' Program.cs — .NET 8 LTS
Imports IronPdf

Private renderer = New ChromePdfRenderer()

' Render a live website to PDF
Private PdfDocument As using

' Persist to disk
pdf.SaveAs("website-snapshot.pdf")
$vbLabelText   $csharpLabel

Cómo funciona

  • ChromePdfRenderer crea una instancia de Chromium en un entorno aislado; no se requiere una instalación separada de Chrome.
  • RenderUrlAsPdf captura el DOM completamente renderizado, incluyendo contenido impulsado por JavaScript, consultas de medios CSS y fuentes.
  • El resultado PdfDocument expone métodos de ayuda para fusionar, proteger con contraseña o firmar digitalmente el resultado, capacidades que se cubrirán más adelante en este tutorial.

Para más detalles sobre matices de despliegue (Azure App Service, AWS Lambda, Linux local), consulta la guía de instalación dedicada y las páginas de configuración avanzada de NuGet. Consejos internos de CI/CD para Docker y clústeres de K8s se cubren en mejores prácticas de despliegue en Docker.

¿Cómo puede un servicio .NET Core convertir laURLde un sitio web en PDF?

Una sola llamada a RenderUrlAsPdf es suficiente: pasa cualquierURLpúblicamente accesible e IronPDF devuelve un PDF completamente renderizado y compatible con los estándares. El código a continuación está dirigido a .NET 8 LTS y se compila sin cambios en .NET 9 preview, así como en el próximo lanzamiento de .NET 10 en 2025.

Ejemplo paso a paso

// Program.cs — .NET 8 LTS-compatible
using IronPdf;

// 1. Activate a license (or trial key)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

// 2. Create a reusable renderer instance
var renderer = new ChromePdfRenderer
{
    RenderingOptions =
    {
        // Force A4 portrait output and apply @media print styles
        PaperSize    = PdfPaperSize.A4,
        CssMediaType = PdfCssMediaType.Print
    }
};

// 3. Convert Microsoft Docs home page to PDF
using PdfDocument pdf = renderer.RenderUrlAsPdf("https://learn.microsoft.com/");

// 4. Save the PDF or stream it from a Web API
pdf.SaveAs("docs-offline-copy.pdf");
// Program.cs — .NET 8 LTS-compatible
using IronPdf;

// 1. Activate a license (or trial key)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

// 2. Create a reusable renderer instance
var renderer = new ChromePdfRenderer
{
    RenderingOptions =
    {
        // Force A4 portrait output and apply @media print styles
        PaperSize    = PdfPaperSize.A4,
        CssMediaType = PdfCssMediaType.Print
    }
};

// 3. Convert Microsoft Docs home page to PDF
using PdfDocument pdf = renderer.RenderUrlAsPdf("https://learn.microsoft.com/");

// 4. Save the PDF or stream it from a Web API
pdf.SaveAs("docs-offline-copy.pdf");
' Program.cs — .NET 8 LTS-compatible
Imports IronPdf

' 1. Activate a license (or trial key)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

' 2. Create a reusable renderer instance
Dim renderer = New ChromePdfRenderer With {
	.RenderingOptions = {
		PaperSize = PdfPaperSize.A4,
		CssMediaType = PdfCssMediaType.Print
	}
}

' 3. Convert Microsoft Docs home page to PDF
Using pdf As PdfDocument = renderer.RenderUrlAsPdf("https://learn.microsoft.com/")
	
	' 4. Save the PDF or stream it from a Web API
	pdf.SaveAs("docs-offline-copy.pdf")
End Using
$vbLabelText   $csharpLabel

Por qué funciona

  • ChromePdfRenderer crea una instancia de Chromium en un entorno aislado; no se requiere dependencia de Chrome en el sistema, manteniendo las imágenes Docker livianas.
  • RenderUrlAsPdf espera a que el DOM y JavaScript terminen antes de capturar la instantánea, de modo que las aplicaciones de una sola página se rendericen correctamente.
  • Configurar CssMediaType a Imprimir indica al motor utilizar reglas específicas de impresión, coincidiendo con la salida de Imprimir → Guardar como PDF de un navegador.
  • El resultado PdfDocument puede ser encriptado, firmado digitalmente, fusionado o rasterizado, capacidades cubiertas en secciones posteriores.

ConsejosDepuración a nivel de píxel: habilita renderer.LoggingOptions.DebugMode = true y sigue la guía de depuración de Chrome sin cabeza para inspeccionar las DevTools en vivo durante la renderización.

Recursos relacionados

¿Cómo convierto HTML sin formato en un PDF en .NET Core?

Pasar una cadena HTML, o el marcado renderizado de una vista Razor, a ChromePdfRenderer.RenderHtmlAsPdf produce instantáneamente un PDF compatible con los estándares. El método inicia el motor Chromium integrado de IronPDF, por lo que no se requiere la instalación de un navegador externo ni la dependencia de WebView. El mismo código que se muestra a continuación se compila en .NET 8 LTS hoy y sigue siendo compatible con .NET 9 y el lanzamiento programado de .NET 10 en noviembre de 2025.

Ejemplo - generar un PDF a partir de un fragmento HTML

// Program.cs — compatible with .NET 8 and newer
using IronPdf;

// Sample HTML fragment (could also be read from a file, Razor view, or CMS)
const string html = """
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Quarterly Report</title>
  <style>
     body { font-family:'Segoe UI', sans-serif; margin:1.2rem; }
     header { margin-bottom:2rem; }
     h1 { color:#3056d3; }
     table { width:100%; border-collapse:collapse; margin-top:1rem; }
     th,td { border:1px solid #ddd; padding:0.5rem; text-align:right; }
     tr:nth-child(even){ background-color:#f8f9fa; }
  </style>
</head>
<body>
  <header><h1>Q2 Revenue Summary</h1></header>
  <table>
    <thead><tr><th>Product</th><th>Revenue ($)</th></tr></thead>
    <tbody>
      <tr><td>IronPDF for .NET</td><td>1,200,000</td></tr>
      <tr><td>IronOCR for .NET</td><td>890,000</td></tr>
      <tr><td>IronXL for .NET</td><td>610,000</td></tr>
    </tbody>
  </table>
</body>
</html>
""";

// 1. Create a renderer once and reuse it across conversions
var renderer = new ChromePdfRenderer
{
    RenderingOptions =
    {
        PaperSize    = PdfPaperSize.A4,                  // ISO-standard paper size
        PaperOrientation = PdfPaperOrientation.Portrait,
        CssMediaType = PdfCssMediaType.Screen,           // Respect on-screen CSS
        RenderDelay  = 100,                              // Wait 100 ms for JS/animations
        FallbackEncoding = "utf-8"                       // Handle non-ASCII correctly
    }
};

// 2. Render the HTML fragment
using PdfDocument pdf = renderer.RenderHtmlAsPdf(html);

// 3. Persist to disk or return via ASP.NET Core FileStreamResult
pdf.SaveAs("q2-report.pdf");
// Program.cs — compatible with .NET 8 and newer
using IronPdf;

// Sample HTML fragment (could also be read from a file, Razor view, or CMS)
const string html = """
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Quarterly Report</title>
  <style>
     body { font-family:'Segoe UI', sans-serif; margin:1.2rem; }
     header { margin-bottom:2rem; }
     h1 { color:#3056d3; }
     table { width:100%; border-collapse:collapse; margin-top:1rem; }
     th,td { border:1px solid #ddd; padding:0.5rem; text-align:right; }
     tr:nth-child(even){ background-color:#f8f9fa; }
  </style>
</head>
<body>
  <header><h1>Q2 Revenue Summary</h1></header>
  <table>
    <thead><tr><th>Product</th><th>Revenue ($)</th></tr></thead>
    <tbody>
      <tr><td>IronPDF for .NET</td><td>1,200,000</td></tr>
      <tr><td>IronOCR for .NET</td><td>890,000</td></tr>
      <tr><td>IronXL for .NET</td><td>610,000</td></tr>
    </tbody>
  </table>
</body>
</html>
""";

// 1. Create a renderer once and reuse it across conversions
var renderer = new ChromePdfRenderer
{
    RenderingOptions =
    {
        PaperSize    = PdfPaperSize.A4,                  // ISO-standard paper size
        PaperOrientation = PdfPaperOrientation.Portrait,
        CssMediaType = PdfCssMediaType.Screen,           // Respect on-screen CSS
        RenderDelay  = 100,                              // Wait 100 ms for JS/animations
        FallbackEncoding = "utf-8"                       // Handle non-ASCII correctly
    }
};

// 2. Render the HTML fragment
using PdfDocument pdf = renderer.RenderHtmlAsPdf(html);

// 3. Persist to disk or return via ASP.NET Core FileStreamResult
pdf.SaveAs("q2-report.pdf");
' Program.cs — compatible with .NET 8 and newer
Imports IronPdf

' Sample HTML fragment (could also be read from a file, Razor view, or CMS)
Private Const html As String = "<!DOCTYPE html>
<html lang=""en"">
<head>
  <meta charset=""utf-8"">
  <title>Quarterly Report</title>
  <style>
     body { font-family:'Segoe UI', sans-serif; margin:1.2rem; }
     header { margin-bottom:2rem; }
     h1 { color:#3056d3; }
     table { width:100%; border-collapse:collapse; margin-top:1rem; }
     th,td { border:1px solid #ddd; padding:0.5rem; text-align:right; }
     tr:nth-child(even){ background-color:#f8f9fa; }
  </style>
</head>
<body>
  <header><h1>Q2 Revenue Summary</h1></header>
  <table>
    <thead><tr><th>Product</th><th>Revenue ($)</th></tr></thead>
    <tbody>
      <tr><td>IronPDF for .NET</td><td>1,200,000</td></tr>
      <tr><td>IronOCR for .NET</td><td>890,000</td></tr>
      <tr><td>IronXL for .NET</td><td>610,000</td></tr>
    </tbody>
  </table>
</body>
</html>"

' 1. Create a renderer once and reuse it across conversions
Private renderer = New ChromePdfRenderer With {
	.RenderingOptions = {
		PaperSize = PdfPaperSize.A4,
		PaperOrientation = PdfPaperOrientation.Portrait,
		CssMediaType = PdfCssMediaType.Screen,
		RenderDelay = 100,
		FallbackEncoding = "utf-8"
	}
}

' 2. Render the HTML fragment
Private PdfDocument As using

' 3. Persist to disk or return via ASP.NET Core FileStreamResult
pdf.SaveAs("q2-report.pdf")
$vbLabelText   $csharpLabel

Qué demuestra el código

  • Chromium embebido — IronPDF agrupa el motor Chromium, garantizando paridad de HTML5, CSS3 y JavaScript con los navegadores modernos.
  • Dependencia única — Una instalación ligera de NuGet cubre Windows, Linux, Docker y Azure/AWS sin bibliotecas del sistema extra.
  • Opciones de renderizado — PaperSize, CssMediaType y RenderDelay reflejan los ajustes de impresión del navegador para que los PDFs coincidan con los diseños en pantalla.
  • Objetivo a prueba de futuro — La superficie de la API es la misma en .NET 8, .NET 9 STS y el próximo .NET 10, por lo que el mantenimiento a largo plazo es mínimo.
  • Ganchos para post-procesamiento — PdfDocument expone ayudantes para fusionar, protección con contraseña y firmas digitales, cada uno cubierto más adelante en esta guía.

Lectura adicional: consulta el tutorial paso a paso HTML a PDF y la documentación completa de la ChromePdfRenderer API.

¿Cómo se puede exportar una vista MVC de ASP .NET Core a PDF?

IronPDF renderiza una vista Razor completamente procesada ( .cshtml ) de la misma manera que lo haría un navegador y transmite el resultado como un PdfDocument. El flujo de trabajo a continuación mantiene limpia la lógica del controlador, no requiere complementos de navegador y funciona en .NET 8 LTS, .NET 9 preview, y el lanzamiento programado de .NET 10 en noviembre de 2025.

Ejemplo de controlador de extremo a extremo

// TicketsController.cs — .NET 8 LTS / MVC
using IronPdf;
using Microsoft.AspNetCore.Mvc;
using YourApp.Models;           // TicketViewModel

public class TicketsController : Controller
{
    private readonly ChromePdfRenderer _renderer;

    public TicketsController()
    {
        _renderer = new ChromePdfRenderer
        {
            RenderingOptions =
            {
                PaperSize        = PdfPaperSize.A5,            // Compact ticket size
                PaperOrientation = PdfPdfOrientation.Portrait,
                FitToPaperWidth  = true,
                CssMediaType     = PdfCssMediaType.Print,
                Margins = new PdfMargins(5, 10, 5, 10)         // mm
            }
        };
    }

    // GET /Tickets/Print/42
    public async Task<IActionResult> Print(int id)
    {
        TicketViewModel vm = await _service.GetTicketAsync(id);

        // 1. Render the Razor view to an HTML string
        string html  = await RazorTemplateEngine.RenderViewAsync(
                           HttpContext, "~/Views/Tickets/Print.cshtml", vm);

        // 2. Convert HTML → PDF
        using PdfDocument pdf = _renderer.RenderHtmlAsPdf(html);

        // 3. Stream back as a file
        return File(pdf.BinaryData, "application/pdf",
                    $"ticket-{id}.pdf");
    }
}
// TicketsController.cs — .NET 8 LTS / MVC
using IronPdf;
using Microsoft.AspNetCore.Mvc;
using YourApp.Models;           // TicketViewModel

public class TicketsController : Controller
{
    private readonly ChromePdfRenderer _renderer;

    public TicketsController()
    {
        _renderer = new ChromePdfRenderer
        {
            RenderingOptions =
            {
                PaperSize        = PdfPaperSize.A5,            // Compact ticket size
                PaperOrientation = PdfPdfOrientation.Portrait,
                FitToPaperWidth  = true,
                CssMediaType     = PdfCssMediaType.Print,
                Margins = new PdfMargins(5, 10, 5, 10)         // mm
            }
        };
    }

    // GET /Tickets/Print/42
    public async Task<IActionResult> Print(int id)
    {
        TicketViewModel vm = await _service.GetTicketAsync(id);

        // 1. Render the Razor view to an HTML string
        string html  = await RazorTemplateEngine.RenderViewAsync(
                           HttpContext, "~/Views/Tickets/Print.cshtml", vm);

        // 2. Convert HTML → PDF
        using PdfDocument pdf = _renderer.RenderHtmlAsPdf(html);

        // 3. Stream back as a file
        return File(pdf.BinaryData, "application/pdf",
                    $"ticket-{id}.pdf");
    }
}
Imports IronPdf
Imports Microsoft.AspNetCore.Mvc
Imports YourApp.Models ' TicketViewModel

Public Class TicketsController
    Inherits Controller

    Private ReadOnly _renderer As ChromePdfRenderer

    Public Sub New()
        _renderer = New ChromePdfRenderer With {
            .RenderingOptions = New PdfRenderingOptions With {
                .PaperSize = PdfPaperSize.A5, ' Compact ticket size
                .PaperOrientation = PdfPdfOrientation.Portrait,
                .FitToPaperWidth = True,
                .CssMediaType = PdfCssMediaType.Print,
                .Margins = New PdfMargins(5, 10, 5, 10) ' mm
            }
        }
    End Sub

    ' GET /Tickets/Print/42
    Public Async Function Print(id As Integer) As Task(Of IActionResult)
        Dim vm As TicketViewModel = Await _service.GetTicketAsync(id)

        ' 1. Render the Razor view to an HTML string
        Dim html As String = Await RazorTemplateEngine.RenderViewAsync(
            HttpContext, "~/Views/Tickets/Print.cshtml", vm)

        ' 2. Convert HTML → PDF
        Using pdf As PdfDocument = _renderer.RenderHtmlAsPdf(html)
            ' 3. Stream back as a file
            Return File(pdf.BinaryData, "application/pdf", $"ticket-{id}.pdf")
        End Using
    End Function
End Class
$vbLabelText   $csharpLabel

Qué ilustra este código

  • Sin archivos temporales — la vista Razor se renderiza en memoria, luego se pasa directamente a RenderHtmlAsPdf, evitando la E/S de disco y condiciones de carrera en carpetas temporales.
  • Salida de tamaño de boleto — PaperSize = A5 y márgenes estrechos mantienen los boletos para imprimir en casa compactos.
  • Estilos de impresión consistentes — CssMediaType = Print aplica las mismas reglas CSS de @media print que los navegadores usan.
  • Transmisión binaria — pdf.BinaryData transmite el documento sin tocar el sistema de archivos; - Renderizador reutilizable -- ChromePdfRenderer se instancia una vez por controlador y se reutiliza, minimizando el costo inicial.
  • Renderizador reutilizable — ChromePdfRenderer se instancia una vez por controlador, luego se reutiliza, minimizando la sobrecarga de creación de procesos.

TamañoDePapel, OrientaciónDePapel, AjusteAlAnchoDePapel

Margenes, Cabecera, Pie de página, Marca de agua

Próximo paso: agregar cifrado, firmas digitales o fusionar múltiples boletos en un solo archivo. Vea el ejemplo de fusión y el tutorial de firma digital.

¿Cómo puedo ajustar el tamaño del papel, los márgenes, los encabezados, las marcas de agua y la seguridad antes de la renderización?

IronPDF expone un único objeto ChromePdfRenderOptions que controla todos los aspectos del resultado: dimensiones de papel, orientación, encabezados y pies de página, tiempo de JavaScript, marcas de agua, encriptación y firmas digitales, todo sin complementos de navegador adicionales.

Muestra de código - aplicar varias opciones a la vez

// AdvancedOptions.cs — .NET 8 compatible
using IronPdf;

var renderer = new ChromePdfRenderer();

// Configure everything in one place
renderer.RenderingOptions = new ChromePdfRenderOptions
{
    // 1. Page layout
    PaperSize        = PdfPaperSize.A4,                     // ISO size
    PaperOrientation = PdfPdfOrientation.Portrait,
    Margins          = new PdfMargins { Top = 20, Bottom = 25, Left = 15, Right = 15 }, // mm

    // 2. Timing & media
    CssMediaType     = PdfCssMediaType.Print,               // Respect @media print
    EnableJavaScript = true,
    RenderDelay      = 200,                                 // Wait 200 ms for animations

    // 3. Headers & footers (HTML gives full design freedom)
    HtmlHeader       = "<header style='font:14px Segoe UI'>Invoice — {{date}}</header>",
    HtmlFooter       = "<footer style='text-align:right;font-size:10px'>Page {{page}} / {{total-pages}}</footer>",

    // 4. Watermark
    Watermark        = new HtmlStamp
    {
        HtmlTemplate = "<div style='font-size:50px;color:#cccccc;opacity:0.3;'>CONFIDENTIAL</div>",
        VerticalAlignment = VerticalAlignment.Center,
        HorizontalAlignment = HorizontalAlignment.Center
    },

    // 5. Security
    SecurityOptions = new PdfSecurityOptions
    {
        OwnerPassword = "StrongOwnerPwd!",
        UserPassword  = "ReadOnly",
        AllowUserPrinting = false,
        AllowUserCopyPasteContent = false
    }
};

// Render any HTML
using PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>Advanced Options Demo</h1>");

// Digitally sign with a PFX certificate (optional)
pdf.SignAndStamp("./certs/company.pfx", "Iron Software", "Bangkok", "Approval");

// Save
pdf.SaveAs("advanced-options-demo.pdf");
// AdvancedOptions.cs — .NET 8 compatible
using IronPdf;

var renderer = new ChromePdfRenderer();

// Configure everything in one place
renderer.RenderingOptions = new ChromePdfRenderOptions
{
    // 1. Page layout
    PaperSize        = PdfPaperSize.A4,                     // ISO size
    PaperOrientation = PdfPdfOrientation.Portrait,
    Margins          = new PdfMargins { Top = 20, Bottom = 25, Left = 15, Right = 15 }, // mm

    // 2. Timing & media
    CssMediaType     = PdfCssMediaType.Print,               // Respect @media print
    EnableJavaScript = true,
    RenderDelay      = 200,                                 // Wait 200 ms for animations

    // 3. Headers & footers (HTML gives full design freedom)
    HtmlHeader       = "<header style='font:14px Segoe UI'>Invoice — {{date}}</header>",
    HtmlFooter       = "<footer style='text-align:right;font-size:10px'>Page {{page}} / {{total-pages}}</footer>",

    // 4. Watermark
    Watermark        = new HtmlStamp
    {
        HtmlTemplate = "<div style='font-size:50px;color:#cccccc;opacity:0.3;'>CONFIDENTIAL</div>",
        VerticalAlignment = VerticalAlignment.Center,
        HorizontalAlignment = HorizontalAlignment.Center
    },

    // 5. Security
    SecurityOptions = new PdfSecurityOptions
    {
        OwnerPassword = "StrongOwnerPwd!",
        UserPassword  = "ReadOnly",
        AllowUserPrinting = false,
        AllowUserCopyPasteContent = false
    }
};

// Render any HTML
using PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>Advanced Options Demo</h1>");

// Digitally sign with a PFX certificate (optional)
pdf.SignAndStamp("./certs/company.pfx", "Iron Software", "Bangkok", "Approval");

// Save
pdf.SaveAs("advanced-options-demo.pdf");
Imports IronPdf

Dim renderer As New ChromePdfRenderer()

' Configure everything in one place
renderer.RenderingOptions = New ChromePdfRenderOptions With {
    ' 1. Page layout
    .PaperSize = PdfPaperSize.A4, ' ISO size
    .PaperOrientation = PdfPdfOrientation.Portrait,
    .Margins = New PdfMargins With {.Top = 20, .Bottom = 25, .Left = 15, .Right = 15}, ' mm

    ' 2. Timing & media
    .CssMediaType = PdfCssMediaType.Print, ' Respect @media print
    .EnableJavaScript = True,
    .RenderDelay = 200, ' Wait 200 ms for animations

    ' 3. Headers & footers (HTML gives full design freedom)
    .HtmlHeader = "<header style='font:14px Segoe UI'>Invoice — {{date}}</header>",
    .HtmlFooter = "<footer style='text-align:right;font-size:10px'>Page {{page}} / {{total-pages}}</footer>",

    ' 4. Watermark
    .Watermark = New HtmlStamp With {
        .HtmlTemplate = "<div style='font-size:50px;color:#cccccc;opacity:0.3;'>CONFIDENTIAL</div>",
        .VerticalAlignment = VerticalAlignment.Center,
        .HorizontalAlignment = HorizontalAlignment.Center
    },

    ' 5. Security
    .SecurityOptions = New PdfSecurityOptions With {
        .OwnerPassword = "StrongOwnerPwd!",
        .UserPassword = "ReadOnly",
        .AllowUserPrinting = False,
        .AllowUserCopyPasteContent = False
    }
}

' Render any HTML
Using pdf As PdfDocument = renderer.RenderHtmlAsPdf("<h1>Advanced Options Demo</h1>")
    ' Digitally sign with a PFX certificate (optional)
    pdf.SignAndStamp("./certs/company.pfx", "Iron Software", "Bangkok", "Approval")

    ' Save
    pdf.SaveAs("advanced-options-demo.pdf")
End Using
$vbLabelText   $csharpLabel

Por qué son importantes estas opciones

  • PaperSize, Margins y CssMediaType reflejan el cuadro de diálogo de impresión de un navegador para que los diseños en pantalla y el PDF permanezcan idénticos en Windows, Linux y Docker.
  • Encabezados y pies de página HTML soportan tokens Razor, CSS y JavaScript, útiles para números de página dinámicos o branding.
  • HtmlStamp permite que una sola línea cree marcas de agua con marca con control completo de HTML + CSS.
  • Firmas digitales añaden un sello criptográfico directamente en el código, manteniendo la autenticidad legal y la evidencia de manipulación.
  • Ayudantes de extracción como ExtractAllText y ExtractAllImages invierten el proceso cuando se requiere análisis.
  • Los ayudantes de extracción como ExtractAllText y ExtractAllImages revierten el proceso cuando se requiere análisis.

Referencia rápida - Ajustes populares

PaperSize , PaperOrientation , Margins , CssMediaType , RenderDelay

HtmlHeader, HtmlFooter, marcadores de posición dinámicos Razor, tokens de número de página

Watermark, HtmlStamp, opacidad, alineación

SecurityOptions, SignAndStamp, contraseñas de propietario/usuario, sellado de certificados

Próximas tareas: fusionar múltiples PDFs, extraer texto e imágenes, y desplegar en Docker o sin servidor. ## ¿Cómo puedo desplegar código de generación de PDF a Docker en Linux y Windows?

¿Cómo puedo implementar código de generación de PDF en Docker en Linux y Windows?

IronPdf se suministra como un único paquete NuGet autónomo, por lo que contenerizar una aplicación ASP.NET Core (o de consola) es sencillo tanto en Windows como en Linux. La clave es copiar los binarios publicados en una imagen de tiempo de ejecución delgada y, en Linux, agregar las dos bibliotecas nativas que IronPDF requiere (libnss3 y libatk1.0-0).

Archivo Docker multietapa (Ubuntu 22.04)

Por favor nota¿Por qué multi-etapa? La imagen del SDK (etapa 1) compila el proyecto; [{i:(¿Contenedores de Windows? Reemplaza la etapa 2 con mcr.microsoft.com/dotnet/aspnet:8.0-windowsservercore-ltsc2022—sin paquetes adicionales, los DLL de Chromium están incluidos.

####### ---------- stage 1 ----------
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY ["MyPdfApp.csproj", "."]
RUN dotnet restore

COPY . .
RUN dotnet publish -c Release -o /app/publish

####### ---------- stage 2 ----------
FROM mcr.microsoft.com/dotnet/aspnet:8.0-jammy
######## Install two native libs required by Chromium
RUN apt-get update && \
    apt-get install -y --no-install-recommends libnss3 libatk1.0-0 && \
    rm -rf /var/lib/apt/lists/*

WORKDIR /app
COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "MyPdfApp.dll"]

Por favor nota¿Contenedores de Windows? Reemplace la segunda etapa con mcr.microsoft.com/dotnet/aspnet:8.0-windowsservercore-ltsc2022; no se necesitan paquetes adicionales porque los DLL de Chromium están incluidos.

Script de validación de principio a fin

docker build -t pdf-demo .
docker run --rm -p 8080:80 pdf-demo
######### ↳ Navigate to http://localhost:8080/api/pdf?url=https://example.com
docker build -t pdf-demo .
docker run --rm -p 8080:80 pdf-demo
######### ↳ Navigate to http://localhost:8080/api/pdf?url=https://example.com
SHELL
  • La acción de la API llama internamente a ChromePdfRenderer.RenderUrlAsPdf igual que en la Sección 2.
  • La huella de memoria se mantiene por debajo de 200 MB incluso durante grandes renderizados.
    ConsejosConsejo de resolución de problemas: Si los registros del contenedor indican un error "libnss3.so no encontrado", confirma que libnss3 y libatk1.0-0 estén presentes.

ConsejosConsejo de solución de problemas: Si los registros del contenedor muestran un error "libnss3.so no encontrado", confirme que ambos libnss3 y libatk1.0-0 estén presentes. Las imágenes Alpine no son compatibles porque la biblioteca C musl carece de los símbolos requeridos.

Recursos internos

¿Cómo puedo abrir, combinar, poner marcas de agua y extraer contenido de PDF existentes en .NET Core?

IronPDF trata a cada PDF, ya sea generado por IronPDF, Adobe® Acrobat o herramientas de terceros, como un objeto PdfDocument de primera clase que puede abrirse, editarse, asegurarse y guardarse nuevamente sin pérdida de calidad. La misma superficie de API funciona actualmente en .NET 8 LTS y compila sin cambios en .NET 9 preview y en la próxima versión .NET 10.

Muestra unificada - abrir → fusionar → marca de agua → extraer

// ManipulateExistingPdf.cs — .NET 8 LTS compatible
using IronPdf;
using System.Linq;

// Step 1: Open two existing files (password-protected PDFs are supported)
PdfDocument invoice  = PdfDocument.FromFile("invoice.pdf", "ReadOnly");   // open with user pwd
PdfDocument tAndCs   = PdfDocument.FromFile("terms.pdf");                 // no pwd required

// Step 2: Merge them (invoice pages first, then T&Cs)
PdfDocument mergedPdf = PdfDocument.Merge(invoice, tAndCs);               // 1-liner merge

// Step 3: Apply a diagonal CONFIDENTIAL watermark to every page
mergedPdf.ApplyStamp(
    "<div style='font-size:60px;color:#d9534f;opacity:0.2;transform:rotate(-45deg);"
  + "width:100%;text-align:center;'>CONFIDENTIAL</div>",
    verticalAlignment   : VerticalAlignment.Center,
    horizontalAlignment : HorizontalAlignment.Center);

// Step 4: Extract all text and the first image for audit purposes
string fullText = mergedPdf.ExtractAllText();
var    image    = mergedPdf.ExtractAllImages().FirstOrDefault();

// Step 5: Save or stream
mergedPdf.SaveAs("invoice-with-terms.pdf");
// ManipulateExistingPdf.cs — .NET 8 LTS compatible
using IronPdf;
using System.Linq;

// Step 1: Open two existing files (password-protected PDFs are supported)
PdfDocument invoice  = PdfDocument.FromFile("invoice.pdf", "ReadOnly");   // open with user pwd
PdfDocument tAndCs   = PdfDocument.FromFile("terms.pdf");                 // no pwd required

// Step 2: Merge them (invoice pages first, then T&Cs)
PdfDocument mergedPdf = PdfDocument.Merge(invoice, tAndCs);               // 1-liner merge

// Step 3: Apply a diagonal CONFIDENTIAL watermark to every page
mergedPdf.ApplyStamp(
    "<div style='font-size:60px;color:#d9534f;opacity:0.2;transform:rotate(-45deg);"
  + "width:100%;text-align:center;'>CONFIDENTIAL</div>",
    verticalAlignment   : VerticalAlignment.Center,
    horizontalAlignment : HorizontalAlignment.Center);

// Step 4: Extract all text and the first image for audit purposes
string fullText = mergedPdf.ExtractAllText();
var    image    = mergedPdf.ExtractAllImages().FirstOrDefault();

// Step 5: Save or stream
mergedPdf.SaveAs("invoice-with-terms.pdf");
' ManipulateExistingPdf.cs — .NET 8 LTS compatible
Imports IronPdf
Imports System.Linq

' Step 1: Open two existing files (password-protected PDFs are supported)
Private invoice As PdfDocument = PdfDocument.FromFile("invoice.pdf", "ReadOnly") ' open with user pwd
Private tAndCs As PdfDocument = PdfDocument.FromFile("terms.pdf") ' no pwd required

' Step 2: Merge them (invoice pages first, then T&Cs)
Private mergedPdf As PdfDocument = PdfDocument.Merge(invoice, tAndCs) ' 1-liner merge

' Step 3: Apply a diagonal CONFIDENTIAL watermark to every page
mergedPdf.ApplyStamp("<div style='font-size:60px;color:#d9534f;opacity:0.2;transform:rotate(-45deg);" & "width:100%;text-align:center;'>CONFIDENTIAL</div>", verticalAlignment := VerticalAlignment.Center, horizontalAlignment := HorizontalAlignment.Center)

' Step 4: Extract all text and the first image for audit purposes
Dim fullText As String = mergedPdf.ExtractAllText()
Dim image = mergedPdf.ExtractAllImages().FirstOrDefault()

' Step 5: Save or stream
mergedPdf.SaveAs("invoice-with-terms.pdf")
$vbLabelText   $csharpLabel

Por qué es importante

  • Abrir y fusionar – PdfDocument.FromFile carga cualquier PDF compatible con estándares, incluidos los archivos cifrados, mientras que PdfDocument.Merge concatena un número arbitrario de documentos en una sola llamada.
  • Marca de agua – ApplyStamp (alias HtmlStamp) incrusta superposiciones HTML/CSS completamente estilizadas, logotipo, código QR o texto diagonal en páginas seleccionadas sin rasterización.
  • Extracción de contenido – ExtractAllText y ExtractAllImages extraen texto sin procesar UTF-8 o flujos de imágenes binarias para su archivo posterior o pipelines de IA.
  • Firmas digitales listas – la misma instancia de PdfDocument puede sellarse con SignAndStamp, produciendo hashes compatibles con RFC 3161 alineados con requisitos de firma digital ISO 32000-2.
  • A prueba de futuro – La API evita ensamblajes de interoperabilidad y llamadas Win32 GDI, por lo que el código se ejecuta sin cambios en Windows, Linux, Docker y próximas SKUs sin servidor en .NET 10. ¿Necesitas dividir, rotar o eliminar páginas? Consulta el tutorial completo de edición de nivel de página para operaciones granulares.

¿Necesita dividir, rotar o eliminar páginas? Vea el tutorial de edición a nivel de página para operaciones detalladas.

¿Cómo se pueden cifrar y firmar digitalmente los PDF en .NET Core?

Ambas APIs residen en el mismo objeto PdfDocument, por lo que el flujo de trabajo es idéntico en .NET 8 LTS hoy y se compila sin cambios en la vista previa de .NET 9 y el próximo lanzamiento de .NET 10. Ambas APIs viven en el mismo objeto PdfDocument, por lo que el flujo de trabajo es idéntico en .NET 8 LTS hoy y se compila sin cambios en la vista previa de .NET 9 y la próxima versión .NET 10.

Ejemplo - aplicar AES de 256 bits, bloquear los derechos de impresión y añadir una firma visible

// SecureAndSign.cs — .NET 8 LTS compatible
using IronPdf;

// Step 1: Load an existing PDF (or produce one with RenderHtmlAsPdf)
PdfDocument pdf = PdfDocument.FromFile("financial-report.pdf");

// Step 2: Configure AES-256 encryption & permissions
pdf.SecuritySettings = new PdfSecuritySettings
{
    EncryptionAlgorithm   = PdfEncryptionAlgorithm.AES256Bit,
    OwnerPassword         = "IronAdmin!2025",
    UserPassword          = "ReadOnly",
    AllowUserPrinting     = PdfPrintSecurity.Disabled,
    AllowUserCopyPasteContent = false,
    AllowUserAnnotations  = false
};

// Step 3: Digitally sign with a PFX certificate
pdf.SignAndStamp(
    certificatePath : "./certs/ironsoftware.pfx",
    authority       : "Iron Software Ltd.",
    location        : "Chicago, IL",
    reason          : "Final approval"
);

// Step 4: Persist or stream
pdf.SaveAs("financial-report-secured-signed.pdf");
// SecureAndSign.cs — .NET 8 LTS compatible
using IronPdf;

// Step 1: Load an existing PDF (or produce one with RenderHtmlAsPdf)
PdfDocument pdf = PdfDocument.FromFile("financial-report.pdf");

// Step 2: Configure AES-256 encryption & permissions
pdf.SecuritySettings = new PdfSecuritySettings
{
    EncryptionAlgorithm   = PdfEncryptionAlgorithm.AES256Bit,
    OwnerPassword         = "IronAdmin!2025",
    UserPassword          = "ReadOnly",
    AllowUserPrinting     = PdfPrintSecurity.Disabled,
    AllowUserCopyPasteContent = false,
    AllowUserAnnotations  = false
};

// Step 3: Digitally sign with a PFX certificate
pdf.SignAndStamp(
    certificatePath : "./certs/ironsoftware.pfx",
    authority       : "Iron Software Ltd.",
    location        : "Chicago, IL",
    reason          : "Final approval"
);

// Step 4: Persist or stream
pdf.SaveAs("financial-report-secured-signed.pdf");
' SecureAndSign.cs — .NET 8 LTS compatible
Imports IronPdf

' Step 1: Load an existing PDF (or produce one with RenderHtmlAsPdf)
Private pdf As PdfDocument = PdfDocument.FromFile("financial-report.pdf")

' Step 2: Configure AES-256 encryption & permissions
pdf.SecuritySettings = New PdfSecuritySettings With {
	.EncryptionAlgorithm = PdfEncryptionAlgorithm.AES256Bit,
	.OwnerPassword = "IronAdmin!2025",
	.UserPassword = "ReadOnly",
	.AllowUserPrinting = PdfPrintSecurity.Disabled,
	.AllowUserCopyPasteContent = False,
	.AllowUserAnnotations = False
}

' Step 3: Digitally sign with a PFX certificate
pdf.SignAndStamp(certificatePath := "./certs/ironsoftware.pfx", authority := "Iron Software Ltd.", location := "Chicago, IL", reason := "Final approval")

' Step 4: Persist or stream
pdf.SaveAs("financial-report-secured-signed.pdf")
$vbLabelText   $csharpLabel

Entre bastidores

  • Cifrado AES-256 — IronPDF envuelve la carga útil con claves AES aprobadas por NIST, bloqueando la apertura, impresión o copia/pegado no autorizado.
  • Granularidad de permisos — propiedades como AllowUserPrinting y AllowUserFormData alternan derechos por acción; - Encriptación AES-256 - IronPDF envuelve la carga con claves AES aprobadas por el NIST, bloqueando accesos no autorizados.
  • Firmas digitales — SignAndStamp incrusta una marca de tiempo RFC 3161 y una cadena de certificados, creando hashes que evidencian manipulación reconocidos por Adobe® Acrobat y otros visores ISO 32000-2.
  • API de una sola parada — tanto el cifrado como la firma modifican la misma instancia de PdfDocument, evitando múltiples pasadas de archivo y preservando fuentes internas, capas y metadatos.

ConsejosConsejo de solución de problemas: si Adobe Reader informa "firma inválida", asegúrese de que el PFX contenga un certificado raíz de confianza y las cadenas location estén limpias de ASCII.

Configuraciones básicas de seguridad

PdfSecuritySettings → OwnerPassword, UserPassword, EncryptionAlgorithm, AllowUserPrinting

PdfDocument.SignAndStamp - Ruta PFX, autoridad, ubicación, motivo, marca de tiempo

Recursos internos para profundizar

¿Cómo se puede optimizar y escalar el rendimiento de HTML a PDF en .NET Core?

El motor Chromium de IronPDF ya renderiza la mayoría de las páginas en < 1 s en hardware moderno, pero el rendimiento se puede multiplicar mediante procesos por lotes, habilitando el multihilo, y reduciendo la sobrecarga de Headless Chrome. ### 1. Agregar renderizados en un fondo de subprocesos

1. Renderizado por lotes en un grupo de hilos en segundo plano

// BatchRender.cs — Thread-safe on .NET 8+
using IronPdf;
using System.Threading.Tasks;

var htmlSources = Directory.GetFiles("./html", "*.html");
var renderer    = new ChromePdfRenderer();                 // reuse 1 instance

Parallel.ForEach(htmlSources, new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount }, file =>
{
    string html = File.ReadAllText(file);
    using PdfDocument pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs(Path.ChangeExtension(file, ".pdf"));
});
// BatchRender.cs — Thread-safe on .NET 8+
using IronPdf;
using System.Threading.Tasks;

var htmlSources = Directory.GetFiles("./html", "*.html");
var renderer    = new ChromePdfRenderer();                 // reuse 1 instance

Parallel.ForEach(htmlSources, new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount }, file =>
{
    string html = File.ReadAllText(file);
    using PdfDocument pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs(Path.ChangeExtension(file, ".pdf"));
});
' BatchRender.cs — Thread-safe on .NET 8+
Imports IronPdf
Imports System.Threading.Tasks

Private htmlSources = Directory.GetFiles("./html", "*.html")
Private renderer = New ChromePdfRenderer() ' reuse 1 instance

Parallel.ForEach(htmlSources, New ParallelOptions With {.MaxDegreeOfParallelism = Environment.ProcessorCount}, Sub(file)
	Dim html As String = File.ReadAllText(file)
	Using pdf As PdfDocument = renderer.RenderHtmlAsPdf(html)
		pdf.SaveAs(Path.ChangeExtension(file, ".pdf"))
	End Using
End Sub)
$vbLabelText   $csharpLabel

2. Reduzca el costo de inicio de Headless Chrome

La agrupación ayuda, y contenedores Linux deben incluir dos bibliotecas nativas: La falta de bibliotecas se manifiesta como el error "libnss3.so no encontrado" en registros de Docker.

RUN apt-get update && \
    apt-get install -y --no-install-recommends libnss3 libatk1.0-0

La falta de cualquiera de las bibliotecas se manifiesta como un error libnss3.so not found en los registros de Docker.

Las banderas de Chrome recomendadas (aplicadas automáticamente por IronPDF) incluyen --disable-gpu y --no-sandbox para reducir la memoria y problemas de usuarios root en contenedores.

3. Esperar JavaScript tardío con RenderDelay o WaitFor

Las páginas que animan contadores o recuperan datos después de DOMContentLoaded pueden necesitar un breve retraso:

renderer.RenderingOptions.RenderDelay = 200;        // ms
// OR: renderer.RenderingOptions.JavaScript = "WaitFor('window.doneLoading')";
renderer.RenderingOptions.RenderDelay = 200;        // ms
// OR: renderer.RenderingOptions.JavaScript = "WaitFor('window.doneLoading')";
renderer.RenderingOptions.RenderDelay = 200 ' ms
' OR: renderer.RenderingOptions.JavaScript = "WaitFor('window.doneLoading')";
$vbLabelText   $csharpLabel

Consulte el tutorial WaitFor dedicado para promesas personalizadas y sondeo del DOM.

4. Habilitar el registro de depuración para una solicitud

renderer.LoggingOptions.DebugMode        = true;
renderer.LoggingOptions.LogsToConsole    = true;
renderer.LoggingOptions.LogFilePath      = "./logs/ironpdf-debug.log";
renderer.LoggingOptions.DebugMode        = true;
renderer.LoggingOptions.LogsToConsole    = true;
renderer.LoggingOptions.LogFilePath      = "./logs/ironpdf-debug.log";
renderer.LoggingOptions.DebugMode = True
renderer.LoggingOptions.LogsToConsole = True
renderer.LoggingOptions.LogFilePath = "./logs/ironpdf-debug.log"
$vbLabelText   $csharpLabel

5. Reutilizar PDFs de plantilla en lugar de renderizar de nuevo

5. Reutilizar plantillas PDF en lugar de volver a renderizar

Para corridas de facturas, crea un PDF de plantilla con marcadores de posición como [[name]] y realiza un reemplazo de texto en lugar de reconstruir HTML complejo. ### Lista de verificación rápida de ajuste

Lista de comprobación de ajuste rápido

Parallel.ForEach, async/await, reutilización de un único ChromePdfRenderer

Use aspnet:8.0-jammy; instale libnss3 + libatk1.0-0; flags --no-sandbox, --disable-gpu

RenderDelay, WaitFor(), línea de tiempo de registro DevTools para hidrataciones lentas de SPA

Lecturas adicionales

¿Dónde puedo descargar una versión de prueba gratuita, elegir una licencia y encontrar asistencia experta? {#anchor-10-resources}

Un clave de prueba de 30 días se emite al instante desde el formulario Iniciar prueba gratuita y desbloquea todas las funciones, incluyendo HTML-a-PDF, firmas digitales y cifrado, sin marcas de agua.

Después de evaluar la biblioteca, elija una licencia desarrollador, despliegue o empresa perpetua; cada plan incluye actualizaciones menores gratuitas, derechos de uso para desarrollo/staging/producción y una garantía de devolución de dinero de 30 días. Aplicar la clave es una sola línea de código (IronPdf.License.LicenseKey = "YOUR-KEY";) y puede automatizarse en pipelines CI/CD.

Documentación completa—guías de inicio rápido, referencia API y videos tutoriales—disponibles en el portal de documentos y se actualiza con cada lanzamiento de .NET.

Las preguntas de ingeniería reciben respuestas en un día hábil a través de chat en vivo, correo electrónico o teléfono del equipo de soporte con sede en Chicago.

Las preguntas frecuentes sobre ajuste de rendimiento y despliegue se agrupan en el Centro de Asistencia de Rendimiento.

Enlaces rápidos

Recurso URL Por qué importa
Obtenga una clave de prueba de 30 días https://ironpdf.com/demos/ Desbloquea todas las funciones sin marcas de agua
Licencias y precios https://ironpdf.com/licensing/ Planes perpetuos o de suscripción; Iron Suite agrupa 10 bibliotecas
Referencia API https://ironpdf.com/object-reference/api/ Documentación completa de clases, por ejemplo ChromePdfRenderer
Portal de documentos https://ironpdf.com/docs/ Guías, tutoriales, proyectos de muestra
Asistencia de rendimiento https://ironpdf.com/troubleshooting/ironpdf-performance-assistance/ Consejos de optimización y escalabilidad
Contactar soporte https://ironsoftware.com/contact-us/ Chat en directo, correo electrónico, asistencia telefónica

Siguientes pasos

  1. Clonar el repositorio de muestra que demuestra todas las funciones principales, desde el renderizado de vistas MVC hasta el cifrado AES-256.
  2. Conecte la clave de prueba en una solución existente y ejecute las pruebas unitarias para validar la compatibilidad entre plataformas.
  3. Reserve una demostración en vivo con el equipo de ingeniería para recomendaciones específicas del proyecto.

Con estos recursos en mano, cualquier equipo de .NET puede enviar PDFs perfectos a producción—localmente, en Docker o sin servidor—en un solo sprint.

Preguntas Frecuentes

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

Puedes convertir HTML a PDF en .NET Core usando la biblioteca IronPDF. Primero, instala el paquete NuGet de IronPDF, luego crea una instancia de ChromePdfRenderer. Usa el método RenderHtmlAsPdf para convertir cadenas HTML en PDFs.

¿Cómo convierto un URL de sitio web a un documento PDF?

Para convertir un URL de sitio web a un documento PDF, instala el paquete NuGet de IronPDF, crea una instancia de ChromePdfRenderer, y usa el método RenderUrlAsPdf para renderizar el URL en un PDF. El resultado se puede guardar usando el método SaveAs.

¿Cuál es la mejor manera de convertir vistas de Razor a PDFs?

La mejor manera de convertir vistas de Razor a PDFs es usando IronPDF. Primero, renderiza la vista Razor a una cadena HTML, luego pasa esta cadena al método RenderHtmlAsPdf para crear un documento PDF.

¿Cómo puedo mejorar la seguridad de mis documentos PDF?

Mejora la seguridad de PDF usando IronPDF aplicando cifrado AES-256, estableciendo contraseñas y controlando permisos de usuario. Configura estas opciones a través de la propiedad SecuritySettings para restringir acciones como impresión y edición.

¿Qué opciones están disponibles para personalizar el renderizado de PDF?

IronPDF proporciona varias opciones de renderización a través de la clase ChromePdfRenderOptions, incluidas configuraciones de tamaño de papel, orientación, márgenes y aplicación de tipos de medios CSS. También puedes agregar encabezados, pies de página, y marcas de agua para una salida de documentos personalizada.

¿Cómo implemento una aplicación de generación de PDF en un contenedor Docker?

Para implementar una aplicación de generación de PDF en un contenedor Docker, configura dependencias de Linux en tu Dockerfile y establece permisos de usuario. Utiliza IronPdf.Installation.LinuxAndDockerDependenciesAutoConfig para la gestión automática de dependencias.

¿Cómo puedo agregar marcas de agua a un PDF usando C#?

Puedes agregar marcas de agua a PDFs usando IronPDF utilizando la propiedad Watermark con objetos HtmlStamp. Para opciones avanzadas, la clase HtmlStamper permite un posicionamiento personalizado y efectos de transparencia.

¿Puedo agregar firmas digitales a documentos PDF?

Sí, puedes agregar firmas digitales a PDFs usando la clase PdfSignature de IronPDF. Usa el método Sign en un PdfDocument y proporciona un archivo de certificado para asegurar la integridad y autenticidad del documento.

¿Cómo puedo optimizar el rendimiento de generación de PDFs en .NET Core?

Optimiza el rendimiento de generación de PDFs reutilizando una instancia segura para hilos de ChromePdfRenderer, habilitando multi-threading y eliminando banderas innecesarias de inicio de Chrome sin cabeza. Estas prácticas ayudan a mejorar la eficiencia de tu aplicación.

¿Funciona el ejemplo de HTML a PDF de .NET Core en este tutorial con .NET 10?

Sí. IronPDF es totalmente compatible con .NET 10, por lo que puedes usar el ejemplo de HTML a PDF de ChromePdfRenderer de este tutorial en proyectos de .NET 10 sin cambiar el código principal. La principal diferencia es que debes orientar a .NET 10 al crear el proyecto y luego instalar el paquete más reciente de IronPDF desde NuGet para generar PDFs perfectos a partir de HTML, vistas Razor o URLs.

Jacob Mellor, Director de Tecnología @ Team Iron
Jacob Mellor
  Chatea con el equipo de ingeniería ahora
Director de Tecnología

Jacob Mellor es Director de Tecnología de Iron Software y un ingeniero visionario pionero en la tecnología C# PDF. Como desarrollador original de la base de código principal de Iron Software, ha dado forma a la arquitectura de productos de la empresa desde su creación, ...

Leer más
Revisado por
Jeff Fritz
Jeffrey T. Fritz
Gerente Principal de Programas - Equipo de la Comunidad .NET
Jeff también es Gerente Principal de Programas para los equipos de .NET y Visual Studio. Es el productor ejecutivo de la serie de conferencias virtuales .NET Conf y anfitrión de 'Fritz and Friends', una transmisión en vivo para desarrolladores que se emite dos veces a la semana donde habla sobre tecnología y escribe código junto con la audiencia. Jeff escribe talleres, presentaciones, y planifica contenido para los eventos de desarrolladores más importantes de Microsoft, incluyendo Microsoft Build, Microsoft Ignite, .NET Conf y la Cumbre de Microsoft MVP.
¿Listo para empezar?
Nuget Descargas 19,014,616 | Versión: 2026.5 just released
Still Scrolling Icon

¿Aún desplazándote?

¿Quieres una prueba rápida? PM > Install-Package IronPdf
ejecutar una muestra Mira cómo tu HTML se convierte en PDF.