Ikona wiadomości
Przejdź do treści stopki
  1. IronPDF
  2. Blog IronPDF
  3. Korzystanie z IronPDF
  4. Wyświetlanie plików PDF w przeglądarce ASP.NET PDF Viewer
KORZYSTANIE Z IRONPDF

Jak wyświetlać, zapisywać i drukować PDF-y w przeglądarce ASP.NET Core

Curtis Chau
Curtis Chau
Zaktualizowano:

Jak wyświetlać, zapisywać i drukować pliki PDF w przeglądarce ASP.NET Core

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 zawierają wbudowane przeglądarki plików PDF, które uruchamiają się po otrzymaniu pliku PDF o prawidłowym typie 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ę funkcję przeglądarki, generując wysokiej jakości pliki PDF po stronie serwera przy użyciu 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
SHELL

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. W przypadku wdrożeń Docker IronPDF zapewnia zoptymalizowane obrazy kontenerów, które minimalizują złożoność wdrożenia — jest to kluczowa kwestia dla inżynierów zarządzających środowiskami kontenerowymi.

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
$vbLabelText   $csharpLabel

Kod tworzy instancję ChromePdfRenderer i konfiguruje ją tak, aby uwzględniała kolory tła oraz konwertowała formularze HTML na formularze PDF. Metoda RenderHtmlAsPdf przekształca ciąg znaków HTML w plik PDF. Zwrócenie pliku PDF z typem MIME application/pdf powoduje, że przeglądarka wyświetla go bezpośrednio, zamiast pobierać go. 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

Interfejs przeglądarki plików PDF pokazujący prosty dokument faktury o numerze 12345 z datą 30.10.2025 r. Przeglądarka plików PDF ASP.NET Core z powodzeniem wyświetla wyrenderowany dokument faktury z elementami nawigacji po stronach i opcjami Zoom na pasku narzędzi.

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")
$vbLabelText   $csharpLabel

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 zarządzających architekturami mikrousług architektura silnika natywnego i zdalnego IronPDF zapewnia elastyczność wdrożenia. 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 wyświetlania ich bezpośrednio w przeglądarce, 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
$vbLabelText   $csharpLabel

Dodanie parametru nazwy pliku automatycznie ustawia nagłówek Content-Disposition na "załącznik", co powoduje, że przeglądarka pobiera plik. Użytkownicy mogą również zapisywać pliki PDF wyświetlane w tekście, korzystając z funkcji zapisywania 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

Przeglądarka PDF wyświetlająca dokument z tekstem Download Me i logo IronPDF for .NET, wyświetlany w przeglądarce przy Zoomie 100%. Przeglądarka plików PDF z powodzeniem wyświetla wygenerowany dokument faktury z włączoną funkcją pobierania za pośrednictwem IronPDF for .NET.

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

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

Ustawienie CssMediaType na Print powoduje zastosowanie stylów CSS specyficznych dla PRINT, zapewniając prawidłowy wygląd dokumentu po wydrukowaniu. 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.

Interfejs przeglądarki PDF pokazujący dokument zoptymalizowany do druku z komunikatem Ten dokument jest zoptymalizowany do druku wyświetlonym na środku białej strony. Przeglądarka plików PDF wyświetla komunikat potwierdzający, gdy dokument zostanie zoptymalizowany do drukowania, dzięki czemu użytkownicy wiedzą, że ich plik jest gotowy do wydruku w wysokiej jakości.

W jaki sposób IronPDF obsługuje wdrożenia wieloplatformowe 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.

Schemat obsługi wielu platform pokazujący kompatybilność .NET z wieloma wersjami, systemami operacyjnymi, platformami chmurowymi i środowiskami programistycznymi. Kompleksowa obsługa wielu platform przez IronPDF obejmuje kompatybilność z .NET 9 poprzez Framework 4.6.2+, działa na systemach Windows, Linux i Mac oraz integruje się z głównymi dostawcami usług w chmurze i narzędziami programistycznymi.

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

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 problem ograniczeń rozmiaru kontenerów w środowiskach orkiestrowanych.

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

W przypadku użytkowania produkcyjnego ceny licencji zaczynają się od $799 i obejmują kompleksowe wsparcie oraz 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 licencyjne, od 749 USD dla pojedynczych programistów do 3999 USD za nieograniczone użytkowanie, przy czym wszystkie licencje obejmują roczną pomoc techniczną i aktualizacje.

Często Zadawane Pytania

Jak wyświetlić pliki PDF w aplikacji .NET Core?

W aplikacji ASP.NET Core można wyświetlać pliki PDF za pomocą biblioteki IronPDF, która zapewnia funkcje renderowania plików PDF bezpośrednio w aplikacji.

Jakie kroki należy wykonać, aby zapisać plik PDF w ASP.NET Core przy użyciu IronPDF?

Aby zapisać plik PDF w ASP.NET Core, można użyć wbudowanych metod IronPDF do konwersji dokumentu do formatu PDF, a następnie zapisać go w systemie plików lub strumieniu.

Czy w aplikacjach .NET Core można drukować pliki PDF?

Tak, IronPDF umożliwia drukowanie plików PDF bezpośrednio z aplikacji ASP.NET Core przy użyciu funkcji renderowania i drukowania.

Jakie są zalety korzystania z IronPDF w ASP.NET Core?

IronPDF oferuje płynną integrację z ASP.NET Core, umożliwiając łatwą obsługę plików PDF, taką jak przeglądanie, zapisywanie i drukowanie, przy minimalnej konfiguracji.

Czy IronPDF obsługuje duże dokumenty PDF w ASP.NET Core?

Tak, IronPDF jest zoptymalizowany pod kątem wydajnej obsługi dużych dokumentów PDF, zapewniając płynne działanie nawet w przypadku złożonych plików.

Czy IronPDF obsługuje adnotacje i komentarze w plikach PDF w ASP.NET Core?

IronPDF obsługuje dodawanie i odczytywanie adnotacji oraz komentarzy w plikach PDF, zwiększając interaktywność i użyteczność dokumentów PDF w aplikacji ASP.NET Core.

Jak zintegrować IronPDF z istniejącym projektem ASP.NET Core?

Możesz zintegrować IronPDF ze swoim projektem ASP.NET Core, instalując pakiet IronPDF NuGet i używając jego API do zarządzania plikami PDF.

Czy istnieją jakieś konkretne wymagania systemowe dotyczące korzystania z IronPDF w ASP.NET Core?

IronPDF wymaga środowiska .NET Core lub .NET 5+ i obsługuje wszystkie główne systemy operacyjne, co czyni go elastycznym wyborem dla projektów ASP.NET Core.

Czy IronPDF może konwertować inne formaty plików do formatu PDF w ASP.NET Core?

Tak, IronPDF może konwertować różne formaty plików, takie jak HTML, obrazy i dokumenty, do formatu PDF w środowisku ASP.NET Core.

Jakiego rodzaju wsparcie oferuje IronPDF dla programistów ASP.NET Core?

IronPDF zapewnia obszerną dokumentację, przykłady kodu i responsywne wsparcie, aby pomóc programistom ASP.NET Core we wdrażaniu funkcji PDF.

Curtis Chau
Curtis Chau
  Czat z zespołem inżynierów teraz
Autor tekstów technicznych

Curtis Chau posiada tytuł licencjata z informatyki (Uniwersytet Carleton) i specjalizuje się w front-endowym rozwoju, z ekspertką w Node.js, TypeScript, JavaScript i React. Pasjonuje się tworzeniem intuicyjnych i estetycznie przyjemnych interfejsów użytkownika, Curtis cieszy się pracą z nowoczesnymi frameworkami i tworzeniem dobrze zorganizowanych, atrakcyjnych wizualnie podrę...

Czytaj więcej

Powiązane artykuły

30-dniowy okres próbny → Pełna wersja produktu. Bez ograniczeń. Bez karty. Bezpłatna próba

Zespol wsparcia Iron

Jestesmy online 24 godziny, 5 dni w tygodniu.
Czat
Email
Zadzwon do mnie