Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronPDF
  2. Blog do IronPDF
  3. Usando o IronPDF
  4. ASP.NET Imprimir PDF
USANDO O IRONPDF

Como Imprimir Arquivos PDF em ASP.NET com IronPDF

Curtis Chau
Curtis Chau
Atualizado:

O IronPDF permite a impressão confiável de PDFs em aplicações ASP.NET , com funcionalidades tanto no servidor quanto no cliente. Ele lida com requisitos corporativos, incluindo impressoras de rede, tratamento de erros e geração de documentos em conformidade com as normas, com trilhas de auditoria completas.

As tarefas de impressão de PDF em ASP.NET frequentemente envolvem desafios específicos de arquiteturas corporativas. Seja para gerar documentos como faturas, relatórios ou etiquetas de envio, implementar uma funcionalidade de impressão confiável exige lidar com as complexidades da arquitetura cliente-servidor, mantendo a conformidade com os padrões de segurança. A biblioteca IronPDF oferece recursos profissionais, incluindo assinaturas digitais, marcas d'água e conformidade com PDF/A para arquivamento a longo prazo.

Este artigo explica como lidar com tarefas de impressão de PDF usando a biblioteca .NET PDF do IronPDF, abordando tanto a automação do lado do servidor quanto os fluxos de trabalho de impressão do lado do cliente. Os exemplos são direcionados ao .NET 10 com estilo de instrução de nível superior e estão escritos em C#.

Quais são os principais desafios da impressão em PDF no ASP.NET?

Os aplicativos de desktop tradicionais podem acessar diretamente a impressora padrão, mas os aplicativos ASP.NET Core enfrentam diversos obstáculos ao imprimir documentos PDF. Em ambientes de servidor, o acesso direto à impressora é limitado devido às restrições de segurança do IIS , e a tentativa de iniciar processos para acessar arquivos gera erros de permissão. Essas restrições são particularmente críticas em setores regulamentados, onde é necessário manter registros de auditoria e controles de acesso. Além disso, os processos do servidor web normalmente são executados em contas de serviço restritas que não têm acesso aos drivers físicos da impressora, o que torna a impressão baseada em processos não confiável, mesmo quando os testes locais são aprovados.

// 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

O código acima ilustra um erro comum. Os aplicativos da Web devem lidar de forma eficaz com cenários de impressão tanto do lado do servidor quanto do lado do cliente, mantendo os requisitos de residência de dados. O IronPDF resolve isso fornecendo uma API .NET totalmente gerenciada que não depende de processos externos ou drivers de impressora.

Como instalar o IronPDF em um projeto ASP.NET ?

O IronPDF oferece uma solução completa em .NET Core para gerar documentos PDF e imprimi-los sem dependências externas. A instalação do pacote NuGet é simples tanto para aplicações .NET Framework quanto para aplicações .NET Core .

Instale através do Console do Gerenciador de Pacotes:

Install-Package IronPdf
Install-Package IronPdf
SHELL

Ou através da CLI do .NET :

dotnet add package IronPdf
dotnet add package IronPdf
SHELL

O IronPDF funciona em diversos sistemas operacionais, incluindo Windows Server, distribuições Linux e contêineres Docker , eliminando os problemas de compatibilidade que afetam outras bibliotecas. No macOS, a biblioteca oferece suporte nativo aos processadores Intel e Apple Silicon.

Após a instalação, adicione uma chave de licença durante a inicialização para ativar o conjunto completo de recursos:

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

Está disponível uma licença de avaliação gratuita para que você possa testar todas as funcionalidades antes de comprar.

Como criar e imprimir documentos PDF no servidor?

O exemplo a seguir mostra como gerar e imprimir um documento PDF a partir de marcação HTML dentro de um controlador ASP.NET . O ChromePdfRenderer garante a renderização perfeita de pixels com suporte completo a CSS. Usar CssMediaType.Print ativa estilos de impressão específicos definidos em seu HTML, para que a saída corresponda exatamente ao que uma visualização de impressão mostraria em um 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 exemplo envia o PDF renderizado diretamente para a impressora padrão do servidor. O ChromePdfRenderer preserva o estilo CSS e a formatação de fontes. Para páginas pesadas em JavaScript, adicione um atraso de renderização usando RenderingOptions.WaitFor para permitir que o conteúdo dinâmico termine de carregar antes de capturar.

Qual é a aparência da saída de impressão do lado do servidor?

Caixa de diálogo do Windows 'Salvar Impressão Como' exibindo pastas e unidades do sistema de arquivos, com o formato PDF selecionado como tipo de salvamento

Como configurar impressoras de rede em ASP.NET?

Para ambientes corporativos que exigem roteamento específico de impressoras com rastreamento de conformidade, o IronPDF oferece gerenciamento completo de documentos de impressão. A biblioteca suporta diversos tamanhos de papel e orientações 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

Essa abordagem proporciona controle total sobre as configurações da impressora, incluindo formato e resolução do papel. A implementação inclui o tratamento de erros e o rastreamento de tarefas exigidos pelas estruturas de conformidade. Para impressão de alto volume, considere implementar processamento assíncrono e otimização de memória para manter a taxa de transferência do servidor elevada.

Quais são as considerações de segurança para impressão em rede?

Caixa de diálogo Salvar Como do Windows para salvar a impressão como PDF, mostrando navegação do sistema de arquivos com informações de pastas e armazenamento em unidades

Como verificar se os trabalhos de impressão foram bem-sucedidos?

Saída do console do navegador mostrando operação de impressão bem-sucedida com resposta JSON contendo 'success: true' e mensagem de confirmação de que o documento foi enviado para Microsoft Print to PDF

Qual é a melhor estratégia de impressão do lado do cliente?

Como os navegadores restringem o acesso direto à impressora por motivos de segurança, implemente a impressão no lado do cliente, fornecendo o arquivo PDF com os cabeçalhos de segurança apropriados. O IronPDF oferece suporte a várias opções de compressão para acelerar a entrega de arquivos. Esse padrão é ideal quando os usuários finais precisam escolher o próprio destino de impressão na caixa de diálogo de impressão do 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

O arquivo PDF é aberto no navegador, onde o usuário inicia a impressão através da caixa de diálogo de impressão padrão. Essa abordagem mantém a segurança por meio de políticas de segurança de conteúdo e marcas d'água, ao mesmo tempo que mantém os recursos do servidor livres de dependências de drivers de impressora.

Como a impressão no lado do cliente garante a segurança dos dados?

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

Como você trabalha com múltiplas fontes de entrada?

O IronPDF lida com diversas fontes de entrada, mantendo a soberania dos dados — algo importante para desenvolvedores que criam fluxos de trabalho de impressão dinâmicos em ambientes corporativos. A biblioteca suporta arquivos HTML , URLs, strings HTML e conteúdo 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 preserva a estrutura e os elementos gráficos do documento, mantendo a qualidade de impressão. A implementação inclui autenticação, validação de entrada e suporte para criptografia. Para fontes de entrada adicionais, o IronPDF suporta arquivos DOCX, documentos RTF e formatos de imagem, tornando-o flexível o suficiente para servir como um único pipeline de PDF em toda uma aplicação.

Após o processamento dos documentos PDF, o Windows exibe esta caixa de diálogo de salvamento permitindo que os usuários salvem a saída de impressão enquanto confirmam que os documentos foram enviados para a impressora padrão

Como implementar o tratamento de erros e o registro de logs?

Um tratamento de erros confiável é essencial para ambientes de produção com requisitos de registro de conformidade. O IronPDF oferece tratamento de exceções nativo e um guia de solução de problemas para diagnosticar falhas de impressão. Um padrão de ID de correlação facilita a correspondência de entradas de log com solicitações de impressão específicas ao revisar o histórico de auditoria:

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

Isso garante uma impressão confiável mesmo quando os recursos do sistema não estão disponíveis. Os IDs de correlação permitem rastrear solicitações em sistemas distribuídos e vincular entradas de log a trabalhos de impressão específicos em trilhas de auditoria. As respostas de erro estruturadas também permitem que o cliente que fez a chamada tome as medidas apropriadas, como tentar novamente com uma impressora alternativa ou notificar o usuário.

O que acontece quando as impressoras não estão disponíveis?

Se a impressora especificada no código não estiver disponível, o código retorna uma resposta de erro estruturada:

Uma mensagem comum de erro de impressora que os usuários podem encontrar ao tentar imprimir documentos

Como monitorar trabalhos de impressão bem-sucedidos?

Uma impressão bem-sucedida retorna uma mensagem de confirmação com os detalhes da tarefa:

Prompt de comando do Windows exibindo confirmação de impressão de PDF bem-sucedida para um arquivo localizado em uma estrutura de pastas aninhada na Área de Trabalho

Quais opções de configuração avançada estão disponíveis?

As opções de renderização do IronPDF suportam cenários complexos exigidos por arquiteturas empresariais. A biblioteca oferece configurações para otimização de desempenho e gerenciamento de memória na geração de documentos de alta fidelidade. Definir DpiResolution para 300 produz uma saída de qualidade de impressão adequada para documentos físicos, enquanto a opção CssMediaType.Print ativa quaisquer regras CSS específicas para impressão no HTML de origem:

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

Uma vez gerado com todas as configurações de segurança aplicadas, chamar pdf.Print() envia o documento para a impressora. Essa abordagem garante a conformidade com os padrões de segurança corporativos, mantendo a integridade dos documentos por meio de assinaturas digitais e criptografia. Para arquivamento a longo prazo, considere a conformidade com o PDF/A — um padrão especificamente desenvolvido para documentos que devem permanecer legíveis e reproduzíveis por décadas.

Como se comparam a impressão no servidor e a impressão no cliente?

A escolha entre impressão no servidor e impressão no cliente depende do seu caso de uso. A tabela abaixo resume as principais vantagens e desvantagens:

Impressão de PDF no servidor versus impressão no cliente em ASP.NET
Aspecto Impressão no servidor Impressão no lado do cliente
Acesso à impressora Impressoras de rede e locais no servidor Impressoras conectadas localmente pelo usuário
Interação do usuário Nenhum -- totalmente automatizado A caixa de diálogo de impressão do navegador é exibida.
Registro de conformidade Registro completo de auditoria do lado do servidor Somente o log do console do lado do cliente
Controle de segurança O servidor aplica todas as restrições. O navegador aplica a política de segurança de conteúdo.
Ideal para Tarefas em lote, faturas, setores regulamentados Impressão sob demanda acionada pelo usuário

Para setores regulamentados que exigem trilhas de auditoria documentadas, a impressão no servidor é a opção preferencial. A impressão no lado do cliente é adequada para cenários em que os usuários finais precisam controlar o destino da impressão.

Por que escolher o IronPDF para impressão de PDFs em ASP.NET?

O IronPDF transforma a impressão de PDFs em ASP.NET , de um desafio complexo para uma implementação simples, mantendo os padrões de segurança corporativos. Sem exigir o Adobe Reader ou dependências externas, a biblioteca gera e imprime arquivos PDF com o mínimo de código, garantindo a conformidade com as normas SOC2, HIPAA e regulamentações específicas do setor.

A API completa oferece suporte a diversos formatos de entrada, recursos de edição, funcionalidades de segurança e ferramentas de organização para gerenciamento completo de PDFs. Os tutoriais extensos da biblioteca, exemplos de código e recursos de resolução de problemas garantem uma integração suave na infraestrutura existente.

Para requisitos de impressão que vão além da geração de PDFs — como a impressão direta de imagens ou arquivos do Office — a Iron Software também oferece o IronPrint , uma biblioteca de impressão .NET dedicada. Diferentemente do IronPDF, que se concentra na geração e manipulação de conteúdo PDF, o IronPrint é especializado na impressão direta de arquivos sem conversão intermediária. De acordo com a documentação do ASP.NET da Microsoft , as operações de impressão no servidor estão sujeitas às restrições de identidade do pool de aplicativos do IIS, tornando a abordagem de biblioteca a escolha arquitetônica correta para qualquer implantação em produção.

Comece hoje mesmo gratuitamente com o teste grátis e experimente como o IronPDF simplifica o processamento de documentos em aplicações ASP.NET . Com documentação completa , suporte técnico direto e certificações de conformidade comprovadas, a impressão de PDFs pronta para produção pode ser iniciada em minutos. Para leituras adicionais, consulte o guia da Iron Software sobre segurança de documentos PDF e a especificação de acessibilidade de PDF da W3C .

Perguntas frequentes

Como posso imprimir um PDF diretamente de uma aplicação ASP.NET?

Você pode imprimir um PDF diretamente de um aplicativo ASP.NET usando o IronPDF, convertendo arquivos HTML em PDF e enviando-os para uma impressora. O IronPDF simplifica esse processo com seus métodos integrados.

Quais são os benefícios de usar o IronPDF para imprimir PDFs em ASP.NET?

O IronPDF oferece diversas vantagens para a impressão de PDFs em ASP.NET, incluindo fácil integração, renderização de alta qualidade e a capacidade de converter conteúdo HTML em PDF com precisão.

É possível personalizar o PDF antes da impressão usando o IronPDF?

Sim, o IronPDF permite personalizar PDFs antes da impressão, adicionando cabeçalhos, rodapés e marcas d'água, além de definir tamanhos de página e margens.

O IronPDF consegue lidar com arquivos PDF grandes para impressão?

O IronPDF é capaz de lidar com arquivos PDF grandes de forma eficiente, garantindo que até mesmo documentos complexos sejam impressos com precisão e rapidez a partir de sua aplicação ASP.NET.

O IronPDF suporta diferentes configurações de impressora para impressão em PDF?

O IronPDF suporta diversas configurações de impressora, permitindo que você especifique o tamanho do papel, a orientação e a qualidade de impressão para atender às suas necessidades.

Existe alguma maneira de visualizar PDFs antes de imprimir em ASP.NET?

Com o IronPDF, você pode gerar e exibir uma pré-visualização de PDF dentro do seu aplicativo ASP.NET, permitindo que os usuários revisem o documento antes de iniciar o comando de impressão.

Quais formatos o IronPDF pode converter para PDF para impressão?

O IronPDF consegue converter uma ampla variedade de formatos para PDF para impressão, incluindo HTML, ASPX e arquivos de imagem, tornando-o versátil para diversas necessidades de aplicação.

Como o IronPDF garante a qualidade dos documentos PDF impressos?

O IronPDF utiliza tecnologia de renderização avançada para garantir que os documentos PDF impressos mantenham alta fidelidade ao conteúdo original, com texto nítido e imagens claras.

O IronPDF pode ser usado para imprimir PDFs criptografados ou protegidos por senha?

Sim, o IronPDF consegue lidar com PDFs criptografados ou protegidos por senha, permitindo que você os imprima com segurança, fornecendo as credenciais necessárias em seu aplicativo ASP.NET.

Quão fácil é integrar o IronPDF em uma aplicação ASP.NET existente?

A integração do IronPDF em uma aplicação ASP.NET existente é simples devido à sua documentação abrangente e ao suporte para diversos ambientes de desenvolvimento.

Curtis Chau
Curtis Chau
  Converse agora mesmo com a equipe de engenharia.
Redator Técnico

Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais ...

Leia mais

Artigos relacionados

Teste grátis por 30 dias → Produto completo. Sem limites. Sem cartão. Teste gratuito

Equipe de suporte de ferro

Estamos online 24 horas por dia, 5 dias por semana.
Bater papo
E-mail
Liga para mim