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

Convert HTML to PDF in .NET Core using C# with 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 incluye un depurador Chrome sin cabeza que ayuda a diagnosticar problemas de CSS, JavaScript, y consultas de medios antes de renderizar el PDF. 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 la URL de un sitio web con `RenderUrlAsPdf`
  3. Renderizar HTML sin procesar mediante `RenderHtmlAsPdf`
  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 sin procesar – ChromePdfRenderer.RenderHtmlAsPdf()
  4. Exportar una vista de Razor – ChromePdfRenderer.RenderHtmlAsPdfAsync()
  5. Ajustar la salida – aproveche ChromePdfRenderer.RenderingOptions

Qué cubre este tutorial

  • Conversión de URL, cadena HTML y vista Razor
  • Configuración de papel, márgenes y tipo de medios
  • Despliegue multiplataforma (Windows, Linux, Docker)
  • Postprocesamiento: combinar, añadir marcas 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

¿Necesita la CLI? El mismo comando funciona con dotnet add package IronPdf dentro de la carpeta de su proyecto.

Una vez instalado, confirme que todo esté configurado correctamente convirtiendo cualquier URL pú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, sin necesidad de instalar Chrome por separado.
  • RenderUrlAsPdf captura el DOM completamente renderizado, incluido el contenido controlado por JavaScript, las consultas de medios CSS y las fuentes.
  • El PdfDocument resultante expone métodos auxiliares para fusionar, proteger con contraseña o firmar digitalmente la salida (capacidades que se tratan 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 la URL de un sitio web en PDF?

Una sola llamada a RenderUrlAsPdf es suficiente: pase cualquierURLaccesible públicamente y IronPDF devolverá 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 espacio aislado (sin dependencia del sistema de Chrome) y mantiene las imágenes de Docker reducidas.
  • RenderUrlAsPdf espera a que el DOM y el JavaScript finalicen antes de tomar una instantánea, para que las aplicaciones de una sola página se representen correctamente.
  • Al configurar CssMediaType en Print, se indica al motor que use reglas específicas de impresión, coincidiendo con la salida Imprimir → Guardar como PDF de un navegador.
  • El PdfDocument resultante se puede cifrar, firmar digitalmente, fusionar o rasterizar (capacidades que se tratan en secciones posteriores).

Consejos Depuración perfecta en píxeles: habilite renderer.LoggingOptions.DebugMode = true y siga la guía de depuración de Chrome sin interfaz gráfica para inspeccionar DevTools en vivo durante la renderización.

Recursos relacionados

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

Al pasar una cadena HTML (o el marcado renderizado de una vista Razor ) a ChromePdfRenderer.RenderHtmlAsPdf se 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 integrado -- IronPDF incorpora el motor Chromium, garantizando paridad HTML5, CSS3 y JavaScript con navegadores modernos.
  • Dependencia única -- Una instalación ligera de NuGet cubre Windows, Linux, Docker y Azure/AWS sin bibliotecas de sistema adicionales.
  • Las opciones de renderizado -- PaperSize, CssMediaType y RenderDelay reflejan la configuración de impresión del navegador para que los PDF 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 de posprocesamiento: PdfDocument expone ayudantes para fusión, protección de contraseña y firmas digitales (cada uno de los cuales se trata más adelante en esta guía).

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

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

IronPDF procesa una vista Razor completamente procesada ( .cshtml ) de la misma forma que lo haría un navegador y transmite el resultado como 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

  • No hay archivos temporales : la vista de Razor se procesa en la memoria y luego se pasa directamente a RenderHtmlAsPdf , lo que evita las condiciones de carrera de carpetas temporales y de E/S de disco.
  • La salida del tamaño de un boleto -- PaperSize = A5 y los márgenes estrechos mantienen los boletos impresos en casa compactos.
  • Estilos de impresión consistentes : CssMediaType = Print aplica las mismas reglas CSS @media print que utilizan los navegadores.
  • Transmisión binaria -- pdf.BinaryData transmite el documento sin tocar el sistema de archivos; ideal para endpoints de API y funciones Lambda.
  • Renderizador reutilizable -- ChromePdfRenderer se instancia una vez por controlador y se reutiliza, minimizando la sobrecarga de generación de procesos.
##

PaperSize, PaperOrientation, FitToPaperWidth

##

Margins, Header, Footer, Watermark

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 cada aspecto de la salida (dimensiones del papel, orientación, encabezados y pies de página, sincronización de JavaScript , marcas de agua, cifrado 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, de modo que los diseños en pantalla y el PDF siguen siendo idénticos en Windows, Linux y Docker.
  • HtmlStamp permite con una sola línea crear marcas de agua corporativas con control total 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.
  • Los métodos de extracción como ExtractAllText y ExtractAllImages invierten el proceso cuando se requiere análisis del contenido.

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. Continúe a la sección de despliegue para garantizar la paridad multiplataforma.

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

IronPDF se distribuye como un único paquete NuGet autocontenido, 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 ligera y, en Linux, agregar las dos bibliotecas nativas que IronPDF requiere (libnss3 y libatk1.0-0).

Dockerfile multietapa (Ubuntu 22.04)

Por favor nota¿Por qué multietapa? La imagen del SDK (etapa 1) compila el proyecto; la imagen de tiempo de ejecución final (etapa 2) se mantiene ligera porque las herramientas de compilación se descartan.

####### ---------- 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? Reemplaza la segunda etapa con mcr.microsoft.com/dotnet/aspnet:8.0-windowsservercore-ltsc2022; no se necesitan paquetes adicionales porque las DLL de Chromium están incluidas.

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 anterior.
  • IronPDF inicia su proceso Chromium en modo headless dentro del contenedor; no se requiere servidor X.
  • La huella de memoria se mantiene por debajo de 200 MB incluso durante renderizados grandes.

ConsejosConsejo de resolución de problemas: Si los registros del contenedor muestran un error "libnss3.so no encontrado", confirme que 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 cada PDF, ya sea generado por IronPDF, Adobe® Acrobat o herramientas de terceros, como un objeto de primera clase que se puede abrir, editar, proteger y volver a guardar 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 los estándares, incluidos los archivos cifrados, mientras que PdfDocument.Merge concatena una cantidad arbitraria de documentos en una sola llamada.
  • Marca de agua – ApplyStamp (alias HtmlStamp) incorpora superposiciones HTML/CSS con estilo completo (logotipo, código QR o texto diagonal) en páginas seleccionadas sin rasterización.
  • Extracción de contenido : ExtractAllText y ExtractAllImages extraen texto UTF-8 sin procesar o secuencias de imágenes binarias para archivado posterior o canalizaciones de IA.
  • Firmas digitales listas: la misma instancia PdfDocument se puede sellar con SignAndStamp, lo que produce hashes compatibles con RFC 3161 alineados con los 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.
    ¿Necesita dividir, rotar o eliminar páginas? Consulte 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 actual y se compila sin cambios en la versión preliminar de .NET 9 y el próximo lanzamiento de .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 el contenido con claves AES aprobadas por el NIST, bloqueando la apertura, impresión o copia no autorizadas.
  • Granularidad de permisos -- propiedades como AllowUserPrinting y AllowUserFormData controlan derechos por acción; se requiere la contraseña de propietario para que cualquier restricción tenga efecto.
  • Firmas digitales : SignAndStamp incorpora una marca de tiempo y una cadena de certificados RFC 3161, creando hashes a prueba de manipulaciones reconocidos por Adobe® Acrobat y otros visores ISO 32000-2.
  • API integral : tanto el cifrado como la firma modifican la misma instancia PdfDocument, evitando múltiples pases de archivos y preservando las fuentes, capas y metadatos internos.

Consejos Consejo para la solución de problemas: si Adobe Reader informa "firma no válida", asegúrese de que el PFX contenga un certificado raíz confiable y que las cadenas location estén limpias en 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 menos de 1 segundo en hardware moderno, pero el rendimiento puede multiplicarse mediante renderizados por lotes, habilitando el multiproceso y reduciendo la sobrecarga de Chrome headless. Los consejos a continuación se aplican a todas las versiones de .NET.

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. Recortar el coste de inicio de Chrome

La agrupación ayuda, y los contenedores Linux deben incluir dos bibliotecas nativas:

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

La ausencia de cualquiera de estas bibliotecas se manifiesta como el error libnss3.so not found en los registros de Docker.

Los indicadores de Chrome recomendados (aplicados automáticamente por IronPDF) incluyen --disable-gpu y --no-sandbox para reducir el uso de memoria y los problemas con usuarios root en contenedores.

3. Espere 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 plantillas PDF en lugar de volver a renderizar

Para ejecuciones de facturas, cree una plantilla PDF con marcadores de posición como [[name]] y realice un reemplazo de texto en lugar de reconstruir HTML complejo. Es 10 veces más rápido y consume menos memoria.

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. La aplicación de la clave es una sola línea de código (IronPdf.License.LicenseKey = "YOUR-KEY";) y se puede automatizar en procesos de 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 la clase, 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 18,560,885 | Versión: 2026.4 recién lanzado
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.