IronPDF umożliwia płynne wyświetlanie plików PDF w aplikacjach ASP.NET Core poprzez generowanie plików PDF po stronie serwera i wykorzystanie wbudowanych przeglądarek PDF w przeglądarkach, eliminując potrzebę stosowania wtyczek, a jednocześnie wspierając wdrażanie międzyplatformowe w kontenerach Docker i środowiskach chmurowych.

Wyświetlanie dokumentów PDF bezpośrednio w przeglądarkach internetowych stało się niezbędnym wymogiem dla nowoczesnych aplikacji internetowych ASP.NET Core. Niezależnie od tego, czy generujesz faktury, raporty czy umowy, użytkownicy oczekują płynnego przeglądania plików PDF bez konieczności pobierania plików lub instalowania programu Adobe Acrobat Reader. Ten samouczek pokazuje, w jaki sposób IronPDF upraszcza wyświetlanie, zapisywanie i drukowanie plików PDF w przeglądarce ASP.NET Core dzięki potężnemu silnikowi renderowania opartemu na przeglądarce Chrome.

W jaki sposób przeglądarki obsługują wyświetlanie plików PDF w ASP.NET Core?

Nowoczesne przeglądarki internetowe zawierają wbudowane przeglądarki PDF, które aktywują się, gdy otrzymają plik PDF z odpowiednim typem MIME (application/pdf). Gdy aplikacja .NET Core zwraca dokument PDF z odpowiednimi nagłówkami, przeglądarka automatycznie wyświetla go w trybie inline. Eliminuje to potrzebę stosowania zewnętrznych wtyczek, programu Adobe Acrobat Reader lub złożonych bibliotek JavaScript. Według MDN Web Docs prawidłowa konfiguracja nagłówków jest niezbędna do kontrolowania sposobu, w jaki przeglądarki obsługują pobieranie i wyświetlanie plików.

IronPDF wykorzystuje tę funkcjonalność przeglądarki, generując wysokiej jakości pliki PDF po stronie serwera przy użyciu swojej klasy ChromePdfRenderer. Renderer wykorzystuje w tle pełny silnik Chrome, zapewniając wyświetlanie dokumentów dokładnie zgodnie z zamierzeniami, z pełną obsługą nowoczesnego CSS, JavaScript, podpisów cyfrowych i czcionek internetowych. W przeciwieństwie do prostych przeglądarek dokumentów, IronPDF zapewnia pełną kontrolę nad przetwarzaniem i renderowaniem plików PDF.

Jakie narzędzia są potrzebne do wyświetlania/przeglądania plików PDF w ASP.NET Core?

Konfiguracja IronPDF w projekcie ASP.NET Core wymaga zaledwie kilku kroków. Najpierw utwórz nowy projekt w Visual Studio lub za pomocą wiersza poleceń. Otwórz Visual Studio i wybierz szablon projektu aplikacji internetowej ASP.NET Core:

dotnet new mvc -n PdfViewerApp
cd PdfViewerApp

dotnet new mvc -n PdfViewerApp
cd PdfViewerApp

Jak zainstalować IronPDF w projekcie .NET?

Zainstaluj IronPDF w swoim projekcie za pomocą menedżera pakietów NuGet:

Install-Package IronPdf

Lub w Solution Explorer kliknij prawym przyciskiem myszy na swój projekt i wybierz "Zarządzaj pakietami NuGet". Wybierz odpowiednie źródło pakietów i wyszukaj IronPDF.

To wszystko, co trzeba zrobić. IronPDF działa płynnie z ASP.NET Core 3.1 i nowszymi wersjami (wersje z długoterminowym wsparciem), w tym .NET 6, 7 i 8. Biblioteka jest często aktualizowana, aby zapewnić zgodność z najnowszymi frameworkami. Szczegółowe instrukcje instalacji można znaleźć w przewodniku instalacji IronPDF. Pakiet zawiera wszystkie niezbędne komponenty do generowania, edycji i przetwarzania plików PDF. Dla wdrożeń Docker IronPDF zapewnia optymalizowane obrazy kontenerów, które minimalizują złożoność wdrożenia—kluczowe zagadnienie dla inżynierów DevOps zarządzających środowiskami z kontenerami.

Jak wyświetlać pliki PDF w przeglądarce przy użyciu ASP.NET Core?

Tworzenie i wyświetlanie plików PDF w przeglądarce wymaga zaledwie kilku wierszy kodu. Oto kompletna akcja kontrolera, która generuje plik PDF z kodu HTML i wyświetla go w linii:

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

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

Kod tworzy instancję ChromePdfRenderer i konfiguruje ją, aby zawierała kolory tła i konwertowała formularze HTML na formularze PDF. Metoda RenderHtmlAsPdf przekształca ciąg HTML w PDF. Zwrócenie pliku PDF z typem MIME application/pdf nakazuje przeglądarce wyświetlenie go wbudowane zamiast jego pobierania. To podejście po stronie serwera zapewnia spójne renderowanie we wszystkich przeglądarkach i na wszystkich platformach — co jest niezbędne do utrzymania niezawodności w środowiskach wdrożeń Azure i AWS Lambda.

Wynik

W przypadku istniejących plików HTML lub stron Razor można użyć alternatywnych metod renderowania:

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

' 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")

Metody te zapewniają elastyczność w pozyskiwaniu treści HTML przy zachowaniu wysokiej jakości plików PDF. Możesz również wczytywać istniejące dokumenty PDF, edytować pliki PDF oraz pracować z formatami WORD (pliki DOCX) i Excel, korzystając z wszechstronnych funkcji IronPDF. Więcej informacji na temat opcji konwersji HTML do PDF można znaleźć w dokumentacji. Aby uzyskać informacje na temat zaawansowanych funkcji przetwarzania i edycji, zapoznaj się z Dokumentacją API.

Dla inżynierów DevOps zarządzających architekturą mikrousług, architektura native vs remote engine IronPDF zapewnia elastyczność wdrożeń. Opcja silnika zdalnego pozwala na wyodrębnienie renderowania plików PDF do dedykowanej usługi, poprawiając wykorzystanie zasobów i umożliwiając skalowanie horyzontalne.

W jaki sposób użytkownicy zapisują dokumenty PDF z przeglądarki?

Aby umożliwić użytkownikom pobieranie plików PDF zamiast ich oglądania online, zmodyfikuj nagłówek Content-Disposition. Ta funkcja jest niezbędna w aplikacjach, w których użytkownicy potrzebują dostępu w trybie offline:

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

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

Dodanie parametru nazwy pliku automatycznie ustawia nagłówek Content-Disposition na "attachment," co powoduje, że przeglądarka pobiera plik. Użytkownicy mogą również zapisać wyświetlane w przeglądarce pliki PDF za pomocą funkcji zapisu przeglądarki (Ctrl+S lub pasek narzędzi przeglądarki PDF). Powyższy punkt końcowy kontroli stanu ma kluczowe znaczenie dla wdrożeń Kubernetes i platform orkiestracji kontenerów, zapewniając, że usługa PDF pozostaje responsywna.

Wynik

Dlaczego warto używać strumieni do obsługi dużych plików PDF?

Aby uzyskać lepszą wydajność pamięci w przypadku dużych dokumentów, należy używać strumieni:

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");
}

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

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

Takie podejście zmniejsza zużycie pamięci poprzez strumieniowe przesyłanie plików PDF bezpośrednio do odpowiedzi bez tworzenia pośrednich tablic bajtów. Można również wczytać istniejące pliki PDF z folderu wwwroot, edytować je i przesyłać strumieniowo zmodyfikowane wersje. Aby uzyskać informacje na temat zaawansowanej obróbki dokumentów PDF i przetwarzania obrazów, zapoznaj się z dokumentacją API PdfDocument. Komponent obsługuje różne operacje edycji, w tym zaznaczanie tekstu, wypełnianie formularzy i dodawanie podpisów cyfrowych.

W przypadku wdrożeń kontenerowych podejście oparte na asynchronicznym generowaniu plików PDF zapobiega blokowaniu wątków i poprawia przepustowość aplikacji — co ma kluczowe znaczenie dla utrzymania responsywnych usług w środowiskach orkiestrowanych.

Czy użytkownicy mogą drukować dokumenty PDF bezpośrednio z aplikacji internetowych ASP.NET Core?

IronPDF optymalizuje pliki PDF do drukowania poprzez konfigurację odpowiedniego typu mediów CSS i ustawień strony. Zapewnia to profesjonalny efekt końcowy, niezależnie od tego, czy użytkownicy drukują na fizycznych drukarkach, czy zapisują pliki w formacie PDF:

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");
}

Public Function PrintablePdf() As IActionResult
    Dim 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
    Dim html = "<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 = 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 = Integer.Parse(Environment.GetEnvironmentVariable("PDF_PRINT_DPI") OrElse "300")
    renderer.RenderingOptions.PrintHtmlBackgrounds = True

    Return Ok("Configured for container environment")
End Function

Public Function PrintablePdf() As IActionResult
    Dim 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
    Dim html = "<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 = 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 = Integer.Parse(Environment.GetEnvironmentVariable("PDF_PRINT_DPI") OrElse "300")
    renderer.RenderingOptions.PrintHtmlBackgrounds = True

    Return Ok("Configured for container environment")
End Function

Ustawienie CssMediaType na Print stosuje style CSS specyficzne dla druku, zapewniając, że dokument wygląda poprawnie podczas drukowania. Ustawienia marginesów zapewniają odpowiednie odstępy na papierze. Użytkownicy mogą drukować pliki PDF bezpośrednio z przeglądarki plików PDF, korzystając ze standardowego okna dialogowego drukowania, zachowując pełną kontrolę nad wyborem drukarki i ustawieniami. Dowiedz się więcej o opcjach renderowania plików PDF, aby precyzyjnie dostosować wynik.

W jaki sposób IronPDF obsługuje wdrożenia wielopłatformowe i w kontenerach?

IronPDF działa płynnie w systemach Windows, Linux, macOS, kontenerach Docker oraz na platformach chmurowych, takich jak Azure i AWS. Ta kompatybilność międzyplatformowa gwarantuje, że Twoje rozwiązanie do przeglądania plików PDF w ASP.NET Core działa spójnie niezależnie od środowiska wdrożeniowego. Biblioteka wewnętrznie obsługuje szczegóły renderowania specyficzne dla platformy, dzięki czemu kod działa wszędzie bez modyfikacji.

Przetwarzanie po stronie serwera zapewnia spójne generowanie plików PDF na wszystkich platformach. Niezależnie od tego, czy komponent jest wdrażany na serwerach Windows, czy w kontenerach Linux, zachowuje tę samą jakość renderowania. Biblioteka automatycznie zarządza różnicami w ścieżkach między systemami operacyjnymi, poprawnie obsługując pliki w folderze wwwroot lub w innych lokalizacjach. W przypadku wdrożeń kontenerowych zapoznaj się z przewodnikiem wdrożeniowym Docker. Pakiet zawiera wszystkie niezbędne zależności dla każdej platformy i nie wymaga żadnej dodatkowej konfiguracji poza standardowymi wymaganiami ASP.NET Core.

W przypadku wdrożeń kontenerowych w środowisku produkcyjnym warto rozważyć poniższy przykład pliku Dockerfile:

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"]

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"]

Zacznij od bezpłatnej wersji próbnej i już dziś zmień możliwości swojej przeglądarki dokumentów.

Jakie są główne zalety korzystania z IronPDF do przeglądania plików PDF w ASP.NET Core?

IronPDF zmienia sposób obsługi plików PDF w aplikacjach ASP.NET Core, łącząc generowanie po stronie serwera z przeglądaniem w przeglądarce. Wystarczy kilka linii kodu, aby tworzyć profesjonalne pliki PDF z HTML, wyświetlać je w tekście, umożliwiać pobieranie oraz optymalizować pod kątem drukowania. Silnik renderujący oparty na przeglądarce Chrome zapewnia idealną dokładność pikselową na wszystkich platformach, eliminując potrzebę korzystania z programu Adobe Acrobat Reader lub przeglądarek innych firm.

To rozwiązanie do przeglądania plików PDF w .NET Core oferuje szeroki zakres funkcji, w tym wypełnianie formularzy, zaznaczanie tekstu, podpisy cyfrowe oraz możliwość edycji plików PDF. Komponent obsługuje również konwersję dokumentów WORD (pliki DOCX), arkuszy kalkulacyjnych Excel oraz obrazów do formatu PDF. Niezależnie od tego, czy tworzysz prostą przeglądarkę dokumentów, czy złożony system zarządzania dokumentami, IronPDF zapewnia narzędzia, których potrzebujesz.

Integracja tag helperów biblioteki oraz obszerna dokumentacja sprawiają, że wdrożenie jest proste. Twój projekt może wyświetlać pliki PDF bezpośrednio, podczas gdy przetwarzanie w tle zajmuje się złożonymi zadaniami związanymi z generowaniem plików PDF. Przeglądarka zachowuje spójne działanie niezależnie od tego, czy ładuje dane z folderu wwwroot, generuje je dynamicznie, czy pobiera z zewnętrznych źródeł. Dzięki wbudowanej obsłudze motywów i konfigurowalnym ustawieniom szerokości możesz idealnie dopasować wygląd do swojej aplikacji. Dla zespołów DevOps, pakiet IronPDF Slim oferuje zmniejszony rozmiar wdrożenia, rozwiązując ograniczenia rozmiaru kontenerów w środowiskach orkiestracyjnych.

Chcesz wdrożyć przeglądanie plików PDF w swojej aplikacji internetowej .NET Core?

Dla użytkowania produkcyjnego, licencje zaczynają się od $999 i obejmują kompleksowe wsparcie i aktualizacje. Odwiedź dokumentację API, aby uzyskać szczegółowe informacje o API i zaawansowanych funkcjach. Zapoznaj się z naszymi obszernymi przykładami kodu, aby szybko wdrożyć funkcjonalność PDF w swoich projektach ASP.NET Core.

![Strona licencyjna IronPDF przedstawiająca cztery poziomy licencji wieczystych (Lite, Plus, Professional i Unlimited) wraz z cenami, limitami dla programistów oraz przełącznikiem między opcjami IronPDF i Iron Suite. IronPDF oferuje różne opcje licencjonowania, począwszy od $999 dla pojedynczych deweloperów do $3,999 za nieograniczone użytkowanie, przy czym wszystkie licencje obejmują 1 rok wsparcia i aktualizacji.