Ícono de mensaje
Saltar al pie de página
  1. IronPDF
  2. Blog de IronPDF
  3. Usando IronPDF
  4. Asp .NET Imprimir PDF
USANDO IRONPDF

Cómo imprimir archivos PDF en ASP.NET con IronPDF

Curtis Chau
Curtis Chau
Actualizado:

IronPDF permite la impresión confiable de PDF en aplicaciones ASP.NET con capacidades del lado del servidor y del lado del cliente. Maneja requisitos empresariales, incluidas impresoras de red, manejo de errores y generación de documentos listos para cumplir con las normas, con registros de auditoría completos.

Las tareas de impresión PDF de ASP.NET a menudo implican desafíos específicos de las arquitecturas empresariales. Ya sea que se generen documentos para facturas, informes o etiquetas de envío, implementar una funcionalidad de impresión confiable requiere navegar por las complejidades de la arquitectura servidor-cliente mientras se mantiene el cumplimiento de la seguridad. La biblioteca IronPDF ofrece funciones profesionales que incluyen firmas digitales, marcas de agua y compatibilidad con PDF/A para archivo a largo plazo.

Este artículo explica cómo gestionar tareas de impresión de PDF utilizando la biblioteca PDF .NET de IronPDF, cubriendo tanto la automatización del lado del servidor como los flujos de trabajo de impresión del lado del cliente. Los ejemplos apuntan a .NET 10 con estilo de declaración de nivel superior y están escritos en C#.

¿Cuáles son los desafíos clave de la impresión PDF en ASP.NET?

Las aplicaciones de escritorio tradicionales pueden acceder directamente a la impresora predeterminada, pero las aplicaciones ASP.NET Core enfrentan varios obstáculos al imprimir documentos PDF. Los entornos de servidor carecen de acceso directo a las impresoras debido a restricciones de seguridad de IIS , y el intento de generar procesos para acceder a archivos genera errores de permiso. Estas restricciones son particularmente críticas en industrias reguladas donde se deben mantener registros de auditoría y controles de acceso. Además, los procesos del servidor web generalmente se ejecutan bajo cuentas de servicio restringidas que no tienen acceso a los controladores de impresora físicos, lo que hace que la impresión basada en procesos no sea confiable incluso cuando se aprueban las pruebas locales.

// This fails in ASP.NET -- wrong approach
Process.Start(@"C:\Files\document.pdf"); // Works locally, crashes on server
// This fails in ASP.NET -- wrong approach
Process.Start(@"C:\Files\document.pdf"); // Works locally, crashes on server
$vbLabelText   $csharpLabel

El código anterior ilustra un error común. Las aplicaciones web deben gestionar de manera efectiva los escenarios de impresión tanto del lado del servidor como del lado del cliente y, al mismo tiempo, mantener los requisitos de residencia de datos. IronPDF resuelve este problema proporcionando una API .NET totalmente administrada que no depende de procesos externos ni de controladores de impresora.

¿Cómo instalar IronPDF en un proyecto ASP.NET ?

IronPDF proporciona una solución .NET Core completa para generar documentos PDF e imprimirlos sin dependencias externas. La instalación del paquete NuGet es sencilla tanto para aplicaciones .NET Framework como .NET Core .

Instalar a través de la consola del administrador de paquetes:

Install-Package IronPdf
Install-Package IronPdf
SHELL

O a través de .NET CLI:

dotnet add package IronPdf
dotnet add package IronPdf
SHELL

IronPDF funciona en todos los sistemas operativos, incluidos Windows Server, distribuciones de Linux y contenedores Docker , eliminando los problemas de compatibilidad que afectan a otras bibliotecas. En macOS, la biblioteca admite de forma nativa procesadores Intel y Apple Silicon.

Después de la instalación, agregue una clave de licencia durante el inicio para activar el conjunto completo de funciones:

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
$vbLabelText   $csharpLabel

Está disponible una licencia de prueba gratuita para evaluar todas las funciones antes de comprar.

¿Cómo crear e imprimir documentos PDF del lado del servidor?

El siguiente ejemplo muestra cómo generar e imprimir un documento PDF desde el marcado HTML dentro de un controlador ASP.NET . El ChromePdfRenderer garantiza una representación perfecta con soporte completo de CSS. Usar CssMediaType.Print activa las hojas de estilo específicas de impresión definidas en tu HTML, de modo que la salida coincide exactamente con lo que mostraría una vista previa de impresión en un navegador:

using IronPdf;
using Microsoft.AspNetCore.Mvc;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();
var app = builder.Build();
app.MapControllers();
app.Run();

[ApiController]
[Route("[controller]")]
public class PdfController : ControllerBase
{
    [HttpGet("print")]
    public IActionResult PrintDocument()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PrintHtmlBackgrounds = true;
        renderer.RenderingOptions.MarginBottom = 10;
        renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;

        var pdf = renderer.RenderHtmlAsPdf("<h1>Invoice</h1><p>Total: $749.00</p>");

        // Print to default server printer
        pdf.Print();

        return Ok("Document sent to printer");
    }
}
using IronPdf;
using Microsoft.AspNetCore.Mvc;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();
var app = builder.Build();
app.MapControllers();
app.Run();

[ApiController]
[Route("[controller]")]
public class PdfController : ControllerBase
{
    [HttpGet("print")]
    public IActionResult PrintDocument()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PrintHtmlBackgrounds = true;
        renderer.RenderingOptions.MarginBottom = 10;
        renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;

        var pdf = renderer.RenderHtmlAsPdf("<h1>Invoice</h1><p>Total: $749.00</p>");

        // Print to default server printer
        pdf.Print();

        return Ok("Document sent to printer");
    }
}
Imports IronPdf
Imports Microsoft.AspNetCore.Mvc

Dim builder = WebApplication.CreateBuilder(args)
builder.Services.AddControllers()
Dim app = builder.Build()
app.MapControllers()
app.Run()

<ApiController>
<Route("[controller]")>
Public Class PdfController
    Inherits ControllerBase

    <HttpGet("print")>
    Public Function PrintDocument() As IActionResult
        Dim renderer = New ChromePdfRenderer()
        renderer.RenderingOptions.PrintHtmlBackgrounds = True
        renderer.RenderingOptions.MarginBottom = 10
        renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print

        Dim pdf = renderer.RenderHtmlAsPdf("<h1>Invoice</h1><p>Total: $749.00</p>")

        ' Print to default server printer
        pdf.Print()

        Return Ok("Document sent to printer")
    End Function
End Class
$vbLabelText   $csharpLabel

Este ejemplo envía el PDF renderizado directamente a la impresora del servidor predeterminado. El ChromePdfRenderer conserva el estilo CSS y el formato de fuente. Para páginas con mucho JavaScript, añade un retraso de renderización usando RenderingOptions.WaitFor para permitir que el contenido dinámico termine de cargarse antes de la captura.

¿Cómo se ve la salida de impresión del lado del servidor?

Cuadro de diálogo de 'Guardar salida de impresión como' de Windows que muestra carpetas y unidades del sistema de archivos, con el formato PDF seleccionado como tipo de guardado

¿Cómo configurar impresoras de red en ASP.NET?

Para entornos empresariales que requieren un enrutamiento de impresora específico con seguimiento de cumplimiento, IronPDF ofrece una gestión completa de documentos de impresión. La biblioteca admite varios tamaños de papel y orientaciones de página:

using IronPdf;
using System.Drawing.Printing;
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("[controller]")]
public class NetworkPrintController : ControllerBase
{
    [HttpPost("print-network")]
    public IActionResult PrintToNetworkPrinter(string filePath)
    {
        try
        {
            var pdfDocument = PdfDocument.FromFile(filePath);
            var printDocument = pdfDocument.GetPrintDocument();

            // Specify network printer with failover support
            printDocument.PrinterSettings.PrinterName = @"\\server\printer";
            printDocument.PrinterSettings.Copies = 2;
            printDocument.DefaultPageSettings.PaperSize = new PaperSize("A4", 827, 1169);

            var printJobId = Guid.NewGuid().ToString();
            printDocument.Print();

            return Ok(new
            {
                success = true,
                jobId = printJobId,
                message = "Document sent to " + printDocument.PrinterSettings.PrinterName
            });
        }
        catch (Exception ex)
        {
            return StatusCode(500, new { error = "Print operation failed", details = ex.Message });
        }
    }
}
using IronPdf;
using System.Drawing.Printing;
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("[controller]")]
public class NetworkPrintController : ControllerBase
{
    [HttpPost("print-network")]
    public IActionResult PrintToNetworkPrinter(string filePath)
    {
        try
        {
            var pdfDocument = PdfDocument.FromFile(filePath);
            var printDocument = pdfDocument.GetPrintDocument();

            // Specify network printer with failover support
            printDocument.PrinterSettings.PrinterName = @"\\server\printer";
            printDocument.PrinterSettings.Copies = 2;
            printDocument.DefaultPageSettings.PaperSize = new PaperSize("A4", 827, 1169);

            var printJobId = Guid.NewGuid().ToString();
            printDocument.Print();

            return Ok(new
            {
                success = true,
                jobId = printJobId,
                message = "Document sent to " + printDocument.PrinterSettings.PrinterName
            });
        }
        catch (Exception ex)
        {
            return StatusCode(500, new { error = "Print operation failed", details = ex.Message });
        }
    }
}
Imports IronPdf
Imports System.Drawing.Printing
Imports Microsoft.AspNetCore.Mvc

<ApiController>
<Route("[controller]")>
Public Class NetworkPrintController
    Inherits ControllerBase

    <HttpPost("print-network")>
    Public Function PrintToNetworkPrinter(filePath As String) As IActionResult
        Try
            Dim pdfDocument = PdfDocument.FromFile(filePath)
            Dim printDocument = pdfDocument.GetPrintDocument()

            ' Specify network printer with failover support
            printDocument.PrinterSettings.PrinterName = "\\server\printer"
            printDocument.PrinterSettings.Copies = 2
            printDocument.DefaultPageSettings.PaperSize = New PaperSize("A4", 827, 1169)

            Dim printJobId = Guid.NewGuid().ToString()
            printDocument.Print()

            Return Ok(New With {
                .success = True,
                .jobId = printJobId,
                .message = "Document sent to " & printDocument.PrinterSettings.PrinterName
            })
        Catch ex As Exception
            Return StatusCode(500, New With {.error = "Print operation failed", .details = ex.Message})
        End Try
    End Function
End Class
$vbLabelText   $csharpLabel

Este enfoque proporciona un control completo sobre la configuración de la impresora, incluido el formato del papel y la resolución. La implementación incluye el manejo de errores y el seguimiento de trabajos necesarios para los marcos de cumplimiento. Para la impresión de gran volumen, considere implementar el procesamiento asincrónico y la optimización de la memoria para mantener alto el rendimiento del servidor.

¿Cuáles son las consideraciones de seguridad para la impresión en red?

Cuadro de diálogo Guardar Como de Windows para guardar la salida de impresión como PDF, mostrando la navegación del sistema de archivos con carpetas e información de almacenamiento en la unidad

¿Cómo verificar trabajos de impresión exitosos?

Consola de salida del navegador mostrando una operación de impresión exitosa con respuesta JSON que contiene 'éxito: true' y un mensaje de confirmación de que el documento fue enviado a Microsoft Print to PDF

¿Cuál es la mejor estrategia de impresión del lado del cliente?

Dado que los navegadores restringen el acceso directo a la impresora por razones de seguridad, implemente la impresión del lado del cliente proporcionando el archivo PDF con encabezados de seguridad adecuados. IronPDF admite varias opciones de compresión para acelerar la entrega de archivos. Este patrón es ideal cuando los usuarios finales necesitan elegir su propio destino de impresión desde el cuadro de diálogo de impresión del navegador:

using IronPdf;
using IronPdf.Rendering;
using Microsoft.AspNetCore.Mvc;
using System.Text;

[ApiController]
[Route("[controller]")]
public class ClientPrintController : ControllerBase
{
    [HttpGet("pdf")]
    public IActionResult GetRawPrintablePdf()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.EnableJavaScript = false;

        var pdf = renderer.RenderHtmlAsPdf(GetInvoiceHtml());

        pdf.SecuritySettings.AllowUserPrinting = true;
        pdf.SecuritySettings.AllowUserEditing = false;
        pdf.SecuritySettings.AllowUserCopyPasteContent = false;

        pdf.ApplyWatermark(
            "<h2 style='color:red;opacity:0.3'>CONFIDENTIAL</h2>",
            30,
            VerticalAlignment.Middle,
            HorizontalAlignment.Center);

        HttpContext.Response.Headers["Content-Disposition"] = "inline; filename=invoice.pdf";
        HttpContext.Response.Headers["X-Content-Type-Options"] = "nosniff";

        return File(pdf.BinaryData, "application/pdf");
    }

    [HttpGet("print-wrapper")]
    public IActionResult PrintUsingClientWrapper()
    {
        var printUrl = Url.Action(nameof(GetRawPrintablePdf));
        var html = new StringBuilder();
        html.AppendLine("<!DOCTYPE html><html lang=\"en\"><head><title>Print Document</title></head><body>");
        html.AppendLine($"<iframe src='{printUrl}' style='position:absolute;top:0;left:0;width:100%;height:100%;border:none;'></iframe>");
        html.AppendLine("<script>window.onload = function() { setTimeout(function() { window.print(); }, 100); };</script>");
        html.AppendLine("</body></html>");
        return Content(html.ToString(), "text/html");
    }

    private static string GetInvoiceHtml() => @"
        <html><head><style>
            body { font-family: Arial, sans-serif; }
            .header { font-weight: bold; color: #1e40af; }
            @media print { .no-print { display: none; } }
        </style></head>
        <body>
            <div class='header'>Invoice Summary</div>
            <p>Total Amount: <b>$749.00</b></p>
        </body></html>";
}
using IronPdf;
using IronPdf.Rendering;
using Microsoft.AspNetCore.Mvc;
using System.Text;

[ApiController]
[Route("[controller]")]
public class ClientPrintController : ControllerBase
{
    [HttpGet("pdf")]
    public IActionResult GetRawPrintablePdf()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.EnableJavaScript = false;

        var pdf = renderer.RenderHtmlAsPdf(GetInvoiceHtml());

        pdf.SecuritySettings.AllowUserPrinting = true;
        pdf.SecuritySettings.AllowUserEditing = false;
        pdf.SecuritySettings.AllowUserCopyPasteContent = false;

        pdf.ApplyWatermark(
            "<h2 style='color:red;opacity:0.3'>CONFIDENTIAL</h2>",
            30,
            VerticalAlignment.Middle,
            HorizontalAlignment.Center);

        HttpContext.Response.Headers["Content-Disposition"] = "inline; filename=invoice.pdf";
        HttpContext.Response.Headers["X-Content-Type-Options"] = "nosniff";

        return File(pdf.BinaryData, "application/pdf");
    }

    [HttpGet("print-wrapper")]
    public IActionResult PrintUsingClientWrapper()
    {
        var printUrl = Url.Action(nameof(GetRawPrintablePdf));
        var html = new StringBuilder();
        html.AppendLine("<!DOCTYPE html><html lang=\"en\"><head><title>Print Document</title></head><body>");
        html.AppendLine($"<iframe src='{printUrl}' style='position:absolute;top:0;left:0;width:100%;height:100%;border:none;'></iframe>");
        html.AppendLine("<script>window.onload = function() { setTimeout(function() { window.print(); }, 100); };</script>");
        html.AppendLine("</body></html>");
        return Content(html.ToString(), "text/html");
    }

    private static string GetInvoiceHtml() => @"
        <html><head><style>
            body { font-family: Arial, sans-serif; }
            .header { font-weight: bold; color: #1e40af; }
            @media print { .no-print { display: none; } }
        </style></head>
        <body>
            <div class='header'>Invoice Summary</div>
            <p>Total Amount: <b>$749.00</b></p>
        </body></html>";
}
Imports IronPdf
Imports IronPdf.Rendering
Imports Microsoft.AspNetCore.Mvc
Imports System.Text

<ApiController>
<Route("[controller]")>
Public Class ClientPrintController
    Inherits ControllerBase

    <HttpGet("pdf")>
    Public Function GetRawPrintablePdf() As IActionResult
        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.EnableJavaScript = False

        Dim pdf = renderer.RenderHtmlAsPdf(GetInvoiceHtml())

        pdf.SecuritySettings.AllowUserPrinting = True
        pdf.SecuritySettings.AllowUserEditing = False
        pdf.SecuritySettings.AllowUserCopyPasteContent = False

        pdf.ApplyWatermark("<h2 style='color:red;opacity:0.3'>CONFIDENTIAL</h2>", 30, VerticalAlignment.Middle, HorizontalAlignment.Center)

        HttpContext.Response.Headers("Content-Disposition") = "inline; filename=invoice.pdf"
        HttpContext.Response.Headers("X-Content-Type-Options") = "nosniff"

        Return File(pdf.BinaryData, "application/pdf")
    End Function

    <HttpGet("print-wrapper")>
    Public Function PrintUsingClientWrapper() As IActionResult
        Dim printUrl = Url.Action(NameOf(GetRawPrintablePdf))
        Dim html As New StringBuilder()
        html.AppendLine("<!DOCTYPE html><html lang=""en""><head><title>Print Document</title></head><body>")
        html.AppendLine($"<iframe src='{printUrl}' style='position:absolute;top:0;left:0;width:100%;height:100%;border:none;'></iframe>")
        html.AppendLine("<script>window.onload = function() { setTimeout(function() { window.print(); }, 100); };</script>")
        html.AppendLine("</body></html>")
        Return Content(html.ToString(), "text/html")
    End Function

    Private Shared Function GetInvoiceHtml() As String
        Return "
        <html><head><style>
            body { font-family: Arial, sans-serif; }
            .header { font-weight: bold; color: #1e40af; }
            @media print { .no-print { display: none; } }
        </style></head>
        <body>
            <div class='header'>Invoice Summary</div>
            <p>Total Amount: <b>$749.00</b></p>
        </body></html>"
    End Function
End Class
$vbLabelText   $csharpLabel

El PDF se abre en el navegador donde el usuario activa la impresión a través del cuadro de diálogo de impresión estándar. Este enfoque mantiene la seguridad a través de políticas de seguridad de contenido y marcas de agua, al tiempo que mantiene los recursos del servidor libres de dependencias del controlador de impresora.

¿Cómo garantiza la impresión del lado del cliente la seguridad de los datos?

Microsoft Edge print dialog showing a PDF invoice preview with $749.00 total and various print settings on the right side

¿Cómo trabajar con múltiples fuentes de entrada?

IronPDF maneja varias fuentes de entrada manteniendo la soberanía de los datos, lo cual es importante para los desarrolladores que crean flujos de trabajo de impresión dinámicos en entornos empresariales. La biblioteca admite archivos HTML , URL, cadenas HTML y contenido Markdown:

using IronPdf;
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("[controller]")]
public class MultiSourcePrintController : ControllerBase
{
    [HttpPost("print-multi")]
    public async Task<IActionResult> PrintFromMultipleSources()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.EnableJavaScript = false;
        renderer.RenderingOptions.Timeout = 30;

        // From URL with authentication
        renderer.LoginCredentials = new ChromeHttpLoginCredentials
        {
            NetworkUsername = "serviceaccount",
            NetworkPassword = "securepassword"
        };
        var pdfFromUrl = await renderer.RenderUrlAsPdfAsync("https://reports.internal.example.com/report");

        // From HTML file template
        var pdfFromFile = renderer.RenderHtmlFileAsPdf(@"Templates\report.html");

        // From sanitized HTML string
        var pdfFromString = renderer.RenderHtmlAsPdf("<h2>Summary Report</h2><p>Generated on demand.</p>");

        pdfFromUrl.Print();

        return Ok(new
        {
            message = "PDF documents processed and printed.",
            sources = new[] { "URL", "File", "HTML string" },
            timestamp = DateTime.UtcNow
        });
    }
}
using IronPdf;
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("[controller]")]
public class MultiSourcePrintController : ControllerBase
{
    [HttpPost("print-multi")]
    public async Task<IActionResult> PrintFromMultipleSources()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.EnableJavaScript = false;
        renderer.RenderingOptions.Timeout = 30;

        // From URL with authentication
        renderer.LoginCredentials = new ChromeHttpLoginCredentials
        {
            NetworkUsername = "serviceaccount",
            NetworkPassword = "securepassword"
        };
        var pdfFromUrl = await renderer.RenderUrlAsPdfAsync("https://reports.internal.example.com/report");

        // From HTML file template
        var pdfFromFile = renderer.RenderHtmlFileAsPdf(@"Templates\report.html");

        // From sanitized HTML string
        var pdfFromString = renderer.RenderHtmlAsPdf("<h2>Summary Report</h2><p>Generated on demand.</p>");

        pdfFromUrl.Print();

        return Ok(new
        {
            message = "PDF documents processed and printed.",
            sources = new[] { "URL", "File", "HTML string" },
            timestamp = DateTime.UtcNow
        });
    }
}
Imports IronPdf
Imports Microsoft.AspNetCore.Mvc

<ApiController>
<Route("[controller]")>
Public Class MultiSourcePrintController
    Inherits ControllerBase

    <HttpPost("print-multi")>
    Public Async Function PrintFromMultipleSources() As Task(Of IActionResult)
        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.EnableJavaScript = False
        renderer.RenderingOptions.Timeout = 30

        ' From URL with authentication
        renderer.LoginCredentials = New ChromeHttpLoginCredentials With {
            .NetworkUsername = "serviceaccount",
            .NetworkPassword = "securepassword"
        }
        Dim pdfFromUrl = Await renderer.RenderUrlAsPdfAsync("https://reports.internal.example.com/report")

        ' From HTML file template
        Dim pdfFromFile = renderer.RenderHtmlFileAsPdf("Templates\report.html")

        ' From sanitized HTML string
        Dim pdfFromString = renderer.RenderHtmlAsPdf("<h2>Summary Report</h2><p>Generated on demand.</p>")

        pdfFromUrl.Print()

        Return Ok(New With {
            .message = "PDF documents processed and printed.",
            .sources = New String() {"URL", "File", "HTML string"},
            .timestamp = DateTime.UtcNow
        })
    End Function
End Class
$vbLabelText   $csharpLabel

Cada método conserva la estructura y los gráficos del documento manteniendo la calidad de impresión. La implementación incluye autenticación, validación de entrada y soporte para cifrado. Para fuentes de entrada adicionales, IronPDF admite archivos DOCX, documentos RTF y formatos de imagen, lo que lo hace lo suficientemente flexible para funcionar como una única canalización de PDF en toda una aplicación.

Después de procesar documentos PDF, Windows muestra este cuadro de diálogo de guardado que permite a los usuarios guardar la salida de impresión mientras confirma que los documentos se enviaron a la impresora predeterminada

¿Cómo se implementa el manejo y registro de errores?

El manejo confiable de errores es esencial para entornos de producción con requisitos de registro de cumplimiento. IronPDF proporciona manejo nativo de excepciones y una guía de solución de problemas para diagnosticar fallas de impresión. Un patrón de identificación de correlación facilita la asociación de entradas de registro con solicitudes de impresión específicas al revisar el historial de auditoría:

using IronPdf;
using System.Drawing.Printing;
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("[controller]")]
public class SafePrintController : ControllerBase
{
    [HttpPost("safe-print")]
    public IActionResult SafePrint(string documentId)
    {
        var correlationId = Guid.NewGuid().ToString();

        try
        {
            var pdf = PdfDocument.FromFile(GetSecureFilePath(documentId));

            var availablePrinters = PrinterSettings.InstalledPrinters.Cast<string>().ToList();
            var targetPrinter = availablePrinters.FirstOrDefault();

            if (string.IsNullOrEmpty(targetPrinter))
            {
                return BadRequest(new
                {
                    error = "No printer available",
                    correlationId
                });
            }

            var printDoc = pdf.GetPrintDocument();
            printDoc.PrinterSettings.PrinterName = targetPrinter;
            printDoc.Print();

            return Ok(new
            {
                message = $"Document {documentId} printed successfully",
                printer = targetPrinter,
                correlationId,
                timestamp = DateTime.UtcNow
            });
        }
        catch (UnauthorizedAccessException)
        {
            return StatusCode(403, new { error = "Access denied", correlationId });
        }
        catch (Exception ex)
        {
            return StatusCode(500, new
            {
                error = "Printing failed",
                correlationId,
                message = "Contact support with the correlation ID"
            });
        }
    }

    private static string GetSecureFilePath(string documentId) =>
        Path.Combine(AppContext.BaseDirectory, "documents", documentId + ".pdf");
}
using IronPdf;
using System.Drawing.Printing;
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("[controller]")]
public class SafePrintController : ControllerBase
{
    [HttpPost("safe-print")]
    public IActionResult SafePrint(string documentId)
    {
        var correlationId = Guid.NewGuid().ToString();

        try
        {
            var pdf = PdfDocument.FromFile(GetSecureFilePath(documentId));

            var availablePrinters = PrinterSettings.InstalledPrinters.Cast<string>().ToList();
            var targetPrinter = availablePrinters.FirstOrDefault();

            if (string.IsNullOrEmpty(targetPrinter))
            {
                return BadRequest(new
                {
                    error = "No printer available",
                    correlationId
                });
            }

            var printDoc = pdf.GetPrintDocument();
            printDoc.PrinterSettings.PrinterName = targetPrinter;
            printDoc.Print();

            return Ok(new
            {
                message = $"Document {documentId} printed successfully",
                printer = targetPrinter,
                correlationId,
                timestamp = DateTime.UtcNow
            });
        }
        catch (UnauthorizedAccessException)
        {
            return StatusCode(403, new { error = "Access denied", correlationId });
        }
        catch (Exception ex)
        {
            return StatusCode(500, new
            {
                error = "Printing failed",
                correlationId,
                message = "Contact support with the correlation ID"
            });
        }
    }

    private static string GetSecureFilePath(string documentId) =>
        Path.Combine(AppContext.BaseDirectory, "documents", documentId + ".pdf");
}
Imports IronPdf
Imports System.Drawing.Printing
Imports Microsoft.AspNetCore.Mvc

<ApiController>
<Route("[controller]")>
Public Class SafePrintController
    Inherits ControllerBase

    <HttpPost("safe-print")>
    Public Function SafePrint(documentId As String) As IActionResult
        Dim correlationId = Guid.NewGuid().ToString()

        Try
            Dim pdf = PdfDocument.FromFile(GetSecureFilePath(documentId))

            Dim availablePrinters = PrinterSettings.InstalledPrinters.Cast(Of String)().ToList()
            Dim targetPrinter = availablePrinters.FirstOrDefault()

            If String.IsNullOrEmpty(targetPrinter) Then
                Return BadRequest(New With {
                    .error = "No printer available",
                    .correlationId = correlationId
                })
            End If

            Dim printDoc = pdf.GetPrintDocument()
            printDoc.PrinterSettings.PrinterName = targetPrinter
            printDoc.Print()

            Return Ok(New With {
                .message = $"Document {documentId} printed successfully",
                .printer = targetPrinter,
                .correlationId = correlationId,
                .timestamp = DateTime.UtcNow
            })
        Catch ex As UnauthorizedAccessException
            Return StatusCode(403, New With {.error = "Access denied", .correlationId = correlationId})
        Catch ex As Exception
            Return StatusCode(500, New With {
                .error = "Printing failed",
                .correlationId = correlationId,
                .message = "Contact support with the correlation ID"
            })
        End Try
    End Function

    Private Shared Function GetSecureFilePath(documentId As String) As String
        Return Path.Combine(AppContext.BaseDirectory, "documents", documentId & ".pdf")
    End Function
End Class
$vbLabelText   $csharpLabel

Esto garantiza una impresión confiable incluso cuando los recursos del sistema no están disponibles. Los identificadores de correlación le permiten rastrear solicitudes en sistemas distribuidos y vincular entradas de registro a trabajos de impresión específicos en registros de auditoría. Las respuestas de error estructuradas también permiten que el cliente que llama tome la acción apropiada, como volver a intentarlo con una impresora alternativa o notificar al usuario.

¿Qué sucede cuando las impresoras no están disponibles?

Si la impresora especificada en el código no está disponible, el código devuelve una respuesta de error estructurada:

Un mensaje de error de impresora común que los usuarios pueden encontrar al intentar imprimir documentos

¿Cómo supervisar trabajos de impresión exitosos?

Un trabajo de impresión exitoso devuelve un mensaje de confirmación con los detalles del trabajo:

Símbolo del sistema de Windows mostrando una confirmación exitosa de la impresión de PDF para un archivo ubicado en una estructura de carpetas anidadas en el Escritorio

¿Qué opciones de configuración avanzadas están disponibles?

Las opciones de renderizado de IronPDF admiten escenarios complejos requeridos por las arquitecturas empresariales. La biblioteca proporciona configuraciones para la optimización del rendimiento y la gestión de la memoria al generar documentos de alta fidelidad. Configurar DpiResolution a 300 produce una salida de calidad de impresión adecuada para documentos físicos, mientras que la opción CssMediaType.Print activa cualquier regla CSS específica de impresión en el HTML de origen:

using IronPdf;
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("[controller]")]
public class AdvancedPrintController : ControllerBase
{
    [HttpGet("advanced")]
    public IActionResult ConfigureAdvancedPrinting()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.EnableJavaScript = false;
        renderer.RenderingOptions.RenderDelay = 500;
        renderer.RenderingOptions.Timeout = 60;
        renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
        renderer.RenderingOptions.PrintHtmlBackgrounds = true;
        renderer.RenderingOptions.DpiResolution = 300;

        var pdf = renderer.RenderHtmlAsPdf(GetEnterpriseHtml());

        pdf.SecuritySettings.AllowUserPrinting = true;
        pdf.SecuritySettings.AllowUserEditing = false;
        pdf.SecuritySettings.OwnerPassword = Guid.NewGuid().ToString();

        pdf.MetaData.Author = "Enterprise Document System";
        pdf.MetaData.Subject = "Compliance Document";
        pdf.MetaData.Keywords = "enterprise,secure,compliant";
        pdf.MetaData.CreationDate = DateTime.UtcNow;

        // Apply digital signature for document integrity
        // pdf.SignWithFile("/path/to/certificate.pfx", "certificatePassword");

        return File(pdf.BinaryData, "application/pdf");
    }

    private static string GetEnterpriseHtml() => @"
        <!DOCTYPE html><html><head>
        <style>@page { size: A4; margin: 1cm; } body { font-family: Arial, sans-serif; }</style>
        </head><body>
        <h1>Enterprise Document</h1>
        <p>CONFIDENTIAL -- INTERNAL USE ONLY</p>
        </body></html>";
}
using IronPdf;
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("[controller]")]
public class AdvancedPrintController : ControllerBase
{
    [HttpGet("advanced")]
    public IActionResult ConfigureAdvancedPrinting()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.EnableJavaScript = false;
        renderer.RenderingOptions.RenderDelay = 500;
        renderer.RenderingOptions.Timeout = 60;
        renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
        renderer.RenderingOptions.PrintHtmlBackgrounds = true;
        renderer.RenderingOptions.DpiResolution = 300;

        var pdf = renderer.RenderHtmlAsPdf(GetEnterpriseHtml());

        pdf.SecuritySettings.AllowUserPrinting = true;
        pdf.SecuritySettings.AllowUserEditing = false;
        pdf.SecuritySettings.OwnerPassword = Guid.NewGuid().ToString();

        pdf.MetaData.Author = "Enterprise Document System";
        pdf.MetaData.Subject = "Compliance Document";
        pdf.MetaData.Keywords = "enterprise,secure,compliant";
        pdf.MetaData.CreationDate = DateTime.UtcNow;

        // Apply digital signature for document integrity
        // pdf.SignWithFile("/path/to/certificate.pfx", "certificatePassword");

        return File(pdf.BinaryData, "application/pdf");
    }

    private static string GetEnterpriseHtml() => @"
        <!DOCTYPE html><html><head>
        <style>@page { size: A4; margin: 1cm; } body { font-family: Arial, sans-serif; }</style>
        </head><body>
        <h1>Enterprise Document</h1>
        <p>CONFIDENTIAL -- INTERNAL USE ONLY</p>
        </body></html>";
}
Imports IronPdf
Imports Microsoft.AspNetCore.Mvc

<ApiController>
<Route("[controller]")>
Public Class AdvancedPrintController
    Inherits ControllerBase

    <HttpGet("advanced")>
    Public Function ConfigureAdvancedPrinting() As IActionResult
        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
        renderer.RenderingOptions.EnableJavaScript = False
        renderer.RenderingOptions.RenderDelay = 500
        renderer.RenderingOptions.Timeout = 60
        renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print
        renderer.RenderingOptions.PrintHtmlBackgrounds = True
        renderer.RenderingOptions.DpiResolution = 300

        Dim pdf = renderer.RenderHtmlAsPdf(GetEnterpriseHtml())

        pdf.SecuritySettings.AllowUserPrinting = True
        pdf.SecuritySettings.AllowUserEditing = False
        pdf.SecuritySettings.OwnerPassword = Guid.NewGuid().ToString()

        pdf.MetaData.Author = "Enterprise Document System"
        pdf.MetaData.Subject = "Compliance Document"
        pdf.MetaData.Keywords = "enterprise,secure,compliant"
        pdf.MetaData.CreationDate = DateTime.UtcNow

        ' Apply digital signature for document integrity
        ' pdf.SignWithFile("/path/to/certificate.pfx", "certificatePassword")

        Return File(pdf.BinaryData, "application/pdf")
    End Function

    Private Shared Function GetEnterpriseHtml() As String
        Return "
        <!DOCTYPE html><html><head>
        <style>@page { size: A4; margin: 1cm; } body { font-family: Arial, sans-serif; }</style>
        </head><body>
        <h1>Enterprise Document</h1>
        <p>CONFIDENTIAL -- INTERNAL USE ONLY</p>
        </body></html>"
    End Function
End Class
$vbLabelText   $csharpLabel

Una vez generado con todas las configuraciones de seguridad aplicadas, llamar a pdf.Print() envía el documento a la impresora. Este enfoque garantiza el cumplimiento de los estándares de seguridad empresarial al tiempo que mantiene la integridad de los documentos mediante firmas digitales y cifrado. Para el archivo a largo plazo, considere la compatibilidad con PDF/A , un estándar diseñado específicamente para documentos que deben permanecer legibles y reproducibles durante décadas.

¿Cómo se comparan la impresión del lado del servidor y la del lado del cliente?

La elección entre la impresión del lado del servidor y del lado del cliente depende de su caso de uso. La siguiente tabla resume las principales compensaciones:

Impresión de PDF del lado del servidor frente a la del lado del cliente en ASP.NET
Aspecto Impresión del lado del servidor Impresión del lado del cliente
Acceso a la impresora Impresoras de red y locales en el servidor Impresoras conectadas localmente del usuario
Interacción del usuario Ninguno - totalmente automatizado Aparece el cuadro de diálogo de impresión del navegador
Registro de cumplimiento Registro de auditoría completo del lado del servidor Solo registro de la consola del lado del cliente
Control de seguridad El servidor aplica todas las restricciones El navegador aplica la política de seguridad del contenido
Mejor para Trabajos por lotes, facturas, industrias reguladas Impresión a pedido activada por el usuario

Para las industrias reguladas que requieren registros de auditoría documentados, la impresión del lado del servidor es la opción preferida. La impresión del lado del cliente es ideal para situaciones donde los usuarios finales necesitan controlar el destino de la impresión.

¿Por qué elegir IronPDF para la impresión PDF en ASP.NET?

IronPDF transforma la impresión de PDF ASP.NET de un desafío complejo a una implementación sencilla manteniendo los estándares de seguridad empresarial. Sin necesidad de Adobe Reader ni dependencias externas, la biblioteca genera e imprime archivos PDF con un código mínimo y al mismo tiempo garantiza el cumplimiento de SOC2, HIPAA y las regulaciones específicas de la industria.

La API completa admite varios formatos de entrada, capacidades de edición, funciones de seguridad y herramientas de organización para la gestión completa de PDF. Los extensos tutoriales de la biblioteca, ejemplos de código y recursos de resolución de problemas garantizan una integración fluida con la infraestructura existente.

Para requisitos de impresión que van más allá de la generación de PDF (como la impresión directa de imágenes o archivos de Office), Iron Software también ofrece IronPrint , una biblioteca de impresión .NET dedicada. A diferencia de IronPDF, que se centra en generar y manipular contenido PDF, IronPrint se especializa en la impresión directa de archivos sin conversión intermedia. Según la documentación ASP.NET de Microsoft , las operaciones de impresión del lado del servidor están sujetas a restricciones de identidad del grupo de aplicaciones de IIS, lo que hace que el enfoque de biblioteca sea la opción arquitectónica correcta para cualquier implementación de producción.

Comience hoy mismo de forma gratuita con la prueba gratuita y experimente cómo IronPDF simplifica el procesamiento de documentos en aplicaciones ASP.NET . Con documentación completa , soporte de ingeniería directo y certificaciones de cumplimiento comprobadas, la impresión de PDF lista para producción puede ejecutarse en minutos. Para obtener información adicional, consulte la guía de Iron Software sobre seguridad de documentos PDF y la especificación de accesibilidad a PDF del W3C .

Preguntas Frecuentes

¿Cómo puedo imprimir un PDF directamente desde una aplicación ASP.NET?

Puede imprimir un PDF directamente desde una aplicación ASP.NET utilizando IronPDF convirtiendo archivos HTML a PDF y enviándolos después a una impresora. IronPDF simplifica este proceso con sus métodos incorporados.

¿Cuáles son las ventajas de utilizar IronPDF para imprimir archivos PDF en ASP.NET?

IronPDF ofrece varias ventajas para la impresión de archivos PDF en ASP.NET, como una integración sencilla, una renderización de alta calidad y la capacidad de convertir contenido HTML a PDF con precisión.

¿Es posible personalizar el PDF antes de imprimirlo con IronPDF?

Sí, IronPDF permite personalizar los PDF antes de imprimirlos añadiendo encabezados, pies de página y marcas de agua, así como estableciendo el tamaño de las páginas y los márgenes.

¿Puede IronPDF manejar archivos PDF de gran tamaño para su impresión?

IronPDF es capaz de gestionar archivos PDF de gran tamaño con eficacia, garantizando que incluso los documentos complejos se impriman con precisión y rapidez desde su aplicación ASP.NET.

¿Admite IronPDF diferentes configuraciones de impresora para la impresión de PDF?

IronPDF admite varias configuraciones de impresora, lo que le permite especificar el tamaño del papel, la orientación y la calidad de impresión para adaptarse a sus necesidades.

¿Existe alguna forma de previsualizar los PDF antes de imprimirlos en ASP.NET?

Con IronPDF, puede generar y mostrar una vista previa de PDF dentro de su aplicación ASP.NET, permitiendo a los usuarios revisar el documento antes de iniciar el comando de impresión.

¿Qué formatos puede convertir IronPDF a PDF para su impresión?

IronPDF puede convertir una amplia gama de formatos a PDF para impresión, incluidos HTML, ASPX y archivos de imagen, lo que lo hace versátil para diversas necesidades de aplicación.

¿Cómo garantiza IronPDF la calidad de los documentos PDF impresos?

IronPDF utiliza tecnología de renderizado avanzada para garantizar que los documentos PDF impresos mantengan una alta fidelidad al contenido original, con texto nítido e imágenes claras.

¿Se puede utilizar IronPDF para imprimir PDF cifrados o protegidos por contraseña?

Sí, IronPDF puede manejar PDF cifrados o protegidos con contraseña, lo que le permite imprimirlos de forma segura proporcionando las credenciales necesarias dentro de su aplicación ASP.NET.

¿Es fácil integrar IronPDF en una aplicación ASP.NET existente?

La integración de IronPDF en una aplicación ASP.NET existente es sencilla gracias a su completa documentación y a su compatibilidad con diversos entornos de desarrollo.

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

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

Leer más

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

Equipo de soporte de Iron

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