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

Wie man einen ASP.NET Core PDF-Viewer mit IronPDF erstellt

Curtis Chau
Curtis Chau
Aktualisiert:

Das direkte Anzeigen von PDF-Dokumenten in einem Webbrowser ist eine gängige Anforderung für moderne ASP.NET Core Anwendungen. Egal ob Rechnungen, Berichte oder Verträge erstellt werden, Benutzer erwarten ein reibungsloses PDF-Anzeigeerlebnis ohne Herunterladen von Dateien oder Installation von Drittanbieter-Plugins wie Adobe Acrobat Reader. IronPDF macht dies unkompliziert, indem es die PDF-Generierung serverseitig und das Streaming über eine Chrome-basierte Rendering-Engine ermöglicht – es sind keine externen Viewer-Abhängigkeiten erforderlich.

Dieses Tutorial führt Sie durch die Schritte zum Anzeigen, Speichern und Drucken von PDF-Dateien in ASP.NET Core mit IronPDF. Sie erfahren außerdem, wie die Bibliothek Container- und Cloud-Bereitstellungen handhabt, was sie zu einer zuverlässigen Wahl für produktive DevOps-Pipelines macht.

IronPDF C# PDF-Bibliothek – Werbebanner mit Hervorhebung der HTML-zu-PDF-Konvertierung, Bearbeitungswerkzeuge, flexibler Einsatzmöglichkeiten und kostenlosem Testangebot

Wie zeigen Browser PDF-Dateien direkt im Browser an?

Moderne Browser verfügen über integrierte PDF-Viewer, die aktiviert werden, wenn eine Antwort mit dem MIME-Typ application/pdf empfangen wird. Wenn Ihr ASP.NET Core Controller ein PDF mit dem korrekten Content-Type-Header zurückgibt, rendert der Browser es automatisch inline – es ist keine Plugin-Installation erforderlich. Laut MDN Web Docs ist die korrekte Konfiguration des MIME-Typs entscheidend dafür, wie Browser mit Dateiantworten umgehen.

IronPDF generiert PDFs serverseitig mithilfe seiner Klasse ChromePdfRenderer, die eine vollständige Chromium-Engine einbettet. Das bedeutet, dass Dokumente mit vollständiger Unterstützung für CSS, JavaScript, Webfonts und digitale Signaturen gerendert werden – dieselbe Rendering-Pipeline, die auch Google Chrome antreibt. Das Ergebnis ist eine pixelgenaue Ausgabe, die Browser ohne clientseitige Viewer-Bibliothek direkt im Browser anzeigen.

Für containerisierte Umgebungen ist diese Architektur besonders wertvoll. Der Renderer läuft vollständig im selben Prozess, ohne externe Headless-Browserprozesse zu erzeugen oder auf Remote-Dienste zurückzugreifen. Die Ressourcenbereinigung erfolgt automatisch und verhindert so Speicherlecks in langlaufenden ASP.NET Core Diensten. Sie können sich den vollständigen Funktionsumfang von IronPDF ansehen, um die gesamten verfügbaren Rendering-Funktionen kennenzulernen.

Vierspaltige Funktionsübersicht mit den Funktionen der PDF-Software: PDFs erstellen, PDFs konvertieren, PDFs bearbeiten sowie PDFs signieren und sichern, mit detaillierten Funktionslisten unter jeder Kategorie

Warum liefert serverseitiges Rendering konsistente Ergebnisse?

Serverseitiges Rendering eliminiert Browserabhängigkeiten im PDF-Generierungsprozess. Wenn PDFs clientseitig generiert werden, hängt die Ausgabequalität von der Browserversion, dem Betriebssystem und den installierten Schriftarten des Endbenutzers ab. Mit IronPDF läuft auf jedem Server – egal ob Windows, Linux oder Docker-Container – dieselbe Chromium-Engine, wodurch eine identische Ausgabe für Compliance-Dokumente, Rechnungen und unterzeichnete Verträge gewährleistet wird.

Was bietet die Chrome-Engine gegenüber einfachen HTML-zu-PDF-Konvertern?

Einfache HTML-zu-PDF-Konverter lassen oft die JavaScript Ausführung aus, ignorieren CSS-Media-Queries oder erzeugen eine schlechte Typografie. Die Chrome-Engine von IronPDF wartet auf die Fertigstellung von JavaScript , berücksichtigt @media print-Stile, verarbeitet SVG-Grafiken und unterstützt die UTF-8-Zeichenkodierung für internationale Inhalte. Diese Wiedergabetreue ist wichtig, wenn Dokumente angezeigt werden, die Benutzer auch ausdrucken oder archivieren werden.

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

Zum Erstellen eines neuen ASP.NET Core -Projekts ist nur ein Befehl erforderlich. Öffnen Sie ein Terminal und führen Sie folgenden Befehl aus:

dotnet new mvc -n PdfViewerApp
cd PdfViewerApp
dotnet new mvc -n PdfViewerApp
cd PdfViewerApp
SHELL

Installieren Sie anschließend das IronPDF NuGet Paket . Sie können entweder die Paket-Manager-Konsole oder die .NET -Befehlszeilenschnittstelle verwenden:

Install-Package IronPdf
dotnet add package IronPdf
Install-Package IronPdf
dotnet add package IronPdf
SHELL

Damit wird alles Notwendige installiert – die Chrome-Engine, PDF-Verarbeitungsbibliotheken und alle plattformspezifischen Abhängigkeiten. IronPDF unterstützt .NET 6, 7, 8, 9 und 10 ohne zusätzliche Framework-Konfiguration. Die IronPDF Dokumentation behandelt erweiterte Installationsoptionen, darunter schlanke Pakete für größenbeschränkte Bereitstellungen wie AWS Lambda .

Die Visual Studio Package Manager Console zeigt den Installationsfortschritt des IronPDF NuGet Pakets an und zeigt mehrere Abhängigkeits-Downloads, darunter Iron Software Komponenten, gRPC und System.Threading.Channels

Welche Paketvariante sollten Sie wählen?

Für Standardeinsätze verwenden Sie IronPdf. Für Umgebungen mit strengen Größenbeschränkungen – wie beispielsweise AWS Lambda oder Edge-Funktionen – reduziert das Paket IronPdf.Slim den anfänglichen Download-Aufwand. Beide Varianten bieten die gleiche API, sodass beim Wechsel keine Codeänderungen erforderlich sind.

Welche Installationsprobleme treten häufig in Containerumgebungen auf?

Linux-Container benötigen manchmal zusätzliche Systembibliotheken für Grafikoperationen. Ein minimales Dockerfile-Setup umfasst:

apt-get update && apt-get install -y libgdiplus libc6-dev libx11-dev
apt-get update && apt-get install -y libgdiplus libc6-dev libx11-dev
SHELL

Windows-Container funktionieren typischerweise ohne zusätzliche Abhängigkeiten. Zur Fehlerbehebung sollten Sie die integrierte Protokollierung von IronPDF aktivieren, um Darstellungsfehler zu erfassen, bevor diese als HTTP-500-Antworten auftreten.

Wie kann man eine PDF-Datei direkt im Browser anzeigen?

Um eine PDF-Datei zur Anzeige im Browser zurückzugeben, sind drei Dinge erforderlich: die PDF-Datei generieren, den MIME-Typ festlegen und den Parameter filename aus dem Ergebnis weglassen. Hier ist eine vollständige Controller-Aktion:

using IronPdf;
using Microsoft.AspNetCore.Mvc;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();
var app = builder.Build();
app.MapControllerRoute(name: "default", pattern: "{controller=Home}/{action=Index}/{id?}");
app.Run();

// PdfController.cs
public class PdfController : Controller
{
    public IActionResult ViewPdf()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PrintHtmlBackgrounds = true;
        renderer.RenderingOptions.CreatePdfFormsFromHtml = true;
        renderer.RenderingOptions.EnableJavaScript = true;
        renderer.RenderingOptions.RenderDelay = 100;

        var html = @"
            <html>
            <head>
                <style>
                    body { font-family: Arial, sans-serif; padding: 20px; }
                    h1 { color: #2c3e50; }
                    .content { line-height: 1.6; }
                </style>
            </head>
            <body>
                <h1>Invoice #12345</h1>
                <div class='content'>
                    <p>Date: " + DateTime.Now.ToString("yyyy-MM-dd") + @"</p>
                    <p>Thank you for your business!</p>
                </div>
            </body>
            </html>";

        var pdf = renderer.RenderHtmlAsPdf(html);

        // Omitting the filename tells the browser to display inline
        return File(pdf.BinaryData, "application/pdf");
    }
}
using IronPdf;
using Microsoft.AspNetCore.Mvc;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();
var app = builder.Build();
app.MapControllerRoute(name: "default", pattern: "{controller=Home}/{action=Index}/{id?}");
app.Run();

// PdfController.cs
public class PdfController : Controller
{
    public IActionResult ViewPdf()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PrintHtmlBackgrounds = true;
        renderer.RenderingOptions.CreatePdfFormsFromHtml = true;
        renderer.RenderingOptions.EnableJavaScript = true;
        renderer.RenderingOptions.RenderDelay = 100;

        var html = @"
            <html>
            <head>
                <style>
                    body { font-family: Arial, sans-serif; padding: 20px; }
                    h1 { color: #2c3e50; }
                    .content { line-height: 1.6; }
                </style>
            </head>
            <body>
                <h1>Invoice #12345</h1>
                <div class='content'>
                    <p>Date: " + DateTime.Now.ToString("yyyy-MM-dd") + @"</p>
                    <p>Thank you for your business!</p>
                </div>
            </body>
            </html>";

        var pdf = renderer.RenderHtmlAsPdf(html);

        // Omitting the filename tells the browser to display inline
        return File(pdf.BinaryData, "application/pdf");
    }
}
Imports IronPdf
Imports Microsoft.AspNetCore.Mvc

Dim builder = WebApplication.CreateBuilder(args)
builder.Services.AddControllersWithViews()
Dim app = builder.Build()
app.MapControllerRoute(name:="default", pattern:="{controller=Home}/{action=Index}/{id?}")
app.Run()

' PdfController.vb
Public Class PdfController
    Inherits Controller

    Public Function ViewPdf() As IActionResult
        Dim renderer = New ChromePdfRenderer()
        renderer.RenderingOptions.PrintHtmlBackgrounds = True
        renderer.RenderingOptions.CreatePdfFormsFromHtml = True
        renderer.RenderingOptions.EnableJavaScript = True
        renderer.RenderingOptions.RenderDelay = 100

        Dim html = "
            <html>
            <head>
                <style>
                    body { font-family: Arial, sans-serif; padding: 20px; }
                    h1 { color: #2c3e50; }
                    .content { line-height: 1.6; }
                </style>
            </head>
            <body>
                <h1>Invoice #12345</h1>
                <div class='content'>
                    <p>Date: " & DateTime.Now.ToString("yyyy-MM-dd") & "</p>
                    <p>Thank you for your business!</p>
                </div>
            </body>
            </html>"

        Dim pdf = renderer.RenderHtmlAsPdf(html)

        ' Omitting the filename tells the browser to display inline
        Return File(pdf.BinaryData, "application/pdf")
    End Function
End Class
$vbLabelText   $csharpLabel

Der Schlüssel liegt im Aufruf File(): Die Rückgabe von application/pdf ohne Dateinamen setzt Content-Disposition: inline, wodurch der im Browser integrierte PDF-Viewer ausgelöst wird. Durch Hinzufügen eines Dateinamens wird auf Content-Disposition: attachment umgeschaltet, wodurch ein Download ausgelöst wird. Weitere Beispiele für HTML-Konvertierungsmuster finden Sie im Leitfaden zur Umwandlung von HTML-Zeichenketten in PDFs .

Bei Anwendungen mit hohem Datenverkehr sollten Sie die asynchrone Rendering-Methode verwenden, um blockierende Threads zu vermeiden:

public async Task<IActionResult> ViewPdfAsync()
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.Timeout = 60;

    var html = await GetHtmlContentAsync();
    var pdf = await renderer.RenderHtmlAsPdfAsync(html);

    return File(pdf.BinaryData, "application/pdf");
}
public async Task<IActionResult> ViewPdfAsync()
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.Timeout = 60;

    var html = await GetHtmlContentAsync();
    var pdf = await renderer.RenderHtmlAsPdfAsync(html);

    return File(pdf.BinaryData, "application/pdf");
}
Imports System.Threading.Tasks

Public Async Function ViewPdfAsync() As Task(Of IActionResult)
    Dim renderer = New ChromePdfRenderer()
    renderer.RenderingOptions.Timeout = 60

    Dim html = Await GetHtmlContentAsync()
    Dim pdf = Await renderer.RenderHtmlAsPdfAsync(html)

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

Beispiel einer einfachen PDF-Rechnung, angezeigt in einem webbasierten PDF-Viewer mit Standard-Navigationssteuerelementen

Wann sollte man die asynchrone PDF-Generierung verwenden?

Die asynchrone Generierung ist für jeden Endpunkt wichtig, der gleichzeitige Anfragen empfängt. Die synchrone Generierung blockiert die Threads des ASP.NET Core -Threadpools und reduziert so die Anzahl der gleichzeitigen Anfragen, die Ihre Anwendung bearbeiten kann. Wechseln Sie frühzeitig zu asynchronen Methoden – die API-Oberfläche ist identisch, daher ist die Migration unkompliziert.

Welche anderen HTML-Quellen können Sie rendern?

Neben HTML-Zeichenketten kann IronPDF auch Inhalte aus URLs, HTML-Dateien auf der Festplatte und Razor Ansichten rendern. Der Aufruf von renderer.RenderUrlAsPdf("https://example.com/report") erfasst eine Live-URL, während renderer.RenderHtmlFileAsPdf("wwwroot/templates/invoice.html") aus dem lokalen Dateisystem liest. Diese Flexibilität bedeutet, dass Sie bestehende Razor Vorlagen als PDF-Vorlagen wiederverwenden können, ohne separate HTML-Dateien pflegen zu müssen. Der Eintrag in der NuGet Gallery für IronPDF zeigt die aktuelle Paketversion und die Versionshinweise an.

Wie aktiviert man PDF-Datei-Downloads in ASP.NET Core?

Das Auslösen eines Dateidownloads anstelle der Inline-Anzeige erfordert eine Änderung eines einzigen Parameters. Durch Hinzufügen eines Dateinamens zum Ergebnis File() wird der Header Content-Disposition auf attachment gesetzt:

public IActionResult DownloadPdf()
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.ImageQuality = 85;

    var html = @"<h1>Quarterly Report</h1>
                 <p>Revenue this quarter exceeded projections by 12%.</p>";
    var pdf = renderer.RenderHtmlAsPdf(html, @"wwwroot/images");

    // Compress images to reduce download size
    pdf.CompressImages(30);

    // The filename parameter triggers download instead of inline view
    return File(pdf.BinaryData, "application/pdf", "quarterly-report-2026.pdf");
}
public IActionResult DownloadPdf()
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.ImageQuality = 85;

    var html = @"<h1>Quarterly Report</h1>
                 <p>Revenue this quarter exceeded projections by 12%.</p>";
    var pdf = renderer.RenderHtmlAsPdf(html, @"wwwroot/images");

    // Compress images to reduce download size
    pdf.CompressImages(30);

    // The filename parameter triggers download instead of inline view
    return File(pdf.BinaryData, "application/pdf", "quarterly-report-2026.pdf");
}
Public Function DownloadPdf() As IActionResult
    Dim renderer = New ChromePdfRenderer()
    renderer.RenderingOptions.ImageQuality = 85

    Dim html As String = "<h1>Quarterly Report</h1>
                          <p>Revenue this quarter exceeded projections by 12%.</p>"
    Dim pdf = renderer.RenderHtmlAsPdf(html, "wwwroot/images")

    ' Compress images to reduce download size
    pdf.CompressImages(30)

    ' The filename parameter triggers download instead of inline view
    Return File(pdf.BinaryData, "application/pdf", "quarterly-report-2026.pdf")
End Function
$vbLabelText   $csharpLabel

Bei großen Dokumenten, die vielen Benutzern bereitgestellt werden, reduziert Streaming die maximale Speicherauslastung:

public IActionResult StreamPdf()
{
    var renderer = new ChromePdfRenderer();
    var html = "<h1>Large Report</h1><p>Content spanning many pages.</p>";
    var pdf = renderer.RenderHtmlAsPdf(html);

    var stream = pdf.Stream;
    stream.Position = 0;

    // Stream directly without buffering the full byte array
    return File(stream, "application/pdf", "report.pdf");
}
public IActionResult StreamPdf()
{
    var renderer = new ChromePdfRenderer();
    var html = "<h1>Large Report</h1><p>Content spanning many pages.</p>";
    var pdf = renderer.RenderHtmlAsPdf(html);

    var stream = pdf.Stream;
    stream.Position = 0;

    // Stream directly without buffering the full byte array
    return File(stream, "application/pdf", "report.pdf");
}
Imports IronPdf

Public Function StreamPdf() As IActionResult
    Dim renderer As New ChromePdfRenderer()
    Dim html As String = "<h1>Large Report</h1><p>Content spanning many pages.</p>"
    Dim pdf = renderer.RenderHtmlAsPdf(html)

    Dim stream = pdf.Stream
    stream.Position = 0

    ' Stream directly without buffering the full byte array
    Return File(stream, "application/pdf", "report.pdf")
End Function
$vbLabelText   $csharpLabel

Streaming sendet PDF-Daten progressiv, was die maximale Speicherauslastung beim Bereitstellen großer Dateien für gleichzeitige Benutzer deutlich reduziert. Weitere Exportmuster finden Sie im Leitfaden zum Zusammenführen und Aufteilen von PDFs sowie zum Extrahieren von Text aus PDFs .

Beispiel eines mit IronPDF for .NET erstellten PDF-Dokuments, angezeigt in einer Standard-PDF-Viewer-Oberfläche

Welche Komprimierungseinstellungen eignen sich am besten für verschiedene Dokumenttypen?

Textreiche PDFs lassen sich bei 70-80 % Bildqualität mit minimalen visuellen Auswirkungen gut komprimieren. Bildreiche Dokumente wie Marketingbroschüren benötigen eine Qualität von 85-95 %, um die Klarheit zu gewährleisten. Finanzberichte mit Diagrammen sollten einen Wert von mindestens 85 % aufweisen, um die Lesbarkeit der Diagramme zu gewährleisten. Testen Sie die Komprimierungswerte anhand repräsentativer Dokumente, bevor Sie die Software in der Produktionsumgebung einsetzen.

Wie generiert man druckfertige PDFs in ASP.NET Core?

Druckfertige PDFs erfordern eine spezifische Seitenkonfiguration: CSS-Medientyp für den Druck, definierte Ränder und explizites Papierformat. IronPDF stellt all dies über RenderingOptions bereit:

public IActionResult PrintablePdf()
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
    renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait;
    renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
    renderer.RenderingOptions.MarginTop = 25;
    renderer.RenderingOptions.MarginBottom = 25;
    renderer.RenderingOptions.MarginLeft = 25;
    renderer.RenderingOptions.MarginRight = 25;

    // Add headers and footers for professional print output
    renderer.RenderingOptions.TextHeader = new TextHeaderFooter
    {
        CenterText = "Confidential Document",
        DrawDividerLine = true
    };
    renderer.RenderingOptions.TextFooter = new TextHeaderFooter
    {
        CenterText = "Page {page} of {total-pages}",
        FontSize = 10
    };

    var html = @"
        <style>
            @media print {
                .no-print { display: none; }
                .page-break { page-break-after: always; }
            }
        </style>
        <h1>Print-Ready Document</h1>
        <p>This document is formatted for A4 printing with standard margins.</p>
        <div class='page-break'></div>
        <h2>Page 2</h2>
        <p>Content continues on the second page.</p>";

    var pdf = renderer.RenderHtmlAsPdf(html);
    return File(pdf.BinaryData, "application/pdf");
}
public IActionResult PrintablePdf()
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
    renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait;
    renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
    renderer.RenderingOptions.MarginTop = 25;
    renderer.RenderingOptions.MarginBottom = 25;
    renderer.RenderingOptions.MarginLeft = 25;
    renderer.RenderingOptions.MarginRight = 25;

    // Add headers and footers for professional print output
    renderer.RenderingOptions.TextHeader = new TextHeaderFooter
    {
        CenterText = "Confidential Document",
        DrawDividerLine = true
    };
    renderer.RenderingOptions.TextFooter = new TextHeaderFooter
    {
        CenterText = "Page {page} of {total-pages}",
        FontSize = 10
    };

    var html = @"
        <style>
            @media print {
                .no-print { display: none; }
                .page-break { page-break-after: always; }
            }
        </style>
        <h1>Print-Ready Document</h1>
        <p>This document is formatted for A4 printing with standard margins.</p>
        <div class='page-break'></div>
        <h2>Page 2</h2>
        <p>Content continues on the second page.</p>";

    var pdf = renderer.RenderHtmlAsPdf(html);
    return File(pdf.BinaryData, "application/pdf");
}
Imports System.Web.Mvc

Public Function PrintablePdf() As ActionResult
    Dim renderer = New ChromePdfRenderer()
    renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print
    renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait
    renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
    renderer.RenderingOptions.MarginTop = 25
    renderer.RenderingOptions.MarginBottom = 25
    renderer.RenderingOptions.MarginLeft = 25
    renderer.RenderingOptions.MarginRight = 25

    ' Add headers and footers for professional print output
    renderer.RenderingOptions.TextHeader = New TextHeaderFooter With {
        .CenterText = "Confidential Document",
        .DrawDividerLine = True
    }
    renderer.RenderingOptions.TextFooter = New TextHeaderFooter With {
        .CenterText = "Page {page} of {total-pages}",
        .FontSize = 10
    }

    Dim html = "
        <style>
            @media print {
                .no-print { display: none; }
                .page-break { page-break-after: always; }
            }
        </style>
        <h1>Print-Ready Document</h1>
        <p>This document is formatted for A4 printing with standard margins.</p>
        <div class='page-break'></div>
        <h2>Page 2</h2>
        <p>Content continues on the second page.</p>"

    Dim pdf = renderer.RenderHtmlAsPdf(html)
    Return File(pdf.BinaryData, "application/pdf")
End Function
$vbLabelText   $csharpLabel

Durch Setzen von CssMediaType.Print werden die CSS-Regeln @media print vor dem Rendern aktiviert. Dadurch werden Navigationsleisten, Seitenleisten und andere Elemente, die nur auf dem Bildschirm sichtbar sind, ausgeblendet. Anschließend können die Benutzer die PDF-Datei über den im Browser integrierten Viewer mithilfe gängiger Tastenkombinationen ausdrucken und haben dabei die volle Kontrolle über die Druckerauswahl und die Anzahl der Kopien. Erweiterte Kopf- und Fußzeilenmuster finden Sie im Leitfaden für Kopf- und Fußzeilen .

Sie können gedruckten Dokumenten auch Wasserzeichen hinzufügen, sie vor der Zustellung digital signieren oder sie mit Passwort- und Berechtigungseinstellungen schützen. Diese Funktionen integrieren sich direkt über die PdfDocument API, ohne dass ein separater Verarbeitungsschritt erforderlich ist.

Beispiel eines druckfertigen PDF-Dokuments, wie es in einem Standard-PDF-Viewer angezeigt wird und die charakteristische Formatierung für den Druck zeigt

Welche Seitenkonfiguration gewährleistet die Kompatibilität zwischen verschiedenen Druckern?

Standardmäßige A4- oder Letter-Formate mit 20-25 mm Rändern funktionieren zuverlässig mit allen Druckermodellen. Vermeiden Sie benutzerdefinierte Papierformate, es sei denn, die Bereitstellung zielt auf eine bekannte Druckerflotte ab. Verwenden Sie die CSS-Eigenschaften page-break-before und page-break-after anstelle proprietärer Seitenumbruchmethoden. Die W3C CSS Paged Media Spezifikation definiert diese Eigenschaften im Detail. Diese Standard-CSS-Eigenschaften funktionieren konsistent auf der Chrome-Rendering-Engine und auf physischen Druckern.

Wie stellt man einen ASP.NET Core PDF-Viewer in Docker bereit?

IronPDF läuft ohne Codeänderungen in Linux- und Windows-Containern. Die im folgenden Dockerfile verwendeten Basis-Images stammen aus den offiziellen .NET -Container-Images von Microsoft , die regelmäßig mit Sicherheitspatches aktualisiert werden. Die unten stehende Docker-Konfiguration installiert die erforderlichen Systembibliotheken und erzeugt einen mehrstufigen Build für eine minimale Image-Größe:

FROM mcr.microsoft.com/dotnet/aspnet:10.0 AS base
WORKDIR /app

RUN apt-get update && apt-get install -y \
    libgdiplus \
    libc6-dev \
    libx11-dev \
    && rm -rf /var/lib/apt/lists/*

FROM mcr.microsoft.com/dotnet/sdk:10.0 AS build
WORKDIR /src
COPY ["PdfViewerApp.csproj", "./"]
RUN dotnet restore "PdfViewerApp.csproj"
COPY . .
RUN dotnet build "PdfViewerApp.csproj" -c Release -o /app/build

FROM build AS publish
RUN dotnet publish "PdfViewerApp.csproj" -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "PdfViewerApp.dll"]

Für Kubernetes-Bereitstellungen sollte ein Health-Check-Endpunkt hinzugefügt werden, der die PDF-Generierung durchgängig validiert:

builder.Services.AddHealthChecks()
    .AddCheck("pdf_generation", () =>
    {
        try
        {
            var renderer = new ChromePdfRenderer();
            var pdf = renderer.RenderHtmlAsPdf("<p>Health check</p>");
            return pdf.PageCount > 0
                ? HealthCheckResult.Healthy()
                : HealthCheckResult.Unhealthy("PDF generation returned empty document");
        }
        catch (Exception ex)
        {
            return HealthCheckResult.Unhealthy(ex.Message);
        }
    });
builder.Services.AddHealthChecks()
    .AddCheck("pdf_generation", () =>
    {
        try
        {
            var renderer = new ChromePdfRenderer();
            var pdf = renderer.RenderHtmlAsPdf("<p>Health check</p>");
            return pdf.PageCount > 0
                ? HealthCheckResult.Healthy()
                : HealthCheckResult.Unhealthy("PDF generation returned empty document");
        }
        catch (Exception ex)
        {
            return HealthCheckResult.Unhealthy(ex.Message);
        }
    });
Imports System
Imports Microsoft.Extensions.DependencyInjection
Imports Microsoft.Extensions.Diagnostics.HealthChecks

builder.Services.AddHealthChecks().AddCheck("pdf_generation", Function()
    Try
        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf("<p>Health check</p>")
        Return If(pdf.PageCount > 0, HealthCheckResult.Healthy(), HealthCheckResult.Unhealthy("PDF generation returned empty document"))
    Catch ex As Exception
        Return HealthCheckResult.Unhealthy(ex.Message)
    End Try
End Function)
$vbLabelText   $csharpLabel

Dieser Health-Check ermöglicht es Kubernetes, fehlerhafte Pods zu erkennen und zu ersetzen, bevor Benutzer auf Fehler stoßen. Es lässt sich außerdem in die standardmäßige ASP.NET Core Middleware zur Zustandsüberwachung integrieren. Die IronPDF Testlizenz beinhaltet die volle Funktionalität für Docker-Tests ohne Einschränkungen.

Welche Vorteile bietet ein In-Process-Renderer beim Einsatz?

Die folgende Tabelle vergleicht den In-Process-Ansatz von IronPDF mit Headless-Browser-Server-Setups, die üblicherweise für die serverseitige PDF-Generierung verwendet werden:

Vergleich von PDF-Generierungsansätzen für ASP.NET Core
Faktor IronPDF (In-Process) Headless-Browser-Server
Bereitstellungskomplexität Nur NuGet -Paket Separater Prozess oder Dienst
Netzwerklatenz Keine (In-Process) HTTP-Roundtrip pro Anfrage
Container-Fußabdruck Einzelner Container Mindestens zwei Container
Gesundheitsüberwachung Standard-ASP.NET ASP.NET Core Middleware Separater Gesundheitscheck für den Service
Rendering-Konsistenz Chrome-Engine, gesperrte Version Variiert je nach Browserversion

Wie fügt man dem Viewer erweiterte PDF-Funktionen hinzu?

IronPDF bietet weit mehr als nur das einfache Anzeigen und Herunterladen. Dieselbe Bibliothek, die HTML in PDF umwandelt, bietet auch PDF-Formularverarbeitung , benutzerdefinierte Wasserzeichen , digitale Signaturen und PDF-zu-Bild-Konvertierung – alles ohne zusätzliche Pakete.

Für Workflows im Bereich Dokumentenmanagement können Sie hochgeladene Dateien in PDF konvertieren, Text zur Indexierung extrahieren, Dokumente mit Anmerkungen versehen und sie an die Benutzer zurückliefern – alles innerhalb eines einzigen ASP.NET Core Controllers. Die IronPDF -Funktionsseite bietet eine vollständige Übersicht über die Funktionen mit Codebeispielen für jeden Funktionsbereich.

Wichtige Funktionen, die für Betrachteranwendungen von Bedeutung sind:

Wie handhaben Sie PDF-Sicherheit und Zugriffskontrolle?

Für Anwendungen, die sensible Dokumente anzeigen, kombinieren Sie die Passwort- und Berechtigungsfunktionen von IronPDF mit der Autorisierungs-Middleware von ASP.NET Core. Stellen Sie die Controller-Aktion so ein, dass eine Authentifizierung erforderlich ist, und streamen Sie dann das PDF – das Dokument berührt niemals das Dateisystem oder einen nicht authentifizierten Endpunkt.

Zur Erfüllung der Anforderungen an die Nachverfolgbarkeit müssen PDFs vor dem Streaming digital signiert werden . Die Signatur speichert den Zeitstempel der Unterzeichnung und bestätigt die Integrität des Dokuments, was für Finanz- und Rechtsdokumente, die über einen Browser-Viewer angezeigt werden, wichtig ist.

Welche Lizenzoptionen stehen zur Verfügung?

Die IronPDF Lizenzierung beginnt mit einer kostenlosen Testversion , die den vollen Funktionsumfang umfasst – geeignet für Entwicklungs-, Staging- und Machbarkeitsstudien in Docker- und Kubernetes-Umgebungen. Produktionslizenzen decken ein breites Spektrum an Bereitstellungsszenarien ab, von der Bereitstellung durch einen einzelnen Entwickler bis hin zu unbegrenzten Serverbereitstellungen.

Die IronPDF Dokumentation bietet detaillierte API-Referenzen, Migrationsleitfäden für das Upgrade zwischen .NET Versionen sowie plattformspezifische Einrichtungsanweisungen für Windows, Linux, macOS, AWS und Azure.

IronPDF offers flexible licensing options starting at $749 for single developers up to $3,999 for unlimited usage, with significant discounts currently available

Mit IronPDF lässt sich in wenigen Minuten ein PDF-Viewer in ASP.NET Core integrieren. Die Chrome-basierte Rendering-Engine bewältigt die Komplexität der HTML-zu-PDF-Konvertierung, das ASP.NET Core File() Ergebnis kümmert sich um das Inline-Verhalten im Vergleich zum Download-Verhalten, und dasselbe Paket deckt Drucken, Wasserzeichen, digitale Signaturen und Container-Bereitstellungen ab. Beginnen Sie mit der kostenlosen Testversion und fügen Sie erweiterte Dokumentfunktionen hinzu, wenn Ihre Anforderungen steigen.

Häufig gestellte Fragen

Wie kann IronPDF bei der Anzeige von PDFs in ASP.NET Core-Anwendungen helfen?

IronPDF vereinfacht den Prozess, indem es eine leistungsstarke Chrome-basierte Rendering-Engine verwendet, um PDF-Dateien direkt in Webbrowsern anzuzeigen, ohne dass Downloads oder zusätzliche Plugins erforderlich sind.

Was sind die Vorteile der Verwendung eines PDF-Viewers in ASP.NET Core?

Die Verwendung eines PDF-Viewers wie IronPDF in ASP.NET Core verbessert die Benutzerfreundlichkeit, indem sie das nahtlose Anzeigen, Speichern und Drucken von PDFs innerhalb des Browsers ermöglicht und externe Anwendungen wie Adobe Acrobat Reader überflüssig macht.

Muss ich Adobe Acrobat Reader installieren, um PDF-Dateien mit IronPDF anzuzeigen?

Nein, IronPDF ermöglicht die Anzeige von PDF-Dateien direkt im Browser, ohne dass Adobe Acrobat Reader oder andere Plugins erforderlich sind.

Welche Arten von Dokumenten können mit IronPDF in einer ASP.NET Core-Anwendung angezeigt werden?

IronPDF kann verwendet werden, um verschiedene Arten von Dokumenten wie Rechnungen, Berichte und Verträge nahtlos in ASP.NET Core-Anwendungen anzuzeigen.

Unterstützt IronPDF das Drucken von PDF-Dokumenten in ASP.NET Core?

Ja, IronPDF unterstützt den Druck von PDF-Dokumenten direkt aus der Webanwendung heraus und bietet damit eine vollständige PDF-Managementlösung.

Kann IronPDF komplexe PDF-Layouts in ASP.NET Core korrekt wiedergeben?

IronPDF verwendet eine auf Chrome basierende Rendering-Engine, um komplexe PDF-Layouts präzise zu rendern und eine qualitativ hochwertige Darstellung ohne Treueverluste zu gewährleisten.

Muss ich PDF-Dateien herunterladen, um sie mit IronPDF in ASP.NET Core anzuzeigen?

Nein, IronPDF ermöglicht es den Benutzern, PDF-Dateien direkt im Webbrowser anzusehen, ohne sie herunterladen zu müssen.

Wie verbessert IronPDF die PDF-Anzeige in Webanwendungen?

IronPDF verbessert das PDF-Anzeigeerlebnis durch die nahtlose Integration mit ASP.NET Core, so dass Benutzer PDFs direkt im Browser anzeigen, speichern und drucken können.

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