Ikona wiadomości
Przejdź do treści stopki
  1. IronPDF
  2. Blog IronPDF
  3. Korzystanie z IronPDF
  4. Asp .NET Core Przeglądarka PDF
KORZYSTANIE Z IRONPDF

Jak zbudować przeglądarkę plików PDF dla ASP.NET Core przy użyciu IronPDF

Curtis Chau
Curtis Chau
Zaktualizowano:

Wyświetlanie dokumentów PDF bezpośrednio w przeglądarce internetowej jest powszechnym wymaganiem w nowoczesnych aplikacjach 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 wtyczek innych firm, takich jak Adobe Acrobat Reader. IronPDF ułatwia to, zapewniając generowanie plików PDF po stronie serwera i strumieniowanie za pośrednictwem silnika renderującego opartego na przeglądarce Chrome — bez konieczności korzystania z zewnętrznych przeglądarek.

Ten samouczek pokazuje, jak wyświetlać, zapisywać i drukować pliki PDF w ASP.NET Core przy użyciu IronPDF. Dowiesz się również, w jaki sposób biblioteka obsługuje wdrożenia kontenerowe i chmurowe, co czyni ją niezawodnym wyborem dla produkcyjnych potoków DevOps.

Baner promocyjny biblioteki IronPDF C# PDF podkreślający konwersję HTML do PDF, narzędzia do edycji, elastyczność wdrożenia oraz ofertę bezpłatnej wersji próbnej

W jaki sposób przeglądarki wyświetlają pliki PDF w treści strony?

Nowoczesne przeglądarki zawierają wbudowane przeglądarki plików PDF, które uruchamiają się po otrzymaniu odpowiedzi o typie MIME application/pdf. Gdy kontroler ASP.NET Core zwraca plik PDF z prawidłowym nagłówkiem Content-Type, przeglądarka renderuje go automatycznie w trybie inline — bez konieczności instalowania wtyczek. Zgodnie z dokumentacją MDN Web Docs prawidłowa konfiguracja typu MIME ma zasadnicze znaczenie dla kontrolowania sposobu, w jaki przeglądarki obsługują odpowiedzi plików.

IronPDF generuje pliki PDF po stronie serwera za pomocą klasy ChromePdfRenderer, która zawiera wbudowany silnik Chromium. Oznacza to, że dokumenty są renderowane z pełną obsługą CSS, JavaScript, czcionek internetowych i podpisów cyfrowych — ten sam proces renderowania, który wykorzystuje przeglądarka Google Chrome. Wynikiem jest idealnie dopasowany obraz, który przeglądarki wyświetlają bezpośrednio bez konieczności korzystania z biblioteki do wyświetlania po stronie klienta.

W środowiskach kontenerowych ta architektura jest szczególnie cenna. Renderer działa całkowicie w ramach procesu, bez uruchamiania zewnętrznych procesów przeglądarki bezinterfejsowej ani korzystania z usług zdalnych. Oczyszczanie zasobów odbywa się automatycznie, zapobiegając wyciekom pamięci w długo działających usługach ASP.NET Core. Możesz zapoznać się z pełnym zestawem funkcji IronPDF, aby zrozumieć wszystkie dostępne możliwości renderowania.

Czterokolumnowa tabela funkcji przedstawiająca możliwości oprogramowania do obsługi plików PDF: Tworzenie plików PDF, Konwersja plików PDF, Edycja plików PDF oraz Podpisywanie i zabezpieczanie plików PDF, wraz ze szczegółowymi listami funkcji w każdej kategorii

Dlaczego renderowanie po stronie serwera zapewnia spójne wyniki?

Renderowanie po stronie serwera eliminuje zmienność przeglądarek z procesu generowania plików PDF. Gdy pliki PDF są generowane po stronie klienta, jakość wyjściowa zależy od wersji przeglądarki użytkownika końcowego, systemu operacyjnego oraz zainstalowanych czcionek. Dzięki IronPDF ten sam silnik Chromium działa na każdym serwerze — niezależnie od tego, czy jest to system Windows, Linux czy kontener Docker — gwarantując identyczny wynik dla dokumentów zgodności, faktur i podpisanych umów.

Co oferuje silnik Chrome w porównaniu z prostymi konwerterami HTML na PDF?

Proste konwertery HTML na PDF często pomijają wykonywanie kodu JavaScript, ignorują zapytania o media CSS lub generują słabą typografię. Silnik IronPDF dla przeglądarki Chrome czeka na zakończenie działania JavaScript, obsługuje style @media print, obsługuje grafikę SVG oraz obsługuje kodowanie znaków UTF-8 dla treści międzynarodowych. Ta wierność ma znaczenie przy wyświetlaniu dokumentów, które użytkownicy będą również drukować lub archiwizować.

Jak zainstalować IronPDF w projekcie ASP.NET Core?

Utworzenie nowego projektu .NET Core wymaga jednego polecenia. Otwórz terminal i uruchom:

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

Następnie zainstaluj pakiet IronPDF NuGet. Można użyć konsoli menedżera pakietów lub interfejsu CLI platformy .NET:

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

To instaluje wszystko, co jest potrzebne — silnik Chrome, biblioteki do przetwarzania plików PDF oraz wszystkie zależności specyficzne dla platformy. IronPDF obsługuje platformy .NET 6, 7, 8, 9 i 10 bez konieczności dodatkowej konfiguracji środowiska. Dokumentacja IronPDF obejmuje zaawansowane opcje instalacji, w tym niewielkie pakiety przeznaczone do wdrożeń o ograniczonej wielkości, takich jak AWS Lambda.

Konsola menedżera pakietów Visual Studio wyświetlająca postęp instalacji pakietu IronPDF NuGet, pokazująca pobieranie wielu zależności, w tym komponentów Iron Software, gRPC i System.Threading.Channels

Który wariant pakietu wybrać?

W przypadku standardowych wdrożeń należy użyć IronPdf. W środowiskach o ścisłych ograniczeniach rozmiaru — takich jak AWS Lambda lub funkcje brzegowe — pakiet IronPdf.Slim zmniejsza początkowy rozmiar pliku do pobrania. Oba warianty udostępniają ten sam interfejs API, więc zmiana nie wymaga żadnych zmian w kodzie.

Jakie są typowe problemy związane z instalacją w środowiskach kontenerowych?

Kontenery Linux czasami wymagają dodatkowych bibliotek systemowych do operacji graficznych. Minimalna konfiguracja pliku Dockerfile obejmuje:

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

Kontenery Windows zazwyczaj działają bez dodatkowych zależności. W celu rozwiązywania problemów należy włączyć wbudowane logowanie IronPDF, aby wychwycić błędy renderowania, zanim pojawią się one jako odpowiedzi HTTP 500.

Jak wyświetlić plik PDF w przeglądarce?

Aby zwrócić plik PDF do przeglądania w przeglądarce, trzeba zrobić trzy rzeczy: wygenerować plik PDF, ustawić typ MIME application/pdf i pominąć parametr nazwy pliku w wyniku File(). Oto kompletna akcja kontrolera:

using IronPdf;
using Microsoft.AspNetCore.Mvc;

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

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

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

        var pdf = renderer.RenderHtmlAsPdf(html);

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

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

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

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

        var pdf = renderer.RenderHtmlAsPdf(html);

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

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

' PdfController.vb
Public Class PdfController
    Inherits Controller

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

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

        Dim pdf = renderer.RenderHtmlAsPdf(html)

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

Kluczowe znaczenie ma wywołanie File(): zwrócenie application/pdf bez nazwy pliku ustawia Content-Disposition: inline, co uruchamia wbudowaną przeglądarkę plików PDF. Dodanie nazwy pliku powoduje przejście do Content-Disposition: attachment, co uruchamia pobieranie. Aby uzyskać więcej wzorców konwersji HTML, zapoznaj się z przewodnikiem dotyczącym konwersji ciągów HTML do formatu PDF.

W przypadku aplikacji o dużym natężeniu ruchu należy stosować metodę renderowania asynchronicznego, aby uniknąć blokowania wątków:

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

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

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

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

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

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

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

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

Przykład podstawowej faktury w formacie PDF wyświetlanej w internetowej przeglądarce plików PDF ze standardowymi elementami nawigacyjnymi

Kiedy warto korzystać z asynchronicznego generowania plików PDF?

Generowanie asynchroniczne jest ważne dla każdego punktu końcowego, który odbiera równoczesne żądania. Generowanie synchroniczne blokuje wątki puli wątków .NET Core, zmniejszając liczbę jednoczesnych żądań, które aplikacja może obsłużyć. Warto wcześnie przejść na metody asynchroniczne — interfejs API jest identyczny, więc migracja jest prosta.

Jakie inne źródła HTML można renderować?

Oprócz ciągów znaków HTML, IronPDF renderuje z adresów URL, plików HTML na dysku oraz widoków Razor. Wywołanie renderer.RenderUrlAsPdf("https://example.com/report") przechwytuje aktywny adres URL, natomiast renderer.RenderHtmlFileAsPdf("wwwroot/templates/invoice.html") odczytuje dane z lokalnego systemu plików. Ta elastyczność oznacza, że można ponownie wykorzystać istniejące szablony Razor jako szablony PDF bez konieczności utrzymywania oddzielnych plików HTML. Wpis dotyczący IronPdf w galerii NuGet zawiera informacje o aktualnej wersji pakietu oraz informacje o wydaniu.

Jak włączyć pobieranie plików PDF w ASP.NET Core?

Wywołanie pobierania pliku zamiast wyświetlania wbudowanego to zmiana jednego parametru. Dodanie nazwy pliku do File() powoduje ustawienie nagłówka Content-Disposition na attachment:

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

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

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

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

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

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

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

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

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

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

W przypadku dużych dokumentów udostępnianych wielu użytkownikom strumieniowanie zmniejsza szczytowe zużycie pamięci:

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

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

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

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

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

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

    Dim stream = pdf.Stream
    stream.Position = 0

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

Streaming wysyła dane PDF stopniowo, co znacznie zmniejsza szczytowe zużycie pamięci podczas dostarczania dużych plików wielu użytkownikom jednocześnie. Aby uzyskać informacje na temat dodatkowych wzorców eksportu, zapoznaj się z przewodnikiem dotyczącym łączenia i dzielenia plików PDF oraz wyodrębniania tekstu z plików PDF.

Przykład dokumentu PDF wygenerowanego przy użyciu IronPDF for .NET, wyświetlonego w standardowym interfejsie przeglądarki PDF

Jakie ustawienia kompresji najlepiej sprawdzają się w przypadku różnych typów dokumentów?

Text-heavy PDFs compress well at 70-80% image quality with minimal visual impact. Dokumenty zawierające dużo obrazów, takie jak broszury marketingowe, wymagają jakości na poziomie 85–95%, aby zachować przejrzystość. W sprawozdaniach finansowych zawierających wykresy należy zachować poziom 85% lub wyższy, aby zapewnić czytelność wykresów. Przed wdrożeniem do środowiska produkcyjnego należy przetestować poziomy kompresji na reprezentatywnych dokumentach.

Jak generować pliki PDF gotowe do druku w ASP.NET Core?

Pliki PDF gotowe do druku wymagają określonej konfiguracji strony: typu mediów CSS do druku, zdefiniowanych marginesów i wyraźnego rozmiaru papieru. IronPDF udostępnia wszystkie te elementy poprzez RenderingOptions:

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

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

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

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

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

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

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

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

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

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

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

Ustawienie CssMediaType.Print aktywuje reguły CSS @media print przed renderowaniem. Spowoduje to ukrycie pasków nawigacyjnych, pasków bocznych i innych elementów wyświetlanych wyłącznie na ekranie. Użytkownicy mogą następnie wydrukować plik PDF z wbudowanej przeglądarki, używając standardowych skrótów klawiaturowych, z pełną kontrolą nad wyborem drukarki i liczbą kopii. Aby zapoznać się z zaawansowanymi wzorcami nagłówków i stopek, zobacz przewodnik dotyczący nagłówków i stopek.

Można również dodawać znaki wodne do drukowanych dokumentów, podpisywać je cyfrowo przed dostarczeniem lub chronić je za pomocą hasła i ustawień uprawnień. Funkcje te integrują się bezpośrednio poprzez interfejs API PdfDocument bez konieczności wykonywania oddzielnego etapu przetwarzania.

Przykład dokumentu PDF gotowego do druku, tak jak wygląda on w standardowej przeglądarce PDF, pokazujący charakterystyczne formatowanie dla wydruku

Jaka konfiguracja strony zapewnia kompatybilność między drukarkami?

Standardowe formaty A4 lub Letter z marginesami 20–25 mm działają niezawodnie na wszystkich modelach drukarek. Należy unikać niestandardowych rozmiarów papieru, chyba że wdrożenie jest przeznaczone dla znanej floty drukarek. Zamiast zastrzeżonych metod podziału stron należy używać właściwości CSS page-break-before i page-break-after. Specyfikacja W3C CSS Paged Media szczegółowo definiuje te właściwości. Te standardowe właściwości CSS działają spójnie zarówno w silniku renderującym przeglądarki Chrome, jak i w drukarkach fizycznych.

Jak wdrożyć przeglądarkę plików PDF ASP.NET Core w Dockerze?

IronPDF działa na kontenerach Linux i Windows bez konieczności wprowadzania zmian w kodzie. Obrazy bazowe użyte w poniższym pliku Dockerfile pochodzą z oficjalnych obrazów kontenerów .NET firmy Microsoft, które są regularnie aktualizowane o poprawki bezpieczeństwa. Poniższa konfiguracja Docker instaluje wymagane biblioteki systemowe i tworzy wieloetapową kompilację w celu uzyskania obrazu o minimalnym rozmiarze:

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

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

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

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

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

W przypadku wdrożeń Kubernetes należy dodać punkt końcowy sprawdzania stanu, który weryfikuje generowanie plików PDF od początku do końca:

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

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

Ta kontrola stanu pozwala Kubernetes wykrywać i zastępować nieprawidłowo działające pody, zanim użytkownicy napotkają błędy. Integruje się również ze standardowym oprogramowaniem pośredniczącym do monitorowania stanu ASP.NET Core. Licencja Trial IronPDF obejmuje pełną funkcjonalność do testowania w środowisku Docker bez żadnych ograniczeń.

Jakie są zalety wdrożenia renderera wbudowanego w proces?

Poniższa tabela porównuje podejście IronPDF oparte na przetwarzaniu w tle z konfiguracjami serwerów z przeglądarką bezinterfejsową, powszechnie stosowanymi do generowania plików PDF po stronie serwera:

Porównanie metod generowania plików PDF dla ASP.NET Core
Czynnik IronPDF (w trakcie przetwarzania) Serwer przeglądarki bezinterfejsowej
Złożoność wdrożenia Tylko pakiet NuGet Oddzielny proces lub usługa
Opóźnienie sieciowe Brak (w trakcie) Liczba operacji HTTP w obie strony na żądanie
Zajmowana przestrzeń przez kontener Pojedynczy kontener Co najmniej dwa kontenery
Monitorowanie stanu Standardowe oprogramowanie pośredniczące .NET Core Oddzielna kontrola stanu usługi
Spójność renderowania Silnik Chrome, wersja zablokowana Różni się w zależności od wersji przeglądarki

Jak dodać zaawansowane funkcje PDF do przeglądarki?

IronPDF wykracza daleko poza podstawowe funkcje przeglądania i pobierania. Ta sama biblioteka, która renderuje HTML do formatu PDF, zapewnia również obsługę formularzy PDF, niestandardowe znaki wodne, podpisy cyfrowe oraz konwersję plików PDF na obrazy — wszystko to bez dodatkowych pakietów.

W ramach procesów zarządzania dokumentami można konwertować przesłane pliki do formatu PDF, wyodrębniać tekst do indeksowania, dodawać adnotacje do dokumentów i dostarczać je z powrotem użytkownikom — wszystko to w ramach jednego kontrolera ASP.NET Core. Strona poświęcona funkcjom IronPDF zawiera kompletny przegląd możliwości wraz z przykładami kodu dla każdego obszaru funkcji.

Kluczowe funkcje, na które warto zwrócić uwagę w aplikacjach do przeglądania:

  • Wyodrębnianie tekstu — indeksowanie zawartości plików PDF w celu wyszukiwania lub archiwizacji zgodnej z przepisami
  • Łączenie i dzielenie — łączenie wielu dokumentów lub wyodrębnianie określonych stron
  • Znak wodny — umieszczanie na dokumentach informacji o poufności lub znaków firmowych przed wyświetleniem
  • Podpisy cyfrowe — podpisywanie wygenerowanych plików PDF przed przesłaniem ich do przeglądarki
  • Nagłówki i stopki — dodaj numery stron, tytuły dokumentów i linie oddzielające

Jak radzisz sobie z zabezpieczeniami plików PDF i kontrolą dostępu?

W przypadku aplikacji wyświetlających poufne dokumenty należy połączyć funkcje haseł i uprawnień IronPDF z oprogramowaniem pośredniczącym do autoryzacji ASP.NET Core. Ustaw akcję kontrolera tak, aby wymagała uwierzytelnienia, a następnie przesyłaj strumieniowo plik PDF — dokument nigdy nie trafia do systemu plików ani do nieautoryzowanego punktu końcowego.

Aby spełnić wymagania dotyczące ścieżki audytu, przed przesyłaniem strumieniowym należy podpisać cyfrowo pliki PDF. Podpis rejestruje znacznik czasu podpisania i weryfikuje integralność dokumentu, co jest ważne w przypadku dokumentów finansowych i prawnych wyświetlanych w przeglądarce.

Jakie opcje licencyjne są dostępne?

Licencjonowanie IronPDF rozpoczyna się od bezpłatnej wersji próbnej, która obejmuje pełną funkcjonalność — odpowiednią do prac związanych z rozwojem, wdrażaniem i weryfikacją koncepcji w środowiskach Docker i Kubernetes. Licencje produkcyjne obejmują szeroki zakres scenariuszy wdrożeniowych, od wdrożeń dla pojedynczego programisty po wdrożenia na nieograniczonej liczbie serwerów.

Dokumentacja IronPDF zawiera szczegółowe informacje o API, przewodniki dotyczące migracji między wersjami .NET oraz instrukcje konfiguracji dla poszczególnych platform, takich jak Windows, Linux, macOS, AWS i Azure.

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

Wbudowanie przeglądarki plików PDF w ASP.NET Core zajmuje zaledwie kilka minut dzięki IronPDF. Silnik renderujący oparty na przeglądarce Chrome obsługuje złożony proces konwersji HTML do PDF, wynik ASP.NET Core File() obsługuje zachowanie wbudowane w porównaniu z pobieraniem, a ten sam pakiet obejmuje drukowanie, znak wodny, podpisy cyfrowe i wdrożenia kontenerowe. Zacznij od bezpłatnej wersji próbnej i dodawaj zaawansowane funkcje dokumentów w miarę wzrostu wymagań.

Często Zadawane Pytania

W jaki sposób IronPDF może pomóc w wyświetlaniu plików PDF w aplikacjach ASP.NET Core?

IronPDF upraszcza ten proces, wykorzystując potężny silnik renderujący oparty na przeglądarce Chrome do wyświetlania plików PDF bezpośrednio w przeglądarkach internetowych bez konieczności pobierania lub instalowania dodatkowych wtyczek.

Jakie są zalety korzystania z przeglądarki plików PDF w ASP.NET Core?

Korzystanie z przeglądarki plików PDF, takiej jak IronPDF w ASP.NET Core, poprawia komfort użytkowania, umożliwiając płynne przeglądanie, zapisywanie i drukowanie plików PDF w przeglądarce, eliminując potrzebę korzystania z zewnętrznych aplikacji, takich jak Adobe Acrobat Reader.

Czy do przeglądania plików PDF w IronPDF konieczne jest zainstalowanie programu Adobe Acrobat Reader?

Nie, IronPDF umożliwia przeglądanie plików PDF bezpośrednio w przeglądarce, eliminując potrzebę korzystania z programu Adobe Acrobat Reader lub jakichkolwiek innych wtyczek.

Jakie typy dokumentów można wyświetlać za pomocą IronPDF w aplikacji ASP.NET Core?

IronPDF może być używany do płynnego wyświetlania różnych typów dokumentów, takich jak faktury, raporty i umowy, w aplikacjach ASP.NET Core.

Czy IronPDF obsługuje drukowanie dokumentów PDF w ASP.NET Core?

Tak, IronPDF obsługuje drukowanie dokumentów PDF bezpośrednio z aplikacji internetowej, zapewniając kompleksowe rozwiązanie do zarządzania plikami PDF.

Czy IronPDF może dokładnie renderować złożone układy PDF w ASP.NET Core?

IronPDF wykorzystuje silnik renderujący oparty na przeglądarce Chrome do dokładnego renderowania złożonych układów PDF, zapewniając wysoką jakość wyświetlania bez utraty wierności.

Czy muszę pobierać pliki PDF, aby wyświetlać je za pomocą IronPDF w ASP.NET Core?

Nie, IronPDF pozwala użytkownikom przeglądać pliki PDF bezpośrednio w przeglądarce internetowej bez konieczności ich pobierania.

W jaki sposób IronPDF poprawia komfort przeglądania plików PDF w aplikacjach internetowych?

IronPDF poprawia komfort przeglądania plików PDF, oferując płynną integrację z ASP.NET Core, co pozwala użytkownikom przeglądać, zapisywać i drukować pliki PDF bezpośrednio w przeglądarce.

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