Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. IronPDF verwenden
  4. PDFs im ASP NET PDF Viewer anzeigen
IRONPDF NUTZEN

Wie man PDFs in einem ASP.NET Core Viewer anzeigt, speichert und druckt

Curtis Chau
Curtis Chau
Aktualisiert:

Anzeigen, Speichern und Drucken von PDFs in einem ASP.NET Core Viewer

IronPDF ermöglicht die nahtlose PDF-Anzeige in ASP.NET Core-Anwendungen, indem PDFs serverseitig generiert und die in Browsern integrierten PDF-Viewer genutzt werden. Dadurch entfällt die Notwendigkeit von Plugins, und gleichzeitig wird die plattformübergreifende Bereitstellung in Docker-Containern und Cloud-Umgebungen unterstützt.

PDF-Dokumente direkt in Webbrowsern anzuzeigen, ist eine essenzielle Anforderung für moderne ASP.NET Core-Webanwendungen geworden. Egal ob Rechnungen , Berichte oder Verträge erstellt werden, Benutzer erwarten eine reibungslose PDF-Anzeige, ohne Dateien herunterladen oder Adobe Acrobat Reader installieren zu müssen. Dieses Tutorial zeigt, wie IronPDF das Anzeigen, Speichern und Drucken von PDFs in Ihrem ASP.NET Core Viewer durch seine leistungsstarke , auf Chrome basierende Rendering-Engine vereinfacht.

Wie handhaben Browser die PDF-Anzeige in ASP.NET Core?

Moderne Browser enthalten eingebaute PDF-Viewer, die aktiviert werden, wenn sie eine PDF-Datei mit dem richtigen MIME-Typ (application/pdf) erhalten. Wenn Ihre ASP.NET Core-Anwendung ein PDF-Dokument mit den entsprechenden Kopfzeilen zurückgibt, zeigt der Browser es automatisch direkt im Dokument an. Dadurch entfällt die Notwendigkeit externer Plugins, des Adobe Acrobat Readers oder komplexer JavaScript-Bibliotheken. Laut MDN Web Docs ist eine korrekte Header-Konfiguration unerlässlich, um zu steuern, wie Browser Dateidownloads und -anzeigen handhaben.

IronPDF nutzt diese Browserfunktion, indem es mithilfe seiner ChromePdfRenderer -Klasse serverseitig qualitativ hochwertige PDFs generiert. Der Renderer nutzt im Hintergrund eine vollständige Chrome-Engine, wodurch sichergestellt wird, dass Ihre Dokumente genau so angezeigt werden, wie sie sollen, mit voller Unterstützung für modernes CSS , JavaScript , digitale Signaturen und Webfonts . Im Gegensatz zu einfachen Dokumentenbetrachtern bietet IronPDF die vollständige Kontrolle über die PDF-Verarbeitung und -Darstellung .

Welche Tools benötigen Sie, um PDF-Dateien in ASP.NET Core anzuzeigen?

Die Einrichtung von IronPDF in Ihrem ASP.NET Core-Projekt erfordert nur wenige Schritte. Erstellen Sie zunächst ein neues Projekt in Visual Studio oder über die Befehlszeile. Öffnen Sie Visual Studio und wählen Sie die ASP.NET Core Web Application-Projektvorlage:

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

Wie installiert man IronPDF in einem .NET-Projekt?

Installieren Sie IronPDF über den NuGet-Paketmanager in Ihrem Projekt:

Install-Package IronPdf

Oder klicken Sie im Solution Explorer mit der rechten Maustaste auf Ihr Projekt und wählen Sie "NuGet-Pakete verwalten." Wählen Sie die geeignete Paketquelle und suchen Sie nach IronPDF.

Das ist alles, was zur Einrichtung nötig ist. IronPDF funktioniert nahtlos mit ASP.NET Core 3.1 und späteren Versionen (Long-Term Support), einschließlich .NET 6, 7 und 8. Die Bibliothek wird regelmäßig aktualisiert, um die Kompatibilität mit den neuesten Frameworks zu gewährleisten. Eine detaillierte Installationsanleitung finden Sie im IronPDF-Installationshandbuch . Das Paket enthält alle notwendigen Komponenten für die PDF-Erstellung , -Bearbeitung und -Verarbeitung. Für Docker-Bereitstellungen bietet IronPDF optimierte Container-Images , die die Bereitstellungskomplexität minimieren – ein entscheidender Faktor für DevOps -Ingenieure, die containerisierte Umgebungen verwalten.

Wie können Sie PDF-Dateien im Browser mit ASP.NET Core anzeigen?

Das Erstellen und Anzeigen von PDFs im Browser erfordert nur wenige Codezeilen. Hier ist eine vollständige Controller-Aktion, die aus HTML ein PDF generiert und es inline anzeigt:

using IronPdf;
using Microsoft.AspNetCore.Mvc;

public class PdfController : Controller
{
    public IActionResult ViewPdf()
    {
        var renderer = new ChromePdfRenderer();
        // Configure rendering options for the PDF viewer
        renderer.RenderingOptions.PrintHtmlBackgrounds = true;
        renderer.RenderingOptions.CreatePdfFormsFromHtml = true;
        renderer.RenderingOptions.EnableJavaScript = true;
        // Generate PDF from HTML string
        var html = @"
            <html>
            <head>
                <style>
                    body { font-family: Arial, sans-serif; padding: 20px; }
                    h1 { color: #2c3e50; }
                    .content { line-height: 1.6; width: 100%; }
                </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);
        // Return PDF for inline viewing in the browser
        return File(pdf.BinaryData, "application/pdf");
    }
}
using IronPdf;
using Microsoft.AspNetCore.Mvc;

public class PdfController : Controller
{
    public IActionResult ViewPdf()
    {
        var renderer = new ChromePdfRenderer();
        // Configure rendering options for the PDF viewer
        renderer.RenderingOptions.PrintHtmlBackgrounds = true;
        renderer.RenderingOptions.CreatePdfFormsFromHtml = true;
        renderer.RenderingOptions.EnableJavaScript = true;
        // Generate PDF from HTML string
        var html = @"
            <html>
            <head>
                <style>
                    body { font-family: Arial, sans-serif; padding: 20px; }
                    h1 { color: #2c3e50; }
                    .content { line-height: 1.6; width: 100%; }
                </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);
        // Return PDF for inline viewing in the browser
        return File(pdf.BinaryData, "application/pdf");
    }
}
Imports IronPdf
Imports Microsoft.AspNetCore.Mvc

Public Class PdfController
    Inherits Controller

    Public Function ViewPdf() As IActionResult
        Dim renderer = New ChromePdfRenderer()
        ' Configure rendering options for the PDF viewer
        renderer.RenderingOptions.PrintHtmlBackgrounds = True
        renderer.RenderingOptions.CreatePdfFormsFromHtml = True
        renderer.RenderingOptions.EnableJavaScript = True
        ' Generate PDF from HTML string
        Dim html = "
            <html>
            <head>
                <style>
                    body { font-family: Arial, sans-serif; padding: 20px; }
                    h1 { color: #2c3e50; }
                    .content { line-height: 1.6; width: 100%; }
                </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)
        ' Return PDF for inline viewing in the browser
        Return File(pdf.BinaryData, "application/pdf")
    End Function
End Class
$vbLabelText   $csharpLabel

Der Code erstellt eine ChromePdfRenderer Instanz und konfiguriert diese so, dass Hintergrundfarben einbezogen und HTML-Formulare in PDF-Formulare konvertiert werden. Die Methode RenderHtmlAsPdf wandelt die HTML-Zeichenkette in ein PDF um. Durch die Rückgabe der PDF-Datei mit dem MIME-Typ application/pdf wird dem Browser mitgeteilt, dass er sie direkt im Browser anzeigen soll, anstatt sie herunterzuladen. Dieser serverseitige Ansatz gewährleistet eine konsistente Darstellung auf allen Browsern und Plattformen – unerlässlich für die Aufrechterhaltung der Zuverlässigkeit in Azure-Bereitstellungen und AWS Lambda-Umgebungen .

Ausgabe

Die Benutzeroberfläche des PDF-Viewers zeigt eine einfache Rechnung mit der Rechnungsnummer 12345 vom 30.10.2025. Der ASP.NET Core PDF-Viewer stellt das gerenderte Rechnungsdokument mit Seitennavigations- und Zoomoptionen in der Symbolleiste korrekt dar.

Für bestehende HTML-Dateien oder Razor-Seiten können Sie alternative Rendering-Methoden verwenden:

// Render from URL - useful for complex pages
var pdf = renderer.RenderUrlAsPdf("___PROTECTED_URL_58___");
// Render from HTML file in the same location
var pdf = renderer.RenderHtmlFileAsPdf("Views/Invoice.html");
// Render from wwwroot folder
var pdf = renderer.RenderHtmlFileAsPdf("wwwroot/templates/report.html");
// For containerized applications, use environment-specific paths
var basePath = Environment.GetEnvironmentVariable("APP_BASE_PATH") ?? "wwwroot";
var pdf = renderer.RenderHtmlFileAsPdf($"{basePath}/templates/report.html");
// Render from URL - useful for complex pages
var pdf = renderer.RenderUrlAsPdf("___PROTECTED_URL_58___");
// Render from HTML file in the same location
var pdf = renderer.RenderHtmlFileAsPdf("Views/Invoice.html");
// Render from wwwroot folder
var pdf = renderer.RenderHtmlFileAsPdf("wwwroot/templates/report.html");
// For containerized applications, use environment-specific paths
var basePath = Environment.GetEnvironmentVariable("APP_BASE_PATH") ?? "wwwroot";
var pdf = renderer.RenderHtmlFileAsPdf($"{basePath}/templates/report.html");
' Render from URL - useful for complex pages
Dim pdf = renderer.RenderUrlAsPdf("___PROTECTED_URL_58___")
' Render from HTML file in the same location
pdf = renderer.RenderHtmlFileAsPdf("Views/Invoice.html")
' Render from wwwroot folder
pdf = renderer.RenderHtmlFileAsPdf("wwwroot/templates/report.html")
' For containerized applications, use environment-specific paths
Dim basePath = If(Environment.GetEnvironmentVariable("APP_BASE_PATH"), "wwwroot")
pdf = renderer.RenderHtmlFileAsPdf($"{basePath}/templates/report.html")
$vbLabelText   $csharpLabel

Diese Methoden bieten Flexibilität bei der Beschaffung Ihrer HTML-Inhalte und gewährleisten gleichzeitig eine hohe Qualität der PDF-Ausgabe. Mit den umfassenden Funktionen von IronPDF können Sie außerdem vorhandene PDF-Dokumente laden , PDFs bearbeiten und mit Word- (DOCX-Dateien) und Excel-Formaten arbeiten. Mehr über die Konvertierungsoptionen von HTML zu PDF erfahren Sie in der Dokumentation. Für erweiterte Verarbeitungs- und Bearbeitungsfunktionen konsultieren Sie die API-Referenz .

Für DevOps Ingenieure, die Microservices-Architekturen verwalten, bietet die native vs. Remote-Engine -Architektur von IronPDF Flexibilität bei der Bereitstellung. Die Option "Remote Engine" ermöglicht es Ihnen, das PDF-Rendering in einen separaten Dienst auszulagern, wodurch die Ressourcennutzung verbessert und eine horizontale Skalierung ermöglicht wird.

Wie können Benutzer PDF-Dokumente aus dem Browser speichern?

Um Benutzern das Herunterladen von PDFs anstatt deren Anzeige im Text zu ermöglichen, muss der Content-Disposition -Header geändert werden. Diese Funktion ist unerlässlich für Anwendungen, bei denen Benutzer Offline-Zugriff benötigen:

public IActionResult DownloadPdf()
{
    var renderer = new ChromePdfRenderer();
    // Create PDF with CSS styling and images
    var html = @"<h1>Download Me</h1>
                 <img src='logo.png' width='100' />";
    var pdf = renderer.RenderHtmlAsPdf(html, @"wwwroot/images");
    // Force download with custom filename
    return File(pdf.BinaryData, "application/pdf", "invoice-2024.pdf");
}

// Health check endpoint for container orchestration
[HttpGet("/health/pdf-generator")]
public IActionResult HealthCheck()
{
    try
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<p>Health Check</p>");
        return Ok(new { status = "healthy", timestamp = DateTime.UtcNow });
    }
    catch (Exception ex)
    {
        return StatusCode(503, new { status = "unhealthy", error = ex.Message });
    }
}
public IActionResult DownloadPdf()
{
    var renderer = new ChromePdfRenderer();
    // Create PDF with CSS styling and images
    var html = @"<h1>Download Me</h1>
                 <img src='logo.png' width='100' />";
    var pdf = renderer.RenderHtmlAsPdf(html, @"wwwroot/images");
    // Force download with custom filename
    return File(pdf.BinaryData, "application/pdf", "invoice-2024.pdf");
}

// Health check endpoint for container orchestration
[HttpGet("/health/pdf-generator")]
public IActionResult HealthCheck()
{
    try
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<p>Health Check</p>");
        return Ok(new { status = "healthy", timestamp = DateTime.UtcNow });
    }
    catch (Exception ex)
    {
        return StatusCode(503, new { status = "unhealthy", error = ex.Message });
    }
}
Public Function DownloadPdf() As IActionResult
    Dim renderer = New ChromePdfRenderer()
    ' Create PDF with CSS styling and images
    Dim html = "<h1>Download Me</h1>
                <img src='logo.png' width='100' />"
    Dim pdf = renderer.RenderHtmlAsPdf(html, "wwwroot/images")
    ' Force download with custom filename
    Return File(pdf.BinaryData, "application/pdf", "invoice-2024.pdf")
End Function

' Health check endpoint for container orchestration
<HttpGet("/health/pdf-generator")>
Public Function HealthCheck() As IActionResult
    Try
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf("<p>Health Check</p>")
        Return Ok(New With {Key .status = "healthy", Key .timestamp = DateTime.UtcNow})
    Catch ex As Exception
        Return StatusCode(503, New With {Key .status = "unhealthy", Key .error = ex.Message})
    End Try
End Function
$vbLabelText   $csharpLabel

Durch Hinzufügen des Dateinamenparameters wird der Content-Disposition Header automatisch auf "attachment" gesetzt, wodurch der Browser zum Herunterladen der Datei aufgefordert wird. Benutzer können auch direkt im Browser angezeigte PDFs mithilfe der Speicherfunktion ihres Browsers (Strg+S oder der PDF-Viewer-Symbolleiste) speichern. Der oben gezeigte Health-Check-Endpunkt ist für Kubernetes-Bereitstellungen und Container-Orchestrierungsplattformen von entscheidender Bedeutung, da er sicherstellt, dass Ihr PDF-Dienst reaktionsfähig bleibt.

Ausgabe

PDF-Viewer, der ein Dokument mit dem Text Download Me und dem IronPDF for .NET-Logo anzeigt, dargestellt in einem Browser mit 100% Zoom. Der PDF-Viewer zeigt das generierte Rechnungsdokument erfolgreich an, wobei die Download-Funktion über IronPDF für .NET aktiviert ist.

Warum sollte man Streams für große PDF-Dateien verwenden?

Um bei großen Dokumenten eine bessere Speichereffizienz zu erzielen, verwenden Sie Streams:

public IActionResult StreamPdf()
{
    var renderer = new ChromePdfRenderer();
    // Load and process HTML with images
    var html = "<h1>Streamed Content</h1>";
    var pdf = renderer.RenderHtmlAsPdf(html);
    // Stream the PDF file to the browser
    var stream = pdf.Stream;
    stream.Position = 0;
    return File(stream, "application/pdf", "document.pdf");
}

// Async streaming for better resource utilization
public async Task<IActionResult> StreamPdfAsync()
{
    var renderer = new ChromePdfRenderer();
    // Configure for optimal container performance
    renderer.RenderingOptions.Timeout = 60000; // 60 seconds for complex documents
    renderer.RenderingOptions.RenderDelay = 500; // Allow JS to execute

    var html = await LoadHtmlTemplateAsync();
    var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf(html));

    var stream = pdf.Stream;
    stream.Position = 0;
    return File(stream, "application/pdf", "async-document.pdf");
}
public IActionResult StreamPdf()
{
    var renderer = new ChromePdfRenderer();
    // Load and process HTML with images
    var html = "<h1>Streamed Content</h1>";
    var pdf = renderer.RenderHtmlAsPdf(html);
    // Stream the PDF file to the browser
    var stream = pdf.Stream;
    stream.Position = 0;
    return File(stream, "application/pdf", "document.pdf");
}

// Async streaming for better resource utilization
public async Task<IActionResult> StreamPdfAsync()
{
    var renderer = new ChromePdfRenderer();
    // Configure for optimal container performance
    renderer.RenderingOptions.Timeout = 60000; // 60 seconds for complex documents
    renderer.RenderingOptions.RenderDelay = 500; // Allow JS to execute

    var html = await LoadHtmlTemplateAsync();
    var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf(html));

    var stream = pdf.Stream;
    stream.Position = 0;
    return File(stream, "application/pdf", "async-document.pdf");
}
Imports System.Threading.Tasks

Public Function StreamPdf() As IActionResult
    Dim renderer = New ChromePdfRenderer()
    ' Load and process HTML with images
    Dim html = "<h1>Streamed Content</h1>"
    Dim pdf = renderer.RenderHtmlAsPdf(html)
    ' Stream the PDF file to the browser
    Dim stream = pdf.Stream
    stream.Position = 0
    Return File(stream, "application/pdf", "document.pdf")
End Function

' Async streaming for better resource utilization
Public Async Function StreamPdfAsync() As Task(Of IActionResult)
    Dim renderer = New ChromePdfRenderer()
    ' Configure for optimal container performance
    renderer.RenderingOptions.Timeout = 60000 ' 60 seconds for complex documents
    renderer.RenderingOptions.RenderDelay = 500 ' Allow JS to execute

    Dim html = Await LoadHtmlTemplateAsync()
    Dim pdf = Await Task.Run(Function() renderer.RenderHtmlAsPdf(html))

    Dim stream = pdf.Stream
    stream.Position = 0
    Return File(stream, "application/pdf", "async-document.pdf")
End Function
$vbLabelText   $csharpLabel

Dieser Ansatz reduziert den Speicherverbrauch, indem PDFs direkt in die Antwort gestreamt werden, ohne Zwischenspeicher in Byte-Arrays zu erstellen. Sie können auch bereits vorhandene PDFs aus dem wwwroot-Ordner laden, bearbeiten und geänderte Versionen streamen. Für fortgeschrittene PDF-Dokumentmanipulation und Bildverarbeitung konsultieren Sie die PdfDocument-API-Referenz . Die Komponente unterstützt verschiedene Bearbeitungsvorgänge, darunter Textauswahl , Formularausfüllen und das Hinzufügen digitaler Signaturen .

Bei Container-Bereitstellungen verhindert der Ansatz der asynchronen PDF-Generierung blockierende Threads und verbessert den Anwendungsdurchsatz – entscheidend für die Aufrechterhaltung reaktionsschneller Dienste in orchestrierten Umgebungen.

Können Benutzer PDF-Dokumente direkt von ASP.NET Core-Webanwendungen aus drucken?

IronPDF optimiert PDFs für den Druck, indem es den entsprechenden CSS-Medientyp und die Seiteneinstellungen konfiguriert. Dies gewährleistet ein professionelles Ergebnis, egal ob die Benutzer auf physischen Druckern drucken oder als PDF speichern:

public IActionResult PrintablePdf()
{
    var renderer = new ChromePdfRenderer();
    // Configure printing options for the PDF viewer
    renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
    renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait;
    renderer.RenderingOptions.MarginTop = 25;
    renderer.RenderingOptions.MarginBottom = 25;
    renderer.RenderingOptions.MarginLeft = 25;
    renderer.RenderingOptions.MarginRight = 25;
    // Load HTML with print-specific CSS
    var html = @"<h1>Print-Optimized Document</h1>
                 <p>This document is optimized for printing.</p>";
    var pdf = renderer.RenderHtmlAsPdf(html);
    // Return the PDF file for viewing and printing
    return File(pdf.BinaryData, "application/pdf");
}

// Container-optimized configuration
public IActionResult ConfigureForContainer()
{
    var renderer = new ChromePdfRenderer();
    // Disable GPU for container compatibility
    renderer.RenderingOptions.EnableJavaScript = true;
    renderer.RenderingOptions.RenderDelay = 0; // No artificial delays
    renderer.RenderingOptions.Timeout = 30000; // 30 second timeout

    // Use environment variables for configuration
    var printDpi = int.Parse(Environment.GetEnvironmentVariable("PDF_PRINT_DPI") ?? "300");
    renderer.RenderingOptions.PrintHtmlBackgrounds = true;

    return Ok("Configured for container environment");
}
public IActionResult PrintablePdf()
{
    var renderer = new ChromePdfRenderer();
    // Configure printing options for the PDF viewer
    renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
    renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait;
    renderer.RenderingOptions.MarginTop = 25;
    renderer.RenderingOptions.MarginBottom = 25;
    renderer.RenderingOptions.MarginLeft = 25;
    renderer.RenderingOptions.MarginRight = 25;
    // Load HTML with print-specific CSS
    var html = @"<h1>Print-Optimized Document</h1>
                 <p>This document is optimized for printing.</p>";
    var pdf = renderer.RenderHtmlAsPdf(html);
    // Return the PDF file for viewing and printing
    return File(pdf.BinaryData, "application/pdf");
}

// Container-optimized configuration
public IActionResult ConfigureForContainer()
{
    var renderer = new ChromePdfRenderer();
    // Disable GPU for container compatibility
    renderer.RenderingOptions.EnableJavaScript = true;
    renderer.RenderingOptions.RenderDelay = 0; // No artificial delays
    renderer.RenderingOptions.Timeout = 30000; // 30 second timeout

    // Use environment variables for configuration
    var printDpi = int.Parse(Environment.GetEnvironmentVariable("PDF_PRINT_DPI") ?? "300");
    renderer.RenderingOptions.PrintHtmlBackgrounds = true;

    return Ok("Configured for container environment");
}
Imports System

Public Class PdfController
    Public Function PrintablePdf() As IActionResult
        Dim renderer As New ChromePdfRenderer()
        ' Configure printing options for the PDF viewer
        renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait
        renderer.RenderingOptions.MarginTop = 25
        renderer.RenderingOptions.MarginBottom = 25
        renderer.RenderingOptions.MarginLeft = 25
        renderer.RenderingOptions.MarginRight = 25
        ' Load HTML with print-specific CSS
        Dim html As String = "<h1>Print-Optimized Document</h1>
                              <p>This document is optimized for printing.</p>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        ' Return the PDF file for viewing and printing
        Return File(pdf.BinaryData, "application/pdf")
    End Function

    ' Container-optimized configuration
    Public Function ConfigureForContainer() As IActionResult
        Dim renderer As New ChromePdfRenderer()
        ' Disable GPU for container compatibility
        renderer.RenderingOptions.EnableJavaScript = True
        renderer.RenderingOptions.RenderDelay = 0 ' No artificial delays
        renderer.RenderingOptions.Timeout = 30000 ' 30 second timeout

        ' Use environment variables for configuration
        Dim printDpi As Integer = Integer.Parse(Environment.GetEnvironmentVariable("PDF_PRINT_DPI") Or "300")
        renderer.RenderingOptions.PrintHtmlBackgrounds = True

        Return Ok("Configured for container environment")
    End Function
End Class
$vbLabelText   $csharpLabel

Durch die Einstellung CssMediaType auf Print werden druckspezifische CSS-Stile angewendet, um sicherzustellen, dass das Dokument beim Drucken korrekt aussieht. Die Seiteneinstellungen sorgen für den richtigen Abstand auf physischem Papier. Benutzer können PDFs direkt aus dem PDF-Viewer ihres Browsers über den Standard-Druckdialog drucken und behalten dabei die volle Kontrolle über die Druckerauswahl und -einstellungen. Erfahren Sie mehr über die PDF-Rendering-Optionen , um Ihre Ausgabe feinabzustimmen.

![PDF-Viewer-Oberfläche, die ein druckoptimiertes Dokument mit der Meldung "Dieses Dokument ist für den Druck optimiert" in der Mitte einer weißen Seite anzeigt.] Der PDF-Viewer zeigt eine Bestätigungsmeldung an, sobald ein Dokument für den Druck optimiert wurde, sodass die Benutzer wissen, dass ihre Datei für eine hochwertige Ausgabe bereit ist.

Wie unterstützt IronPDF plattformübergreifende und Container-Bereitstellungen?

IronPDF läuft nahtlos auf Windows, Linux, macOS, Docker-Containern und Cloud-Plattformen wie Azure und AWS. Diese plattformübergreifende Kompatibilität stellt sicher, dass Ihre ASP.NET Core-PDF-Viewer-Lösung unabhängig von der Bereitstellungsumgebung konsistent funktioniert. Die Bibliothek kümmert sich intern um plattformspezifische Rendering-Details, sodass Ihr Code überall ohne Änderungen funktioniert.

![Plattformübergreifendes Unterstützungsdiagramm, das die .NET-Kompatibilität über verschiedene Versionen, Betriebssysteme, Cloud-Plattformen und Entwicklungsumgebungen hinweg zeigt. IronPDF bietet umfassende plattformübergreifende Unterstützung, einschließlich Kompatibilität mit .NET 9 bis Framework 4.6.2+, läuft unter Windows, Linux und Mac und lässt sich in gängige Cloud-Anbieter und Entwicklungstools integrieren.

Die serverseitige Verarbeitung stellt eine konsistente PDF-Erzeugung über alle Plattformen hinweg sicher. Unabhängig davon, ob die Komponente auf Windows-Servern oder Linux-Containern eingesetzt wird, bleibt die Rendering-Qualität gleich. Die Bibliothek verwaltet automatisch Pfadunterschiede zwischen Betriebssystemen und verarbeitet Dateien im wwwroot-Ordner oder an anderen Speicherorten korrekt. Für containerisierte Bereitstellungen konsultieren Sie bitte den Docker-Bereitstellungsleitfaden . Das Paket enthält alle notwendigen Abhängigkeiten für jede Plattform und erfordert keine zusätzliche Konfiguration über die Standardanforderungen von ASP.NET Core hinaus.

Für den Einsatz von Containern in der Produktion können Sie folgendes Dockerfile-Beispiel verwenden:

FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
WORKDIR /app
EXPOSE 80

# Install IronPDF dependencies for Linux
RUN apt-get update && apt-get install -y \
    libgdiplus \
    libc6-dev \
    libx11-6 \
    && rm -rf /var/lib/apt/lists/*

FROM mcr.microsoft.com/dotnet/sdk:8.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"]

Starten Sie jetzt mit einer kostenlosen Testversion und erweitern Sie noch heute die Möglichkeiten Ihres Dokumentenbetrachters.

Was sind die wichtigsten Vorteile der Verwendung von IronPDF für die PDF-Anzeige in ASP.NET Core?

IronPDF revolutioniert die PDF-Verarbeitung in ASP.NET Core-Anwendungen durch die Kombination von serverseitiger Generierung und browsernativer Anzeige. Mit nur wenigen Codezeilen können Sie professionelle PDFs aus HTML erstellen, diese direkt im Text anzeigen, Downloads ermöglichen und für den Druck optimieren. Die auf Chrome basierende Rendering-Engine gewährleistet pixelgenaue Darstellung auf allen Plattformen und macht somit Adobe Acrobat Reader oder Drittanbieter-Viewer überflüssig.

Diese ASP.NET Core PDF-Viewer-Lösung bietet umfassende Funktionen wie Formularausfüllung , Textauswahl , digitale Signaturen und die Möglichkeit, PDFs zu bearbeiten . Die Komponente unterstützt außerdem die Konvertierung von Word-Dokumenten (DOCX-Dateien) , Excel-Tabellen und Bildern in PDF . Egal, ob Sie einen einfachen Dokumentenbetrachter oder ein komplexes Dokumentenmanagementsystem entwickeln möchten, IronPDF bietet Ihnen die nötigen Werkzeuge.

Die Tag-Helper-Integration der Bibliothek und die umfangreiche Dokumentation erleichtern die Implementierung. Ihr Projekt kann PDFs direkt anzeigen, während die komplexe PDF-Generierung im Hintergrund verarbeitet wird. Der Viewer verhält sich konsistent, egal ob er aus dem wwwroot-Ordner geladen, dynamisch generiert oder von externen Quellen abgerufen wird. Mit eingebauter Themenunterstützung und anpassbaren Breiteneinstellungen können Sie das Design Ihrer Anwendung perfekt anpassen. Für DevOps Teams bietet das IronPDF Slim-Paket eine reduzierte Bereitstellungsgröße und begegnet so den Beschränkungen der Containergröße in orchestrierten Umgebungen.

Bereit zur Implementierung der PDF-Anzeige in Ihrer .NET Core-Webanwendung?

Für den produktiven Einsatz beginnen die Lizenzen bei $799 und beinhalten umfassenden Support und Updates. Besuchen Sie die Dokumentation für detaillierte API-Referenzen und erweiterte Funktionen. Suchen Sie in unseren umfangreichen Codebeispielen nach einer schnellen Implementierung von PDF-Funktionalität in Ihren ASP.NET Core-Projekten.

![IronPDF-Lizenzseite mit vier unbefristeten Lizenzstufen (Lite, Plus, Professional und Unlimited) mit Preisen, Entwicklerbeschränkungen und einer Option zum Umschalten zwischen IronPDF- und Iron Suite-Optionen. IronPDF bietet verschiedene Lizenzoptionen an, von 749 US-Dollar für einzelne Entwickler bis zu 3.999 US-Dollar für die unbegrenzte Nutzung. Alle Lizenzen beinhalten ein Jahr Support und Updates.

Häufig gestellte Fragen

Wie kann ich PDFs in einer ASP.NET Core-Anwendung anzeigen?

Sie können PDFs in einer ASP.NET Core-Anwendung mit IronPDF anzeigen, das Funktionen zum Rendern von PDF-Dateien direkt in Ihrer Anwendung bietet.

Welche Schritte sind nötig, um ein PDF in ASP.NET Core mit IronPDF zu speichern?

Um ein PDF in ASP.NET Core zu speichern, können Sie die integrierten Methoden von IronPDF verwenden, um Ihr Dokument in ein PDF-Format zu konvertieren und es dann in ein Dateisystem oder einen Stream zu schreiben.

Ist es möglich, PDFs in ASP.NET Core-Anwendungen zu drucken?

Ja, IronPDF ermöglicht das direkte Drucken von PDFs aus Ihrer ASP.NET Core-Anwendung mithilfe von Rendering- und Druckfunktionen.

Welche Vorteile bietet IronPDF in ASP.NET Core?

IronPDF bietet eine nahtlose Integration mit ASP.NET Core, die eine einfache PDF-Manipulation wie Anzeigen, Speichern und Drucken mit minimalem Aufwand ermöglicht.

Kann IronPDF große PDF-Dokumente in ASP.NET Core verarbeiten?

Ja, IronPDF ist optimiert, um große PDF-Dokumente effizient zu verarbeiten und eine reibungslose Leistung auch bei komplexen Dateien zu gewährleisten.

Unterstützt IronPDF PDF-Anmerkungen und Kommentare in ASP.NET Core?

IronPDF unterstützt das Hinzufügen und Lesen von Anmerkungen und Kommentaren in PDFs, was die Interaktivität und Benutzerfreundlichkeit von PDF-Dokumenten in Ihrer ASP.NET Core-Anwendung verbessert.

Wie integriere ich IronPDF in ein bestehendes ASP.NET Core-Projekt?

Sie können IronPDF in Ihr ASP.NET Core-Projekt integrieren, indem Sie das IronPDF NuGet-Paket installieren und dessen API zur Verwaltung von PDFs verwenden.

Gibt es spezifische Systemanforderungen für die Verwendung von IronPDF mit ASP.NET Core?

IronPDF erfordert .NET Core oder .NET 5+ und unterstützt alle gängigen Betriebssysteme, was es zu einer flexiblen Wahl für ASP.NET Core-Projekte macht.

Kann IronPDF andere Dateiformate in PDF in ASP.NET Core konvertieren?

Ja, IronPDF kann verschiedene Dateiformate wie HTML, Bilder und Dokumente innerhalb einer ASP.NET Core-Umgebung in PDFs konvertieren.

Welche Art von Unterstützung bietet IronPDF für ASP.NET Core-Entwickler?

IronPDF bietet umfassende Dokumentation, Code-Beispiele und einen reaktionsschnellen Support, um ASP.NET Core-Entwicklern bei der Implementierung von PDF-Funktionen zu helfen.

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