Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. Utilisation de IronPDF
  4. Asp .NET Print PDF
UTILISATION DE IRONPDF

Comment imprimer des fichiers PDF dans ASP.NET avec IronPDF

Curtis Chau
Curtis Chau
Mis à jour:

IronPDF permet une impression PDF fiable dans les applications ASP.NET grâce à ses fonctionnalités côté serveur et côté client. Il répond aux exigences des Enterprise , notamment en matière d'imprimantes réseau, de gestion des erreurs et de génération de documents conformes avec des pistes d'audit complètes.

Les tâches d'impression de PDF ASP.NET impliquent souvent des défis spécifiques aux architectures Enterprise . Qu'il s'agisse de générer des documents pour des factures, des rapports ou des étiquettes d'expédition, la mise en œuvre d'une fonctionnalité d'impression fiable nécessite de naviguer dans les complexités de l'architecture serveur-client tout en maintenant la conformité en matière de sécurité. La bibliothèque IronPDF offre des fonctionnalités Professional telles que les signatures numériques, le filigrane et la conformité PDF/A pour l'archivage à long terme.

Cet article explique comment gérer les tâches d'impression de fichiers PDF à l'aide de la bibliothèque PDF .NET d'IronPDF, en couvrant à la fois l'automatisation côté serveur et les flux de travail d'impression côté client. Les exemples ciblent .NET 10 avec un style d'instruction de niveau supérieur et sont écrits en C#.

Quels sont les principaux défis de l'impression PDF dans ASP.NET?

Les applications de bureau traditionnelles peuvent accéder directement à l'imprimante par défaut, mais les applications ASP.NET Core rencontrent plusieurs obstacles lors de l'impression de documents PDF. Les environnements serveur ne peuvent pas accéder directement aux imprimantes en raison des restrictions de sécurité d'IIS , et toute tentative de création de processus pour l'accès aux fichiers génère des erreurs d'autorisation. Ces contraintes sont particulièrement critiques dans les secteurs réglementés où les pistes d'audit et les contrôles d'accès doivent être maintenus. De plus, les processus du serveur Web s'exécutent généralement sous des comptes de service restreints qui n'ont pas accès aux pilotes d'imprimante physiques, ce qui rend l'impression basée sur les processus peu fiable même lorsque les tests locaux sont concluants.

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

Le code ci-dessus illustre une erreur courante. Les applications Web doivent gérer efficacement les scénarios d'impression côté serveur et côté client tout en respectant les exigences de résidence des données. IronPDF résout ce problème en fournissant une API .NET entièrement gérée qui ne dépend pas de processus externes ni de pilotes d'imprimante.

Comment installer IronPDF dans un projet ASP.NET ?

IronPDF fournit une solution .NET Core complète pour générer et imprimer des documents PDF sans dépendances externes. L'installation du package NuGet est simple pour les applications .NET Framework et .NET Core .

Installation via la console du gestionnaire de packages :

Install-Package IronPdf
Install-Package IronPdf
SHELL

Ou via le .NET CLI :

dotnet add package IronPdf
dotnet add package IronPdf
SHELL

IronPDF fonctionne sur différents systèmes d'exploitation, notamment Windows Server, les distributions Linux et les conteneurs Docker , éliminant ainsi les problèmes de compatibilité qui affectent d'autres bibliothèques. Sous macOS, la bibliothèque prend en charge nativement les processeurs Intel et Apple Silicon.

Après l'installation, ajoutez une clé de licence au démarrage pour activer l'ensemble des fonctionnalités :

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

Une licence d'essai gratuite est disponible pour évaluer toutes les fonctionnalités avant l'achat.

Comment créer et imprimer des documents PDF côté serveur ?

L'exemple suivant montre comment générer et imprimer un document PDF à partir de balises HTML dans un contrôleur ASP.NET . Le ChromePdfRenderer assure un rendu pixel-perfect avec une prise en charge CSS complète. L'utilisation de CssMediaType.Print active les feuilles de style spécifiques à l'impression définies dans votre code HTML, de sorte que le résultat corresponde exactement à ce qu'un aperçu avant impression afficherait dans un navigateur :

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

Cet exemple envoie directement le PDF rendu à l'imprimante serveur par défaut. Le ChromePdfRenderer préserve le style CSS et la mise en forme des polices. Pour les pages contenant beaucoup de JavaScript, ajoutez un délai de rendu en utilisant RenderingOptions.WaitFor pour permettre au contenu dynamique de finir de se charger avant la capture.

À quoi ressemble la sortie d'impression côté serveur ?

Boîte de dialogue

Comment configurer les imprimantes réseau dans ASP.NET?

Pour les environnements Enterprise nécessitant un routage d'imprimantes spécifique avec suivi de la conformité, IronPDF offre une gestion complète des documents imprimés. La bibliothèque prend en charge différents formats de papier et orientations de page :

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

Cette approche offre un contrôle total sur les paramètres de l'imprimante, notamment le format du papier et la résolution. La mise en œuvre comprend la gestion des erreurs et le suivi des tâches requis par les cadres de conformité. Pour l'impression à haut volume, envisagez la mise en œuvre d'un traitement asynchrone et d'une optimisation de la mémoire afin de maintenir un débit serveur élevé.

Quelles sont les considérations de sécurité relatives à l'impression réseau ?

Boîte de dialogue

Comment vérifier la réussite des impressions ?

Sortie de la console du navigateur montrant une opération d'impression réussie avec une réponse JSON contenant

Quelle est la meilleure stratégie d'impression côté client ?

Étant donné que les navigateurs restreignent l'accès direct à l'imprimante pour des raisons de sécurité, il convient de mettre en œuvre l'impression côté client en servant le fichier PDF avec les en-têtes de sécurité appropriés. IronPDF prend en charge différentes options de compression pour accélérer la transmission des fichiers. Ce modèle est idéal lorsque les utilisateurs finaux doivent choisir eux-mêmes leur destination d'impression à partir de la boîte de dialogue d'impression du navigateur :

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

Le fichier PDF s'ouvre dans le navigateur où l'utilisateur déclenche l'impression via la boîte de dialogue d'impression standard. Cette approche garantit la sécurité grâce à des politiques de sécurité du contenu et au marquage numérique, tout en préservant les ressources du serveur des dépendances liées aux pilotes d'imprimante.

Comment l'impression côté client garantit-elle la sécurité des données ?

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

Comment travaillez-vous avec plusieurs sources d'entrée ?

IronPDF gère diverses sources d'entrée tout en préservant la souveraineté des données, ce qui est important pour les développeurs qui créent des flux de travail d'impression dynamiques dans des environnements Enterprise . La bibliothèque prend en charge les fichiers HTML , les URL, les chaînes HTML et le contenu 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

Chaque méthode préserve la structure et les graphismes du document tout en maintenant la qualité d'impression. La mise en œuvre comprend l'authentification, la validation des entrées et la prise en charge du chiffrement. Pour les sources d'entrée supplémentaires, IronPDF prend en charge les fichiers DOCX, les documents RTF et les formats d'image, ce qui le rend suffisamment flexible pour servir de pipeline PDF unique pour l'ensemble d'une application.

Après le traitement des documents PDF, Windows affiche cette boîte de dialogue d'enregistrement permettant aux utilisateurs d'enregistrer le document à imprimer tout en confirmant que les documents ont été envoyés à l'imprimante par défaut.

Comment mettre en œuvre la gestion des erreurs et la journalisation ?

Une gestion fiable des erreurs est essentielle pour les environnements de production soumis à des exigences de journalisation de conformité. IronPDF propose une gestion native des exceptions et un guide de dépannage pour diagnostiquer les échecs d'impression. Un modèle d'identifiant de corrélation facilite la mise en correspondance des entrées de journal avec des demandes d'impression spécifiques lors de la consultation de l'historique d'audit :

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

Cela garantit une impression fiable même lorsque les ressources système sont indisponibles. Les identifiants de corrélation permettent de suivre les requêtes sur différents systèmes distribués et de lier les entrées de journal à des travaux d'impression spécifiques dans les journaux d'audit. Les réponses d'erreur structurées permettent également au client appelant de prendre les mesures appropriées, comme par exemple réessayer avec une imprimante de secours ou notifier l'utilisateur.

Que se passe-t-il lorsque les imprimantes sont indisponibles ?

Si l'imprimante spécifiée dans le code n'est pas disponible, le code renvoie une réponse d'erreur structurée :

Message d'erreur d'imprimante courant que les utilisateurs peuvent rencontrer lors de la tentative d'impression de documents

Comment surveiller la réussite des travaux d'impression ?

Une impression réussie renvoie un message de confirmation contenant les détails de la tâche :

Invite de commandes Windows affichant la confirmation d'impression PDF réussie pour un fichier situé dans une structure de dossiers imbriquée sur le Bureau

Quelles sont les options de configuration avancées disponibles ?

Les options de rendu d'IronPDF prennent en charge les scénarios complexes requis par les architectures Enterprise . La bibliothèque propose des paramètres d'optimisation des performances et de gestion de la mémoire lors de la génération de documents haute fidélité. Définir DpiResolution sur 300 produit une sortie de qualité d'impression adaptée aux documents physiques, tandis que l'option CssMediaType.Print active toutes les règles CSS spécifiques à l'impression dans le code HTML source :

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

Une fois généré avec toutes les configurations de sécurité appliquées, l'appel à pdf.Print() envoie le document à l'imprimante. Cette approche garantit la conformité aux normes de sécurité de Enterprise tout en préservant l'intégrité des documents grâce aux signatures numériques et au chiffrement. Pour l'archivage à long terme, envisagez la conformité au format PDF/A – une norme spécialement conçue pour les documents qui doivent rester lisibles et reproductibles pendant des décennies.

Comparaison entre l'impression côté serveur et l'impression côté client ?

Le choix entre l'impression côté serveur et l'impression côté client dépend de votre cas d'utilisation. Le tableau ci-dessous résume les principaux compromis :

Impression PDF côté serveur vs. côté client dans ASP.NET
Aspect Impression côté serveur Impression côté client
Accès à l'imprimante Imprimantes réseau et locales sur le serveur Imprimantes connectées localement par l'utilisateur
Interaction de l'utilisateur Aucun – entièrement automatisé La boîte de dialogue d'impression du navigateur apparaît
Journalisation de la conformité Journal d'audit complet côté serveur Journalisation de la console côté client uniquement
Contrôle de sécurité Le serveur applique toutes les restrictions Le navigateur applique la politique de sécurité du contenu
Meilleur pour Travaux par lots, factures, secteurs réglementés Impression à la demande déclenchée par l'utilisateur

Pour les secteurs réglementés exigeant une traçabilité complète, l'impression côté serveur est la solution privilégiée. L'impression côté client convient aux situations où les utilisateurs finaux doivent contrôler la destination d'impression.

Pourquoi choisir IronPDF pour l'impression de PDF dans ASP.NET?

IronPDF transforme l'impression PDF ASP.NET , auparavant un défi complexe, en une implémentation simple tout en respectant les normes de sécurité des Enterprise . Sans nécessiter Adobe Reader ni dépendances externes, la bibliothèque génère et imprime des fichiers PDF avec un minimum de code tout en garantissant la conformité aux normes SOC2, HIPAA et aux réglementations spécifiques à l'industrie.

L' API complète prend en charge différents formats d'entrée, des fonctionnalités d'édition, des fonctions de sécurité et des outils d'organisation pour une gestion complète des fichiers PDF. Les tutoriels complets , les exemples de code et les ressources de dépannage de la bibliothèque garantissent une intégration fluide dans l'infrastructure existante.

Pour les besoins d'impression qui vont au-delà de la génération de PDF — comme l'impression directe d'images ou de fichiers Office —, Iron Software propose également IronPrint , une bibliothèque d'impression .NET dédiée. Contrairement à IronPDF, qui se concentre sur la génération et la manipulation de contenu PDF, IronPrint est spécialisé dans l'impression directe de fichiers sans conversion intermédiaire. Selon la documentation ASP.NET de Microsoft , les opérations d'impression côté serveur sont soumises aux restrictions d'identité du pool d'applications IIS, ce qui fait d'une approche par bibliothèque le choix architectural approprié pour tout déploiement en production.

Démarrez gratuitement dès aujourd'hui grâce à l' essai gratuit et découvrez comment IronPDF simplifie le traitement des documents dans les applications ASP.NET . Grâce à une documentation complète , un support technique direct et des certifications de conformité éprouvées, l'impression de PDF prêts pour la production peut être lancée en quelques minutes. Pour en savoir plus, consultez le guide d'Iron Software sur la sécurité des documents PDF et la spécification d'accessibilité PDF du W3C .

Questions Fréquemment Posées

Comment puis-je imprimer un PDF directement à partir d'une application ASP.NET ?

Vous pouvez imprimer un PDF directement à partir d'une application ASP.NET à l'aide d'IronPDF en convertissant les fichiers HTML en PDF puis en les envoyant à une imprimante. IronPDF simplifie ce processus grâce à ses méthodes intégrées.

Quels sont les avantages de l'utilisation d'IronPDF pour l'impression de PDF en ASP.NET ?

IronPDF offre plusieurs avantages pour l'impression de PDF en ASP.NET, notamment une intégration facile, un rendu de haute qualité et la possibilité de convertir du contenu HTML en PDF avec précision.

Est-il possible de personnaliser le PDF avant l'impression à l'aide d'IronPDF ?

Oui, IronPDF vous permet de personnaliser les PDF avant de les imprimer en ajoutant des en-têtes, des pieds de page et des filigranes, ainsi qu'en définissant la taille des pages et les marges.

IronPDF peut-il gérer des fichiers PDF volumineux pour l'impression ?

IronPDF est capable de traiter efficacement des fichiers PDF volumineux, ce qui garantit que même les documents complexes sont imprimés avec précision et rapidité à partir de votre application ASP.NET.

IronPDF prend-il en charge différents paramètres d'imprimante pour l'impression de PDF ?

IronPDF prend en charge différents paramètres d'impression, ce qui vous permet de spécifier la taille du papier, l'orientation et la qualité d'impression en fonction de vos besoins.

Existe-t-il un moyen de prévisualiser les PDF avant de les imprimer en ASP.NET ?

Avec IronPDF, vous pouvez générer et afficher un aperçu PDF au sein de votre application ASP.NET, ce qui permet aux utilisateurs d'examiner le document avant de lancer la commande d'impression.

Quels formats IronPDF peut-il convertir en PDF pour l'impression ?

IronPDF peut convertir un large éventail de formats en PDF pour l'impression, y compris HTML, ASPX et les fichiers d'images, ce qui le rend polyvalent pour divers besoins d'application.

Comment IronPDF garantit-il la qualité des documents PDF imprimés ?

IronPDF utilise une technologie de rendu avancée pour s'assurer que les documents PDF imprimés conservent une grande fidélité au contenu original, avec des textes nets et des images claires.

IronPDF peut-il être utilisé pour imprimer des PDF cryptés ou protégés par un mot de passe ?

Oui, IronPDF peut gérer des PDF cryptés ou protégés par un mot de passe, ce qui vous permet de les imprimer en toute sécurité en fournissant les informations d'identification nécessaires au sein de votre application ASP.NET.

Est-il facile d'intégrer IronPDF dans une application ASP.NET existante ?

L'intégration d'IronPDF dans une application ASP.NET existante est simple grâce à sa documentation complète et à sa prise en charge de divers environnements de développement.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes
Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit

Équipe de soutien Iron

Nous sommes en ligne 24 heures sur 24, 5 jours sur 7.
Chat
Email
Appelez-moi