Jak wyświetlać PDF w panelu ASP.NET przy użyciu IronPDF

Jak działa renderowanie plików PDF po stronie serwera w ASP.NET?

IronPDF przenosi renderowanie plików PDF całkowicie na serwer, wykorzystując silnik Chrome bez interfejsu graficznego. Kontroler generuje lub pobiera dokument PDF, konwertuje go na tablicę bajtów i przesyła strumieniowo do przeglądarki z nagłówkiem inline Content-Disposition. Wbudowana przeglądarka PDF w przeglądarce wyświetla następnie dokument wewnątrz elementu <iframe> osadzonego w panelu.

Ta fundamentalna Shift eliminuje tradycyjne problemy:

• Na komputerze klienta nie jest wymagany program Adobe Reader ani rozszerzenie przeglądarki
• Spójne wyświetlanie niezależnie od systemu operacyjnego użytkownika lub wersji przeglądarki
• Pełna programowa kontrola nad treścią, układem i stylem dokumentu
• Działa w środowiskach Enterprise, w których polityki IT blokują instalację wtyczek

Silnik renderujący biblioteki w przeglądarce Chrome generuje obraz o idealnej rozdzielczości na podstawie HTML, adresów URL i surowych źródeł treści. Kontrolujesz każdy aspekt wydruku — rozmiar papieru, marginesy, nagłówki, stopki i typ mediów CSS — zanim plik PDF trafi do klienta.

IronPDF obsługuje również wdrażanie wieloplatformowe na serwerach z systemami Windows, Linux i macOS, dzięki czemu nadaje się do aplikacji ASP.NET hostowanych w chmurze, działających na platformach Azure lub AWS, a także w środowiskach kontenerowych wykorzystujących Docker.

Jak skonfigurować pakiet NuGet?

Otwórz program Visual Studio, kliknij prawym przyciskiem myszy swój projekt w Eksploratorze rozwiązań i wybierz opcję Zarządzaj pakietami NuGet. Wyszukaj IronPdf i zainstaluj go. Alternatywnie, uruchom to polecenie w konsoli menedżera pakietów:

Install-Package IronPdf

Można również używać interfejsu CLI platformy .NET z dotnet add package IronPdf. Po zainstalowaniu dodaj using IronPdf; na początku klasy kontrolera lub usługi, aby uzyskać dostęp do przestrzeni nazw biblioteki.

Aby zapewnić optymalne dostarczanie plików PDF, skonfiguruj Program.cs do obsługi plików statycznych i ustaw routing:

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllersWithViews();
builder.Services.AddRazorPages();

var app = builder.Build();

app.UseStaticFiles();
app.UseRouting();

app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");

app.Run();

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllersWithViews();
builder.Services.AddRazorPages();

var app = builder.Build();

app.UseStaticFiles();
app.UseRouting();

app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");

app.Run();

Imports Microsoft.AspNetCore.Builder
Imports Microsoft.Extensions.DependencyInjection

Dim builder = WebApplication.CreateBuilder(args)

builder.Services.AddControllersWithViews()
builder.Services.AddRazorPages()

Dim app = builder.Build()

app.UseStaticFiles()
app.UseRouting()

app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}")

app.Run()

Rejestracja AddControllersWithViews() umożliwia zarówno punkty końcowe API, jak i renderowanie widoku — oba są potrzebne, gdy chcesz udostępniać zawartość PDF za pośrednictwem dedykowanych akcji kontrolera i wyświetlać ją w panelach widoku Razor. Pełne informacje dotyczące konfiguracji można znaleźć w dokumentacji API IronPDF.

Jak wyświetlić plik PDF bezpośrednio w panelu?

Podstawowy schemat jest prosty: akcja kontrolera generuje plik PDF, konwertuje go na bajty, ustawia nagłówek Content-Disposition na inline i zwraca wynik File. <iframe> w widoku Razor wskazuje ten punkt końcowy.

Oto kompletna implementacja kontrolera:

[ApiController]
[Route("api/[controller]")]
public class PdfPanelController : ControllerBase
{
    [HttpGet("display/{documentId}")]
    public IActionResult DisplayPdfInPanel(string documentId)
    {
        var renderer = new ChromePdfRenderer();

        string filename = $"document_{documentId}.pdf";

        var htmlContent = $@"
            <html>
            <head>
                <style>
                    body {{ font-family: Arial, sans-serif; margin: 40px; }}
                    h1 {{ color: #333; }}
                    .content {{ line-height: 1.6; }}
                </style>
            </head>
            <body>
                <h1>Document #{documentId}</h1>
                <div class='content'>
                    <p>This PDF is generated dynamically and displayed inline in your panel.</p>
                    <p>Generated at: {DateTime.Now:yyyy-MM-dd HH:mm:ss}</p>
                </div>
            </body>
            </html>";

        using var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);

        byte[] pdfBytes = pdfDocument.BinaryData;

        Response.Headers.Append("Content-Disposition", $"inline; filename={filename}");

        return File(pdfBytes, "application/pdf");
    }
}

[ApiController]
[Route("api/[controller]")]
public class PdfPanelController : ControllerBase
{
    [HttpGet("display/{documentId}")]
    public IActionResult DisplayPdfInPanel(string documentId)
    {
        var renderer = new ChromePdfRenderer();

        string filename = $"document_{documentId}.pdf";

        var htmlContent = $@"
            <html>
            <head>
                <style>
                    body {{ font-family: Arial, sans-serif; margin: 40px; }}
                    h1 {{ color: #333; }}
                    .content {{ line-height: 1.6; }}
                </style>
            </head>
            <body>
                <h1>Document #{documentId}</h1>
                <div class='content'>
                    <p>This PDF is generated dynamically and displayed inline in your panel.</p>
                    <p>Generated at: {DateTime.Now:yyyy-MM-dd HH:mm:ss}</p>
                </div>
            </body>
            </html>";

        using var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);

        byte[] pdfBytes = pdfDocument.BinaryData;

        Response.Headers.Append("Content-Disposition", $"inline; filename={filename}");

        return File(pdfBytes, "application/pdf");
    }
}

Imports Microsoft.AspNetCore.Mvc
Imports System

<ApiController>
<Route("api/[controller]")>
Public Class PdfPanelController
    Inherits ControllerBase

    <HttpGet("display/{documentId}")>
    Public Function DisplayPdfInPanel(documentId As String) As IActionResult
        Dim renderer = New ChromePdfRenderer()

        Dim filename As String = $"document_{documentId}.pdf"

        Dim htmlContent As String = $"
            <html>
            <head>
                <style>
                    body {{ font-family: Arial, sans-serif; margin: 40px; }}
                    h1 {{ color: #333; }}
                    .content {{ line-height: 1.6; }}
                </style>
            </head>
            <body>
                <h1>Document #{documentId}</h1>
                <div class='content'>
                    <p>This PDF is generated dynamically and displayed inline in your panel.</p>
                    <p>Generated at: {DateTime.Now:yyyy-MM-dd HH:mm:ss}</p>
                </div>
            </body>
            </html>"

        Using pdfDocument = renderer.RenderHtmlAsPdf(htmlContent)
            Dim pdfBytes As Byte() = pdfDocument.BinaryData

            Response.Headers.Append("Content-Disposition", $"inline; filename={filename}")

            Return File(pdfBytes, "application/pdf")
        End Using
    End Function
End Class

Klasa ChromePdfRenderer jest głównym punktem wejścia dla renderowania po stronie serwera. Akceptuje treści HTML, konwertuje je za pomocą przeglądarki Chrome bez interfejsu użytkownika i zwraca obiekt PdfDocument. Właściwość BinaryData udostępnia surowe bajty do strumieniowania.

Ustawienie Content-Disposition na inline jest kluczowym krokiem dla wyświetlania na panelu. W przeciwnym razie przeglądarka wyświetli monit o pobranie pliku zamiast wyświetlić go wewnątrz <iframe>. Można również dodawać nagłówki i stopki do każdej strony lub kontrolować orientację strony i niestandardowe marginesy za pomocą RenderingOptions.

Aby osadzić ten punkt końcowy w panelu Razor, utwórz <iframe> wskazujący na trasę kontrolera:

@page
@model IndexModel

<div class="container mt-4">
    <div class="card">
        <div class="card-header">
            <h3>PDF Display Panel</h3>
        </div>
        <div class="card-body">
            <div class="pdf-panel" style="height: 600px;">
                <iframe src="/api/PdfPanel/display/12345"
                        width="100%"
                        height="100%"
                        frameborder="0">
                </iframe>
            </div>
        </div>
    </div>
</div>

@page
@model IndexModel

<div class="container mt-4">
    <div class="card">
        <div class="card-header">
            <h3>PDF Display Panel</h3>
        </div>
        <div class="card-body">
            <div class="pdf-panel" style="height: 600px;">
                <iframe src="/api/PdfPanel/display/12345"
                        width="100%"
                        height="100%"
                        frameborder="0">
                </iframe>
            </div>
        </div>
    </div>
</div>

The provided code is a Razor page markup, which is not directly translatable to VB.NET as it is not C# code. Razor pages are used in ASP.NET Core for creating dynamic web pages and are written in a combination of HTML and C#.

If you need to convert the C# logic within a Razor page to VB.NET, you would typically focus on the code-behind file or any C# code embedded within the Razor markup. However, the provided snippet contains only HTML and Razor directives without any C# logic to convert.

If you have a specific C# code-behind logic or embedded C# code within a Razor page that you need to convert to VB.NET, please provide that portion, and I can assist with the conversion.

<iframe> żąda pliku PDF z punktu końcowego kontrolera. W tym momencie zadanie przejmuje wbudowana przeglądarka plików PDF, wyświetlając dokument na całej szerokości i wysokości panelu bez żadnych bibliotek ani wtyczek po stronie klienta.

Jak dynamicznie ładować pliki PDF za pomocą AJAX?

Statyczne źródła <iframe> sprawdzają się w przypadku stałej treści, ale wiele aplikacji wymaga ładowania plików PDF w oparciu o działania użytkownika — kliknięcie rekordu w tabeli danych, przesłanie formularza lub wybór typu raportu. Podejście oparte na AJAX pozwala obsługiwać te scenariusze bez konieczności ponownego ładowania całej strony.

Akcja kontrolera przyjmuje treść żądania i zwraca plik PDF jako ciąg znaków w formacie base64:

[HttpPost("generate")]
public async Task<IActionResult> GenerateDynamicPdf([FromBody] PdfRequestModel request)
{
    try
    {
        var renderer = new ChromePdfRenderer();

        renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
        renderer.RenderingOptions.MarginTop = 20;
        renderer.RenderingOptions.MarginBottom = 20;
        renderer.RenderingOptions.MarginLeft = 20;
        renderer.RenderingOptions.MarginRight = 20;

        var htmlBuilder = new StringBuilder();
        htmlBuilder.Append("<html><body>");
        htmlBuilder.Append($"<h2>{request.Title}</h2>");
        htmlBuilder.Append($"<div>{request.Content}</div>");

        if (request.IncludeData)
        {
            htmlBuilder.Append("<table border='1' style='width:100%;'>");
            foreach (var item in request.DataItems)
            {
                htmlBuilder.Append($"<tr><td>{item.Key}</td><td>{item.Value}</td></tr>");
            }
            htmlBuilder.Append("</table>");
        }

        htmlBuilder.Append("</body></html>");

        var pdfDocument = await Task.Run(() =>
            renderer.RenderHtmlAsPdf(htmlBuilder.ToString()));

        var base64Pdf = Convert.ToBase64String(pdfDocument.BinaryData);

        return Ok(new { success = true, pdfData = base64Pdf });
    }
    catch (Exception ex)
    {
        return BadRequest(new { success = false, error = ex.Message });
    }
}

[HttpPost("generate")]
public async Task<IActionResult> GenerateDynamicPdf([FromBody] PdfRequestModel request)
{
    try
    {
        var renderer = new ChromePdfRenderer();

        renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
        renderer.RenderingOptions.MarginTop = 20;
        renderer.RenderingOptions.MarginBottom = 20;
        renderer.RenderingOptions.MarginLeft = 20;
        renderer.RenderingOptions.MarginRight = 20;

        var htmlBuilder = new StringBuilder();
        htmlBuilder.Append("<html><body>");
        htmlBuilder.Append($"<h2>{request.Title}</h2>");
        htmlBuilder.Append($"<div>{request.Content}</div>");

        if (request.IncludeData)
        {
            htmlBuilder.Append("<table border='1' style='width:100%;'>");
            foreach (var item in request.DataItems)
            {
                htmlBuilder.Append($"<tr><td>{item.Key}</td><td>{item.Value}</td></tr>");
            }
            htmlBuilder.Append("</table>");
        }

        htmlBuilder.Append("</body></html>");

        var pdfDocument = await Task.Run(() =>
            renderer.RenderHtmlAsPdf(htmlBuilder.ToString()));

        var base64Pdf = Convert.ToBase64String(pdfDocument.BinaryData);

        return Ok(new { success = true, pdfData = base64Pdf });
    }
    catch (Exception ex)
    {
        return BadRequest(new { success = false, error = ex.Message });
    }
}

Imports System.Text
Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc

<HttpPost("generate")>
Public Async Function GenerateDynamicPdf(<FromBody> request As PdfRequestModel) As Task(Of IActionResult)
    Try
        Dim renderer = New ChromePdfRenderer()

        renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4
        renderer.RenderingOptions.MarginTop = 20
        renderer.RenderingOptions.MarginBottom = 20
        renderer.RenderingOptions.MarginLeft = 20
        renderer.RenderingOptions.MarginRight = 20

        Dim htmlBuilder = New StringBuilder()
        htmlBuilder.Append("<html><body>")
        htmlBuilder.Append($"<h2>{request.Title}</h2>")
        htmlBuilder.Append($"<div>{request.Content}</div>")

        If request.IncludeData Then
            htmlBuilder.Append("<table border='1' style='width:100%;'>")
            For Each item In request.DataItems
                htmlBuilder.Append($"<tr><td>{item.Key}</td><td>{item.Value}</td></tr>")
            Next
            htmlBuilder.Append("</table>")
        End If

        htmlBuilder.Append("</body></html>")

        Dim pdfDocument = Await Task.Run(Function() renderer.RenderHtmlAsPdf(htmlBuilder.ToString()))

        Dim base64Pdf = Convert.ToBase64String(pdfDocument.BinaryData)

        Return Ok(New With {Key .success = True, Key .pdfData = base64Pdf})
    Catch ex As Exception
        Return BadRequest(New With {Key .success = False, Key .error = ex.Message})
    End Try
End Function

Blok RenderingOptions pozwala skonfigurować rozmiar papieru, marginesy i typ mediów CSS przed renderowaniem. Zgodnie z dokumentacją Microsoftu dotyczącą .NET Core, wzorce asynchroniczne są niezbędne do utrzymania responsywnych interfejsów pod obciążeniem. Otoczenie synchronicznego wywołania renderowania w Task.Run pozwala zachować wolny wątek żądania, podczas gdy silnik Chrome przetwarza kod HTML.

Odpowiedź w formacie base64 pozwala klientowi JavaScript na bezpośrednią aktualizację źródła <iframe> bez konieczności ponownego ładowania strony:

fetch('/api/PdfPanel/generate', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(requestData)
})
.then(response => response.json())
.then(result => {
    if (result.success) {
        const iframe = document.getElementById('pdf-frame');
        iframe.src = 'data:application/pdf;base64,' + result.pdfData;
    }
});

fetch('/api/PdfPanel/generate', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(requestData)
})
.then(response => response.json())
.then(result => {
    if (result.success) {
        const iframe = document.getElementById('pdf-frame');
        iframe.src = 'data:application/pdf;base64,' + result.pdfData;
    }
});

Ten wzorzec sprawdza się zarówno w przypadku Razor Pages, jak i widoków MVC. W zaawansowanych przypadkach użycia IronPDF obsługuje również renderowanie asynchroniczne w sposób natywny, dzięki czemu można używać bezpośrednio RenderHtmlAsPdfAsync zamiast Task.Run.

Jak radzicie sobie z różnymi typami plików źródłowych PDF?

IronPDF może generować pliki PDF z trzech głównych źródeł: ciągów znaków HTML, lokalnych plików HTML oraz zewnętrznych adresów URL. Każde z nich nadaje się do innych scenariuszy.

[HttpGet("from-html")]
public IActionResult GenerateFromHtmlString(string reportType)
{
    var renderer = new ChromePdfRenderer();

    var htmlTemplate = GetHtmlTemplate(reportType);

    var userName = User?.Identity?.Name ?? "Unknown";

    var processedHtml = htmlTemplate
        .Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd"))
        .Replace("{{USER}}", userName)
        .Replace("{{REPORT_TYPE}}", reportType);

    renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;

    using var pdf = renderer.RenderHtmlAsPdf(processedHtml);

    pdf.SaveAs(Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", $"{reportType}.pdf"));

    return File(pdf.BinaryData, "application/pdf");
}

private string GetHtmlTemplate(string reportType)
{
    return @"
        <html>
        <head><title>{{REPORT_TYPE}} Report</title></head>
        <body>
            <h1>{{REPORT_TYPE}} Report</h1>
            <p>Date: {{DATE}}</p>
            <p>User: {{USER}}</p>
            <div>Report content goes here.</div>
        </body>
        </html>";
}

[HttpGet("from-html")]
public IActionResult GenerateFromHtmlString(string reportType)
{
    var renderer = new ChromePdfRenderer();

    var htmlTemplate = GetHtmlTemplate(reportType);

    var userName = User?.Identity?.Name ?? "Unknown";

    var processedHtml = htmlTemplate
        .Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd"))
        .Replace("{{USER}}", userName)
        .Replace("{{REPORT_TYPE}}", reportType);

    renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;

    using var pdf = renderer.RenderHtmlAsPdf(processedHtml);

    pdf.SaveAs(Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", $"{reportType}.pdf"));

    return File(pdf.BinaryData, "application/pdf");
}

private string GetHtmlTemplate(string reportType)
{
    return @"
        <html>
        <head><title>{{REPORT_TYPE}} Report</title></head>
        <body>
            <h1>{{REPORT_TYPE}} Report</h1>
            <p>Date: {{DATE}}</p>
            <p>User: {{USER}}</p>
            <div>Report content goes here.</div>
        </body>
        </html>";
}

Imports System
Imports Microsoft.AspNetCore.Mvc
Imports IronPdf
Imports System.IO

<HttpGet("from-html")>
Public Function GenerateFromHtmlString(reportType As String) As IActionResult
    Dim renderer As New ChromePdfRenderer()

    Dim htmlTemplate As String = GetHtmlTemplate(reportType)

    Dim userName As String = If(User?.Identity?.Name, "Unknown")

    Dim processedHtml As String = htmlTemplate _
        .Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd")) _
        .Replace("{{USER}}", userName) _
        .Replace("{{REPORT_TYPE}}", reportType)

    renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print

    Using pdf = renderer.RenderHtmlAsPdf(processedHtml)
        pdf.SaveAs(Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", $"{reportType}.pdf"))
        Return File(pdf.BinaryData, "application/pdf")
    End Using
End Function

Private Function GetHtmlTemplate(reportType As String) As String
    Return "
        <html>
        <head><title>{{REPORT_TYPE}} Report</title></head>
        <body>
            <h1>{{REPORT_TYPE}} Report</h1>
            <p>Date: {{DATE}}</p>
            <p>User: {{USER}}</p>
            <div>Report content goes here.</div>
        </body>
        </html>"
End Function

[HttpGet("from-url")]
public async Task<IActionResult> GenerateFromUrl(string encodedUrl)
{
    var url = HttpUtility.UrlDecode(encodedUrl);

    var renderer = new ChromePdfRenderer();

    renderer.RenderingOptions.ViewPortWidth = 1920;
    renderer.RenderingOptions.EnableJavaScript = true;
    renderer.RenderingOptions.WaitFor.RenderDelay(2000);

    using var pdf = await renderer.RenderUrlAsPdfAsync(url);

    Response.Headers.Append("Content-Disposition", "inline; filename=webpage.pdf");

    return File(pdf.BinaryData, "application/pdf");
}

[HttpGet("from-url")]
public async Task<IActionResult> GenerateFromUrl(string encodedUrl)
{
    var url = HttpUtility.UrlDecode(encodedUrl);

    var renderer = new ChromePdfRenderer();

    renderer.RenderingOptions.ViewPortWidth = 1920;
    renderer.RenderingOptions.EnableJavaScript = true;
    renderer.RenderingOptions.WaitFor.RenderDelay(2000);

    using var pdf = await renderer.RenderUrlAsPdfAsync(url);

    Response.Headers.Append("Content-Disposition", "inline; filename=webpage.pdf");

    return File(pdf.BinaryData, "application/pdf");
}

Imports System.Web
Imports Microsoft.AspNetCore.Mvc

<HttpGet("from-url")>
Public Async Function GenerateFromUrl(encodedUrl As String) As Task(Of IActionResult)
    Dim url = HttpUtility.UrlDecode(encodedUrl)

    Dim renderer = New ChromePdfRenderer()

    renderer.RenderingOptions.ViewPortWidth = 1920
    renderer.RenderingOptions.EnableJavaScript = True
    renderer.RenderingOptions.WaitFor.RenderDelay(2000)

    Using pdf = Await renderer.RenderUrlAsPdfAsync(url)
        Response.Headers.Append("Content-Disposition", "inline; filename=webpage.pdf")
        Return File(pdf.BinaryData, "application/pdf")
    End Using
End Function

Jak zarządzasz pamięcią i wydajnością?

Generowanie plików PDF wymaga dużych zasobów. Każde wywołanie ChromePdfRenderer tworzy proces Chrome bez interfejsu graficznego, a każdy obiekt PdfDocument przechowuje renderowane bajty w pamięci. Właściwe usuwanie zapobiega wyciekom zasobów i pozwala utrzymać przewidywalne zużycie pamięci pod obciążeniem.

Zawsze używaj instrukcji using z PdfDocument:

public IActionResult OptimizedPdfGeneration()
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.CreatePdfFormsFromHtml = false;

    var processedHtml = GetHtmlTemplate("report")
        .Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd"))
        .Replace("{{USER}}", "Test")
        .Replace("{{REPORT_TYPE}}", "Report");

    using var pdf = renderer.RenderHtmlAsPdf(processedHtml);

    byte[] pdfBytes = pdf.BinaryData;
    pdf.SaveAs("output.pdf");

    return File(pdfBytes, "application/pdf");
}

public IActionResult OptimizedPdfGeneration()
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.CreatePdfFormsFromHtml = false;

    var processedHtml = GetHtmlTemplate("report")
        .Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd"))
        .Replace("{{USER}}", "Test")
        .Replace("{{REPORT_TYPE}}", "Report");

    using var pdf = renderer.RenderHtmlAsPdf(processedHtml);

    byte[] pdfBytes = pdf.BinaryData;
    pdf.SaveAs("output.pdf");

    return File(pdfBytes, "application/pdf");
}

Imports System
Imports Microsoft.AspNetCore.Mvc

Public Class PdfController
    Inherits Controller

    Public Function OptimizedPdfGeneration() As IActionResult
        Dim renderer = New ChromePdfRenderer()
        renderer.RenderingOptions.CreatePdfFormsFromHtml = False

        Dim processedHtml = GetHtmlTemplate("report") _
            .Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd")) _
            .Replace("{{USER}}", "Test") _
            .Replace("{{REPORT_TYPE}}", "Report")

        Using pdf = renderer.RenderHtmlAsPdf(processedHtml)
            Dim pdfBytes As Byte() = pdf.BinaryData
            pdf.SaveAs("output.pdf")

            Return File(pdfBytes, "application/pdf")
        End Using
    End Function

    Private Function GetHtmlTemplate(templateName As String) As String
        ' Placeholder for the actual implementation
        Return String.Empty
    End Function
End Class

Instrukcja using gwarantuje, że obiekt PdfDocument zostanie usunięty natychmiast po wyodrębnieniu tablicy bajtów, nawet jeśli w dalszej części kodu wystąpi wyjątek. W przypadku aplikacji, które często generują pliki PDF, warto rozważyć następujące dodatkowe strategie:

• Buforowanie: Przechowuj często wywoływane pliki PDF w pamięci podręcznej lub na dysku. Użyj IMemoryCache, aby zapisać w pamięci podręcznej tablicę bajtów indeksowaną według identyfikatora dokumentu i sygnatury czasowej.
• Przesyłanie strumieniowe: W przypadku bardzo dużych dokumentów należy używać strumieni pamięci PDF zamiast tablic bajtów, aby uniknąć alokacji dużych, ciągłych bloków pamięci.
• Liniaryzacja: Włącz liniaryzowane (szybkie wyświetlanie stron) wyjście, aby przeglądarki mogły rozpocząć renderowanie przed pobraniem całego pliku.
• Kompresja: Zastosuj kompresję plików PDF, aby zmniejszyć rozmiar plików podczas udostępniania dokumentów przez ograniczone połączenia sieciowe.

Przewodnik dotyczący wydajności IronPDF obejmuje dodatkowe strategie optymalizacji dla scenariuszy wymagających dużej przepustowości.

Jak zapewnić bezpieczeństwo i kompatybilność z różnymi przeglądarkami?

Przed wdrożeniem wyświetlacza panelowego PDF do produkcji należy zwrócić uwagę zarówno na bezpieczeństwo, jak i niezawodność.

Walidacja danych wejściowych: Zawsze oczyszczaj treści dynamiczne przed wstawieniem ich do szablonów HTML. Nieoczyszczone dane wprowadzane przez użytkownika i renderowane przez silnik Chrome mogą narazić serwer na ataki SSRF i XSS. Należy korzystać z uznanych bibliotek kodowania HTML lub ograniczyć akceptowane znaki do bezpiecznej listy dozwolonych znaków.

Kontrola dostępu: Chroń swoje punkty końcowe PDF za pomocą oprogramowania pośredniczącego do uwierzytelniania i autoryzacji. Adres URL taki jak /api/PdfPanel/display/12345, który zwraca dokument bez sprawdzania tożsamości wywołującego, stanowi ryzyko ujawnienia danych. Zastosuj atrybuty [Authorize] i sprawdź, czy uwierzytelniony użytkownik ma uprawnienia dostępu do żądanego identyfikatora dokumentu.

Konfiguracja typu MIME: Zawsze zwracaj application/pdf jako typ zawartości. Przeglądarki, które otrzymają nieprawidłowy typ MIME, mogą wyświetlić okno dialogowe pobierania lub odmówić renderowania wbudowanego. Sprawdź, czy mapowania typów MIME Twojej aplikacji obejmują format PDF, jeśli obsługujesz również statyczne pliki PDF z wwwroot.

Wyświetlanie wbudowane w różnych przeglądarkach: Nowoczesne przeglądarki — Chrome, Firefox, Edge i Safari — obsługują wyświetlanie wbudowane plików PDF za pomocą nagłówka Content-Disposition: inline. Specyfikacja W3C Content Security Policy zawiera wytyczne dotyczące dyrektyw frame-ancestors, jeśli panele osadzają pliki PDF z różnych źródeł. Renderowanie po stronie serwera w IronPDF eliminuje większość niespójności w renderowaniu przeglądarek, ponieważ generowanie plików PDF odbywa się niezależnie od klienta.

Obsługa błędów: Otocz generowanie plików PDF blokami try-catch i zwracaj sensowne kody statusu HTTP. Odpowiedź 500 bez treści jest trudna do zdiagnozowania. Zwróć obiekt błędu o strukturze, aby kod po stronie klienta mógł wyświetlić przyjazny dla użytkownika komunikat zamiast uszkodzonego <iframe>.

W celu zapewnienia bezpieczeństwa dokumentów IronPDF obsługuje ochronę hasłem i uprawnienia, podpisy cyfrowe oraz zgodność z formatem PDF/A dla potrzeb archiwizacji.

Jakie są Twoje kolejne kroki?

Masz teraz gotowy wzorzec wyświetlania plików PDF w panelach ASP.NET: zainstaluj IronPDF, utwórz akcję kontrolera, która generuje plik PDF i zwraca go za pomocą Content-Disposition: inline, a następnie osadź punkt końcowy w <iframe> wewnątrz panelu Razor. Dzięki temu wzorzec AJAX pozwala na dynamiczne ładowanie dokumentów w odpowiedzi na działania użytkownika bez konieczności ponownego ładowania strony.

Rozpocznij bezpłatny okres próbny IronPDF, aby przetestować te wzorce we własnym projekcie — nie jest wymagana karta kredytowa. Wersja próbna zapewnia pełny dostęp do wszystkich funkcji, w tym renderowania HTML do PDF, przechwytywania adresów URL oraz zaawansowanej edycji plików PDF.

Gdy podstawowa wersja będzie już działać, rozważ następujące naturalne rozszerzenia:

• Łączenie lub dzielenie plików PDF w ramach procesów tworzenia dokumentów
• Tworzenie formularzy PDF do wypełnienia na podstawie formularzy HTML
• Dodaj podpisy cyfrowe w celu uwierzytelnienia dokumentów
• Edytuj istniejące pliki PDF, aby dodawać pieczątki, adnotacje lub redagować treść
• Konwersja HTML do PDF z pełną obsługą CSS i JavaScript dla złożonych układów raportów

Dokumentacja IronPDF szczegółowo omawia każdą z tych funkcji, zawierając kompletne przykłady kodu i informacje dotyczące konfiguracji.