Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. IronPDF nutzen
  4. Asp .NET PDF drucken
IRONPDF NUTZEN

Wie man PDF-Dateien in ASP.NET mit IronPDF druckt

Curtis Chau
Curtis Chau
Aktualisiert:

IronPDF ermöglicht zuverlässiges PDF-Drucken in ASP.NET Anwendungen mit serverseitigen und clientseitigen Funktionen. Es erfüllt die Anforderungen von Enterprise , einschließlich Netzwerkdruckern, Fehlerbehandlung und der Erstellung von Compliance-konformen Dokumenten mit vollständigen Prüfprotokollen.

ASP.NET Druckaufgaben für PDFs bringen oft Herausforderungen mit sich, die spezifisch für Enterprise sind. Ob es um die Erstellung von Dokumenten für Rechnungen, Berichte oder Versandetiketten geht – die Implementierung zuverlässiger Druckfunktionen erfordert die Bewältigung der Komplexität der Server-Client-Architektur unter Einhaltung der Sicherheitsbestimmungen. Die IronPDF -Bibliothek bietet Professional Funktionen wie digitale Signaturen, Wasserzeichen und PDF/A-Konformität für die Langzeitarchivierung.

Dieser Artikel beschreibt, wie man PDF-Druckaufgaben mit der .NET PDF-Bibliothek von IronPDF handhabt und behandelt sowohl serverseitige Automatisierung als auch clientseitige Druckworkflows. Die Beispiele sind auf .NET 10 mit Top-Level-Anweisungsstil ausgerichtet und in C# geschrieben.

Was sind die wichtigsten Herausforderungen beim PDF-Druck in ASP.NET?

Herkömmliche Desktop-Anwendungen können direkt auf den Standarddrucker zugreifen, ASP.NET Core -Anwendungen stehen jedoch beim Drucken von PDF-Dokumenten vor mehreren Hürden. Serverumgebungen haben aufgrund von IIS-Sicherheitsbeschränkungen keinen direkten Zugriff auf Drucker, und der Versuch, Prozesse für den Dateizugriff zu starten, führt zu Berechtigungsfehlern. Diese Einschränkungen sind besonders wichtig in regulierten Branchen, in denen Prüfprotokolle und Zugriffskontrollen aufrechterhalten werden müssen. Darüber hinaus laufen Webserverprozesse typischerweise unter eingeschränkten Dienstkonten, die keinen Zugriff auf physische Druckertreiber haben, was prozessbasiertes Drucken unzuverlässig macht, selbst wenn lokale Tests erfolgreich verlaufen.

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

Der obige Code veranschaulicht einen häufigen Fehler. Webanwendungen müssen sowohl serverseitige als auch clientseitige Druckszenarien effektiv bewältigen und gleichzeitig die Anforderungen an die Datenresidenz erfüllen. IronPDF löst dieses Problem durch die Bereitstellung einer vollständig verwalteten .NET API, die nicht von externen Prozessen oder Druckertreibern abhängig ist.

Wie installiert man IronPDF in einem ASP.NET -Projekt?

IronPDF bietet eine vollständige .NET Core Lösung zum Generieren und Drucken von PDF-Dokumenten ohne externe Abhängigkeiten. Die Installation des NuGet Pakets ist sowohl for .NET Framework als auch for .NET Core Anwendungen unkompliziert.

Installation über die Paket-Manager-Konsole:

Install-Package IronPdf
Install-Package IronPdf
SHELL

Oder über die .NET CLI:

dotnet add package IronPdf
dotnet add package IronPdf
SHELL

IronPDF funktioniert auf verschiedenen Betriebssystemen, einschließlich Windows Server, Linux-Distributionen und Docker-Containern , wodurch die Kompatibilitätsprobleme, die andere Bibliotheken betreffen, beseitigt werden. Unter macOS unterstützt die Bibliothek sowohl Intel- als auch Apple Silicon-Prozessoren nativ.

Nach der Installation muss beim Start ein Lizenzschlüssel hinzugefügt werden, um den vollen Funktionsumfang zu aktivieren:

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

Vor dem Kauf steht eine kostenlose Testlizenz zur Verfügung, um alle Funktionen zu testen.

Wie erstellt und druckt man PDF-Dokumente serverseitig?

Das folgende Beispiel zeigt, wie man innerhalb eines ASP.NET -Controllers ein PDF-Dokument aus HTML-Markup generiert und druckt . Der ChromePdfRenderer gewährleistet eine pixelgenaue Darstellung mit voller CSS-Unterstützung. Die Verwendung von CssMediaType.Print aktiviert druckspezifische Stylesheets, die in Ihrem HTML definiert sind, sodass die Ausgabe genau dem entspricht, was eine Druckvorschau im Browser anzeigen würde:

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

Dieses Beispiel sendet die gerenderte PDF-Datei direkt an den Standarddrucker des Servers. Der ChromePdfRenderer erhält die CSS-Styling- und Schriftformatierung. Bei Seiten mit hohem JavaScript-Aufkommen fügen Sie eine Renderverzögerung mit RenderingOptions.WaitFor hinzu, damit dynamische Inhalte vor der Erfassung vollständig geladen werden können.

Wie sieht die serverseitige Druckausgabe aus?

Windows-Dialogfeld

Wie konfiguriert man Netzwerkdrucker in ASP.NET?

Für Enterprise , die eine spezifische Druckerweiterleitung mit Compliance-Überwachung erfordern, bietet IronPDF ein umfassendes Druckdokumentenmanagement. Die Bibliothek unterstützt verschiedene Papierformate und Seitenausrichtungen:

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

Dieser Ansatz ermöglicht die vollständige Kontrolle über die Druckereinstellungen, einschließlich Papierformat und Auflösung. Die Implementierung umfasst die für Compliance-Rahmenwerke erforderliche Fehlerbehandlung und Auftragsverfolgung. Für Druckaufträge mit hohem Volumen empfiehlt sich die Implementierung asynchroner Verarbeitung und Speicheroptimierung, um einen hohen Serverdurchsatz zu gewährleisten.

Welche Sicherheitsaspekte sind beim Netzwerkdruck zu beachten?

Windows-Dialogfeld

Wie überprüft man erfolgreiche Druckaufträge?

Browserkonsolenausgabe, die einen erfolgreichen Druckvorgang mit einer JSON-Antwort anzeigt, die 'success: true' und die Bestätigungsmeldung enthält, dass das Dokument an Microsoft Print to PDF gesendet wurde

Was ist die beste clientseitige Druckstrategie?

Da Browser aus Sicherheitsgründen den direkten Zugriff auf Drucker einschränken, implementieren Sie clientseitiges Drucken, indem Sie die PDF-Datei mit entsprechenden Sicherheitsheadern bereitstellen. IronPDF unterstützt verschiedene Komprimierungsoptionen, um die Dateiübertragung zu beschleunigen. Dieses Muster ist ideal, wenn Endbenutzer im Druckdialog des Browsers ihr Druckziel selbst auswählen müssen:

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

Die PDF-Datei öffnet sich im Browser, wo der Benutzer den Druckvorgang über den Standard-Druckdialog auslöst. Dieser Ansatz gewährleistet die Sicherheit durch Content-Security-Richtlinien und Wasserzeichen und hält gleichzeitig die Serverressourcen frei von Abhängigkeiten von Druckertreibern.

Wie gewährleistet clientseitiges Drucken die Datensicherheit?

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

Wie arbeitet man mit mehreren Eingangsquellen?

IronPDF verarbeitet verschiedene Eingabequellen unter Wahrung der Datensouveränität – wichtig für Entwickler, die dynamische Druckworkflows in Enterprise erstellen. Die Bibliothek unterstützt HTML-Dateien , URLs, HTML-Zeichenketten und Markdown-Inhalte:

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

Bei beiden Methoden bleiben Dokumentstruktur und Grafiken erhalten, während gleichzeitig die Druckqualität gewährleistet wird. Die Implementierung umfasst Authentifizierung, Eingabevalidierung und Unterstützung für Verschlüsselung. Für zusätzliche Eingabequellen unterstützt IronPDF DOCX-Dateien, RTF-Dokumente und Bildformate – wodurch es flexibel genug ist, um als einheitliche PDF-Pipeline für eine gesamte Anwendung zu dienen.

Nach der Verarbeitung von PDF-Dokumenten zeigt Windows diesen Speicherdialog an, in dem Benutzer die Druckausgabe speichern und gleichzeitig bestätigen können, dass die Dokumente an den Standarddrucker gesendet wurden.

Wie implementiert man Fehlerbehandlung und Protokollierung?

Eine zuverlässige Fehlerbehandlung ist für Produktionsumgebungen mit Compliance-Protokollierungsanforderungen unerlässlich. IronPDF bietet eine integrierte Ausnahmebehandlung und einen Leitfaden zur Fehlerbehebung bei Druckfehlern. Ein Korrelations-ID-Muster vereinfacht die Zuordnung von Protokolleinträgen zu bestimmten Druckanforderungen bei der Überprüfung des Prüfverlaufs:

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

Dies gewährleistet zuverlässiges Drucken auch dann, wenn Systemressourcen nicht verfügbar sind. Korrelations-IDs ermöglichen es Ihnen, Anfragen über verteilte Systeme hinweg zu verfolgen und Protokolleinträge mit bestimmten Druckaufträgen in Prüfprotokollen zu verknüpfen. Die strukturierten Fehlerantworten ermöglichen es dem aufrufenden Client außerdem, geeignete Maßnahmen zu ergreifen – wie beispielsweise einen erneuten Versuch mit einem Ausweichdrucker oder die Benachrichtigung des Benutzers.

Was passiert, wenn Drucker nicht verfügbar sind?

Wenn der im Code angegebene Drucker nicht verfügbar ist, gibt der Code eine strukturierte Fehlerantwort zurück:

Eine häufige Druckerfehlermeldung, die Benutzern beim Drucken von Dokumenten begegnen kann

Wie überwacht man erfolgreiche Druckaufträge?

Bei einem erfolgreichen Druckauftrag wird eine Bestätigungsnachricht mit den Auftragsdetails zurückgegeben:

Windows-Eingabeaufforderung zeigt erfolgreiche PDF-Druckbestätigung für eine Datei in einer verschachtelten Desktop-Ordnerstruktur an

Welche erweiterten Konfigurationsoptionen stehen zur Verfügung?

Die Rendering-Optionen von IronPDF unterstützen komplexe Szenarien, die von Enterprise benötigt werden. Die Bibliothek bietet Einstellungen zur Leistungsoptimierung und Speicherverwaltung bei der Generierung hochauflösender Dokumente. Die Einstellung von DpiResolution auf 300 erzeugt eine für physische Dokumente geeignete Druckqualität, während die Option CssMediaType.Print alle druckspezifischen CSS-Regeln im Quell-HTML aktiviert:

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

Sobald alle Sicherheitskonfigurationen angewendet wurden, sendet der Aufruf von pdf.Print() das Dokument an den Drucker. Dieser Ansatz gewährleistet die Einhaltung der Sicherheitsstandards des Enterprise und erhält gleichzeitig die Dokumentenintegrität durch digitale Signaturen und Verschlüsselung aufrecht. Für die Langzeitarchivierung empfiehlt sich die Einhaltung des PDF/A-Standards – ein Standard, der speziell für Dokumente entwickelt wurde, die über Jahrzehnte lesbar und reproduzierbar bleiben müssen.

Wie unterscheiden sich serverseitiges und clientseitiges Drucken?

Die Wahl zwischen serverseitigem und clientseitigem Drucken hängt von Ihrem Anwendungsfall ab. Die folgende Tabelle fasst die wichtigsten Abwägungen zusammen:

Serverseitiger vs. clientseitiger PDF-Druck in ASP.NET
Aspekt Serverseitiges Drucken Clientseitiger Druck
Druckerzugriff Netzwerk- und lokale Drucker auf dem Server Lokal angeschlossene Drucker des Benutzers
Benutzerinteraktion Keine – vollautomatisiert Der Druckdialog des Browsers wird angezeigt
Protokollierung der Einhaltung der Vorschriften Vollständiges serverseitiges Prüfprotokoll Nur clientseitiges Konsolenprotokoll
Sicherheitskontrolle Der Server setzt alle Beschränkungen durch. Der Browser erzwingt die Inhaltssicherheitsrichtlinie
Am besten geeignet für Stapelverarbeitung, Rechnungen, regulierte Branchen vom Benutzer ausgelöster Druck auf Abruf

Für regulierte Branchen, die dokumentierte Prüfprotokolle erfordern, ist serverseitiges Drucken die bevorzugte Option. Clientseitiges Drucken eignet sich für Szenarien, in denen Endbenutzer die Kontrolle über das Druckziel benötigen.

Warum IronPDF für den PDF-Druck in ASP.NET wählen?

IronPDF macht das Drucken von ASP.NET PDFs von einer komplexen Herausforderung zu einer unkomplizierten Implementierung und wahrt dabei gleichzeitig die Sicherheitsstandards von Enterprise . Ohne die Notwendigkeit von Adobe Reader oder externen Abhängigkeiten generiert und druckt die Bibliothek PDF-Dateien mit minimalem Codeaufwand und gewährleistet gleichzeitig die Einhaltung von SOC2, HIPAA und branchenspezifischen Vorschriften.

Die vollständige API unterstützt verschiedene Eingabeformate, Bearbeitungsfunktionen, Sicherheitsfunktionen und Organisationswerkzeuge für die umfassende PDF-Verwaltung. Die umfangreichen Tutorials , Codebeispiele und Ressourcen zur Fehlerbehebung der Bibliothek gewährleisten eine reibungslose Integration in die bestehende Infrastruktur.

Für Druckanforderungen, die über die PDF-Erstellung hinausgehen – wie beispielsweise das direkte Drucken von Bildern oder Office-Dateien – bietet Iron Software auch IronPrint an, eine spezielle .NET Druckbibliothek. Im Gegensatz zu IronPDF, das sich auf die Erstellung und Bearbeitung von PDF-Inhalten konzentriert, ist IronPrint auf den direkten Dateidruck ohne Zwischenkonvertierung spezialisiert. Laut der ASP.NET Dokumentation von Microsoft unterliegen serverseitige Druckvorgänge den Identitätsbeschränkungen des IIS-Anwendungspools. Daher ist ein Bibliotheksansatz die richtige architektonische Wahl für jede Produktionsbereitstellung.

Starten Sie noch heute kostenlos mit der Testversion und erleben Sie, wie IronPDF die Dokumentenverarbeitung in ASP.NET -Anwendungen vereinfacht. Dank vollständiger Dokumentation , direkter technischer Unterstützung und nachgewiesener Konformitätszertifizierungen kann der produktionsreife PDF-Druck innerhalb weniger Minuten gestartet werden. Weiterführende Informationen finden Sie im Leitfaden von Iron Software zur Sicherheit von PDF-Dokumenten und in der W3C-Spezifikation zur PDF-Barrierefreiheit .

Häufig gestellte Fragen

Wie kann ich eine PDF-Datei direkt aus einer ASP.NET-Anwendung drucken?

Mit IronPDF können Sie eine PDF-Datei direkt aus einer ASP.NET-Anwendung drucken, indem Sie HTML-Dateien in PDF-Dateien konvertieren und diese dann an einen Drucker senden. IronPDF vereinfacht diesen Prozess mit seinen integrierten Methoden.

Welche Vorteile bietet IronPDF für den Druck von PDF-Dateien in ASP.NET?

IronPDF bietet mehrere Vorteile für das Drucken von PDFs in ASP.NET, darunter eine einfache Integration, qualitativ hochwertiges Rendering und die Möglichkeit, HTML-Inhalte präzise in PDF zu konvertieren.

Ist es möglich, die PDF-Datei vor dem Druck mit IronPDF anzupassen?

Ja, IronPDF ermöglicht es Ihnen, PDFs vor dem Druck anzupassen, indem Sie Kopf- und Fußzeilen sowie Wasserzeichen hinzufügen und Seitengrößen und -ränder festlegen.

Kann IronPDF große PDF-Dateien für den Druck verarbeiten?

IronPDF ist in der Lage, große PDF-Dateien effizient zu verarbeiten und stellt sicher, dass selbst komplexe Dokumente aus Ihrer ASP.NET-Anwendung präzise und schnell gedruckt werden.

Unterstützt IronPDF verschiedene Druckereinstellungen für den PDF-Druck?

IronPDF unterstützt verschiedene Druckereinstellungen, mit denen Sie Papiergröße, Ausrichtung und Druckqualität Ihren Bedürfnissen entsprechend festlegen können.

Gibt es eine Möglichkeit, PDFs vor dem Drucken in ASP.NET in der Vorschau anzuzeigen?

Mit IronPDF können Sie innerhalb Ihrer ASP.NET-Anwendung eine PDF-Vorschau generieren und anzeigen, so dass Benutzer das Dokument überprüfen können, bevor sie den Druckbefehl auslösen.

Welche Formate kann IronPDF für den Druck in PDF konvertieren?

IronPDF kann eine Vielzahl von Formaten für den Druck in das PDF-Format konvertieren, darunter HTML, ASPX und Bilddateien, und ist somit vielseitig einsetzbar.

Wie gewährleistet IronPDF die Qualität der gedruckten PDF-Dokumente?

IronPDF verwendet fortschrittliche Rendering-Technologien, um sicherzustellen, dass die gedruckten PDF-Dokumente eine hohe Wiedergabetreue zum Originalinhalt aufweisen, mit scharfem Text und klaren Bildern.

Kann IronPDF verwendet werden, um verschlüsselte oder passwortgeschützte PDF-Dateien zu drucken?

Ja, IronPDF kann verschlüsselte oder passwortgeschützte PDFs verarbeiten, so dass Sie sie sicher drucken können, indem Sie die erforderlichen Anmeldeinformationen innerhalb Ihrer ASP.NET-Anwendung angeben.

Wie einfach ist es, IronPDF in eine bestehende ASP.NET-Anwendung zu integrieren?

Die Integration von IronPDF in eine bestehende ASP.NET-Anwendung ist aufgrund der umfassenden Dokumentation und der Unterstützung für verschiedene Entwicklungsumgebungen problemlos möglich.

Curtis Chau
Curtis Chau
  Jetzt mit dem Ingenieurteam chatten
Technischer Autor

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender ...

Weiterlesen

Verwandte Artikel
30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen

Iron Support Team

Wir sind 24 Stunden am Tag, 5 Tage die Woche online.
Chat
E-Mail
Rufen Sie mich an