Jak wyświetlać pliki PDF w Blazorze za pomocą IronPDF

Dlaczego aplikacja Blazor potrzebuje dedykowanej przeglądarki plików PDF?

Wyświetlanie plików PDF w nowoczesnych aplikacjach internetowych wymaga niezawodnego komponentu przeglądarki, który wykracza poza podstawowe możliwości przeglądarki. Dla programistów .NET tworzących aplikacje Blazor, IronPDF zapewnia skuteczne rozwiązanie do przeglądania plików PDF, które integruje się z aplikacją Blazor Server. Umożliwia to wysokowydajne renderowanie plików PDF i bogatą funkcjonalność bez konieczności korzystania z narzędzi przeglądarkowych innych firm.

Wbudowana obsługa plików PDF różni się znacznie w zależności od przeglądarki i platformy, co prowadzi do niespójnych wrażeń użytkownika. Wdrażając niestandardową przeglądarkę plików PDF w aplikacji Blazor, zyskujesz pełną kontrolę nad wyświetlaniem treści, zapewniając spójną funkcjonalność na wszystkich platformach. Jest to szczególnie ważne w przypadku aplikacji wymagających zgodności z normami i zaawansowanych funkcji bezpieczeństwa.

Framework Blazor — oparty na platformie .NET Core firmy Microsoft — umożliwia tworzenie oprogramowania opartego na komponentach, które w naturalny sposób współdziała z bibliotekami do obróbki plików PDF. Zamiast osadzać widget przeglądarki innej firmy z zewnętrznej sieci CDN, możesz zbudować komponent dostosowany do konkretnych wymagań Twojej aplikacji.

Jak zainstalować IronPDF w projekcie Blazor?

Przed wdrożeniem przeglądarki plików PDF Blazor zainstaluj IronPDF. Dodaj ją do swojej aplikacji Blazor Server za pośrednictwem NuGet, korzystając z konsoli menedżera pakietów lub interfejsu CLI .NET:

Install-Package IronPdf

Install-Package IronPdf

dotnet add package IronPdf

dotnet add package IronPdf

Następnie utwórz nową aplikację Blazor i upewnij się, że masz zainstalowaną najnowszą wersję .NET. Pliki PDF należy przechowywać w folderze wwwroot, aby zapewnić do nich łatwy dostęp, lub ładować je z innych źródeł, takich jak tablice bajtów lub adresy URL. Przegląd instalacji zawiera szczegółowe wskazówki dotyczące różnych scenariuszy wdrożenia.

Jak utworzyć komponent przeglądarki plików PDF w Blazorze?

Zbuduj podstawowy komponent przeglądarki PDF w Blazorze, który może wyświetlać dokumenty PDF. Utwórz nowy komponent Razor w swoim projekcie:

@page "/pdfviewer"
@rendermode InteraktywneServer
@using IronPdf
@inject IJSRuntime JSRuntime
@inject Microsoft.AspNetCore.Hosting.IWebHostEnvironment WebHostEnvironment

<h3>PDF Viewer Component</h3>
<div>
    <button @onclick="LoadPdfDocument">Open File</button>
    <div id="pdfContainer">
        @if (!string.IsNullOrEmpty(pdfUrl))
        {
            <iframe src="@pdfUrl" style="width:100%; height:600px;"></iframe>
        }
    </div>
</div>

@code {
    private string pdfUrl = "";
    private byte[] pdfData = Array.Empty<byte>();

    private async Task LoadPdfDocument()
    {
        var pdfDocument = PdfDocument.FromFile("wwwroot/sample.pdf");
        pdfData = pdfDocument.BinaryData;
        var base64 = Convert.ToBase64String(pdfData);
        pdfUrl = $"data:application/pdf;base64,{base64}";
    }
}

@page "/pdfviewer"
@rendermode InteraktywneServer
@using IronPdf
@inject IJSRuntime JSRuntime
@inject Microsoft.AspNetCore.Hosting.IWebHostEnvironment WebHostEnvironment

<h3>PDF Viewer Component</h3>
<div>
    <button @onclick="LoadPdfDocument">Open File</button>
    <div id="pdfContainer">
        @if (!string.IsNullOrEmpty(pdfUrl))
        {
            <iframe src="@pdfUrl" style="width:100%; height:600px;"></iframe>
        }
    </div>
</div>

@code {
    private string pdfUrl = "";
    private byte[] pdfData = Array.Empty<byte>();

    private async Task LoadPdfDocument()
    {
        var pdfDocument = PdfDocument.FromFile("wwwroot/sample.pdf");
        pdfData = pdfDocument.BinaryData;
        var base64 = Convert.ToBase64String(pdfData);
        pdfUrl = $"data:application/pdf;base64,{base64}";
    }
}

Imports IronPdf
Imports Microsoft.AspNetCore.Hosting
Imports Microsoft.AspNetCore.Components
Imports Microsoft.AspNetCore.Components.Web
Imports Microsoft.JSInterop

@page "/pdfviewer"
@rendermode InteractiveServer

<h3>PDF Viewer Component</h3>
<div>
    <button @onclick="LoadPdfDocument">Open File</button>
    <div id="pdfContainer">
        @If Not String.IsNullOrEmpty(pdfUrl) Then
            <iframe src="@pdfUrl" style="width:100%; height:600px;"></iframe>
        End If
    </div>
</div>

@code {
    Private pdfUrl As String = ""
    Private pdfData As Byte() = Array.Empty(Of Byte)()

    Private Async Function LoadPdfDocument() As Task
        Dim pdfDocument = PdfDocument.FromFile("wwwroot/sample.pdf")
        pdfData = pdfDocument.BinaryData
        Dim base64 = Convert.ToBase64String(pdfData)
        pdfUrl = $"data:application/pdf;base64,{base64}"
    End Function
}

Ten kod tworzy komponent przeglądarki PDF, który ładuje dokument PDF i wyświetla go za pomocą ramki iframe. Metoda LoadPdfDocument odczytuje plik PDF z folderu wwwroot i konwertuje go na adres URL danych w formacie base64, który ramka iframe renderuje bezpośrednio. To podejście sprawdza się dobrze w przypadku różnych wersji plików PDF i obsługuje kodowanie UTF-8 dla dokumentów międzynarodowych.

Jak wykorzystać JavaScript Interop do lepszego wyświetlania plików PDF?

Aby uzyskać lepszą kontrolę nad wyświetlaniem treści plików PDF, należy użyć interoperacyjności JavaScript do obsługi funkcji przeglądarki PDF. Ten wzorzec ładuje moduł JavaScript asynchronicznie i przekazuje renderowanie do natywnych interfejsów API blob/URL przeglądarki — technika ta doskonale nadaje się do cyklu życia komponentów Blazor:

@page "/pdf-jsinterop"
@rendermode InteraktywneServer
@using IronPdf
@inject IJSRuntime JSRuntime
@inject Microsoft.AspNetCore.Hosting.IWebHostEnvironment WebHostEnvironment
@implements IAsyncDisposable

<h3>IronPDF JavaScript Interop Viewer</h3>
<p>Displays PDF using JavaScript Blob/ObjectURL capabilities.</p>

@if (!string.IsNullOrEmpty(ErrorMessage))
{
    <div class="alert alert-danger">Error: @ErrorMessage</div>
}

<div id="@documentId" style="border: 1px solid #ccc; width: 100%; min-height: 600px;">
    Loading PDF...
</div>

@code {
    private string documentId = Guid.NewGuid().ToString();
    private string ErrorMessage = string.Empty;
    private bool pdfLoaded = false;
    private IJSObjectReference? jsModule;

    protected override async Task OnAfterRenderAsync(bool firstRender)
    {
        if (firstRender && !pdfLoaded)
        {
            try
            {
                jsModule = await JSRuntime.InvokeAsync<IJSObjectReference>(
                    "import", "./pdfViewerInterop.js");
                await LoadPdfWithJavaScript();
                pdfLoaded = true;
            }
            catch (Exception ex)
            {
                ErrorMessage = $"Failed to load JS module: {ex.Message}";
            }
            finally
            {
                StateHasChanged();
            }
        }
    }

    private async Task LoadPdfWithJavaScript()
    {
        if (jsModule is null) return;
        var pdfPath = Path.Combine(WebHostEnvironment.WebRootPath, "sample.pdf");
        if (!File.Exists(pdfPath))
        {
            ErrorMessage = $"File not found: {pdfPath}";
            return;
        }
        var pdf = PdfDocument.FromFile(pdfPath);
        await jsModule.InvokeVoidAsync("displayPdf", documentId, pdf.BinaryData);
    }

    public async ValueTask DisposeAsync()
    {
        if (jsModule is not null)
            await jsModule.DisposeAsync();
    }
}

@page "/pdf-jsinterop"
@rendermode InteraktywneServer
@using IronPdf
@inject IJSRuntime JSRuntime
@inject Microsoft.AspNetCore.Hosting.IWebHostEnvironment WebHostEnvironment
@implements IAsyncDisposable

<h3>IronPDF JavaScript Interop Viewer</h3>
<p>Displays PDF using JavaScript Blob/ObjectURL capabilities.</p>

@if (!string.IsNullOrEmpty(ErrorMessage))
{
    <div class="alert alert-danger">Error: @ErrorMessage</div>
}

<div id="@documentId" style="border: 1px solid #ccc; width: 100%; min-height: 600px;">
    Loading PDF...
</div>

@code {
    private string documentId = Guid.NewGuid().ToString();
    private string ErrorMessage = string.Empty;
    private bool pdfLoaded = false;
    private IJSObjectReference? jsModule;

    protected override async Task OnAfterRenderAsync(bool firstRender)
    {
        if (firstRender && !pdfLoaded)
        {
            try
            {
                jsModule = await JSRuntime.InvokeAsync<IJSObjectReference>(
                    "import", "./pdfViewerInterop.js");
                await LoadPdfWithJavaScript();
                pdfLoaded = true;
            }
            catch (Exception ex)
            {
                ErrorMessage = $"Failed to load JS module: {ex.Message}";
            }
            finally
            {
                StateHasChanged();
            }
        }
    }

    private async Task LoadPdfWithJavaScript()
    {
        if (jsModule is null) return;
        var pdfPath = Path.Combine(WebHostEnvironment.WebRootPath, "sample.pdf");
        if (!File.Exists(pdfPath))
        {
            ErrorMessage = $"File not found: {pdfPath}";
            return;
        }
        var pdf = PdfDocument.FromFile(pdfPath);
        await jsModule.InvokeVoidAsync("displayPdf", documentId, pdf.BinaryData);
    }

    public async ValueTask DisposeAsync()
    {
        if (jsModule is not null)
            await jsModule.DisposeAsync();
    }
}

Imports System
Imports System.IO
Imports System.Threading.Tasks
Imports IronPdf
Imports Microsoft.AspNetCore.Components
Imports Microsoft.AspNetCore.Components.Web
Imports Microsoft.JSInterop
Imports Microsoft.AspNetCore.Hosting

@page "/pdf-jsinterop"
@rendermode InteractiveServer
@inject IJSRuntime JSRuntime
@inject IWebHostEnvironment WebHostEnvironment
@implements IAsyncDisposable

<h3>IronPDF JavaScript Interop Viewer</h3>
<p>Displays PDF using JavaScript Blob/ObjectURL capabilities.</p>

@if Not String.IsNullOrEmpty(ErrorMessage) Then
    <div class="alert alert-danger">Error: @ErrorMessage</div>
End If

<div id="@documentId" style="border: 1px solid #ccc; width: 100%; min-height: 600px;">
    Loading PDF...
</div>

@code {
    Private documentId As String = Guid.NewGuid().ToString()
    Private ErrorMessage As String = String.Empty
    Private pdfLoaded As Boolean = False
    Private jsModule As IJSObjectReference

    Protected Overrides Async Function OnAfterRenderAsync(firstRender As Boolean) As Task
        If firstRender AndAlso Not pdfLoaded Then
            Try
                jsModule = Await JSRuntime.InvokeAsync(Of IJSObjectReference)(
                    "import", "./pdfViewerInterop.js")
                Await LoadPdfWithJavaScript()
                pdfLoaded = True
            Catch ex As Exception
                ErrorMessage = $"Failed to load JS module: {ex.Message}"
            Finally
                StateHasChanged()
            End Try
        End If
    End Function

    Private Async Function LoadPdfWithJavaScript() As Task
        If jsModule Is Nothing Then Return
        Dim pdfPath = Path.Combine(WebHostEnvironment.WebRootPath, "sample.pdf")
        If Not File.Exists(pdfPath) Then
            ErrorMessage = $"File not found: {pdfPath}"
            Return
        End If
        Dim pdf = PdfDocument.FromFile(pdfPath)
        Await jsModule.InvokeVoidAsync("displayPdf", documentId, pdf.BinaryData)
    End Function

    Public Async Function DisposeAsync() As ValueTask Implements IAsyncDisposable.DisposeAsync
        If jsModule IsNot Nothing Then
            Await jsModule.DisposeAsync()
        End If
    End Function
}

Dodaj odpowiednią funkcję JavaScript do pliku wwwroot/pdfViewerInterop.js. Zwróć uwagę, że ten plik używa JavaScript (a nie C#) i jest zapisany jako moduł .js:

export function displayPdf(elementId, data) {
    const blob = new Blob([new Uint8Array(data)], { type: 'application/pdf' });
    const url = URL.createObjectURL(blob);
    const container = document.getElementById(elementId);
    if (!container) return;
    container.innerHTML = '';
    const iframe = document.createElement('iframe');
    iframe.src = url;
    iframe.style.width = '100%';
    iframe.style.height = '600px';
    iframe.style.border = 'none';
    container.appendChild(iframe);
}

export function displayPdf(elementId, data) {
    const blob = new Blob([new Uint8Array(data)], { type: 'application/pdf' });
    const url = URL.createObjectURL(blob);
    const container = document.getElementById(elementId);
    if (!container) return;
    container.innerHTML = '';
    const iframe = document.createElement('iframe');
    iframe.src = url;
    iframe.style.width = '100%';
    iframe.style.height = '600px';
    iframe.style.border = 'none';
    container.appendChild(iframe);
}

The provided code is JavaScript, not C#. Therefore, it cannot be directly converted to VB.NET, as VB.NET is a server-side language and JavaScript is a client-side language. If you have C# code that you need converted to VB.NET, please provide that code for conversion.

Ta funkcja JavaScript tworzy obiekt blob na podstawie danych PDF, generuje adres URL obiektu i dołącza ramkę iframe do kontenera. Technika ta obsługuje renderowanie JavaScript oraz niestandardowe opóźnienia renderowania dla złożonych dokumentów.

Jak wczytać pliki PDF z wielu źródeł?

Przeglądarka plików PDF Blazor umożliwia pobieranie i wyświetlanie dokumentów PDF z różnych źródeł. Poniższy przykład pokazuje ładowanie z adresu URL oraz z treści HTML:

private async Task LoadFromUrl(string url)
{
    using var client = new HttpClient();
    client.Timeout = TimeSpan.FromSeconds(30);
    var response = await client.GetAsync(url);
    response.EnsureSuccessStatusCode();
    var stream = await response.Content.ReadAsStreamAsync();
    var pdfDocument = new PdfDocument(stream);
    await DisplayPdfContent(pdfDocument);
}

private async Task LoadFromHtmlContent()
{
    var renderer = new ChromePdfRenderer();
    var htmlContent = "<h1>Generated PDF</h1><p>Dynamic content from Blazor.</p>";
    var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);
    await DisplayPdfContent(pdfDocument);
}

private Task DisplayPdfContent(PdfDocument document)
{
    var data = document.BinaryData;
    pdfUrl = $"data:application/pdf;base64,{Convert.ToBase64String(data)}";
    return Task.CompletedTask;
}

private async Task LoadFromUrl(string url)
{
    using var client = new HttpClient();
    client.Timeout = TimeSpan.FromSeconds(30);
    var response = await client.GetAsync(url);
    response.EnsureSuccessStatusCode();
    var stream = await response.Content.ReadAsStreamAsync();
    var pdfDocument = new PdfDocument(stream);
    await DisplayPdfContent(pdfDocument);
}

private async Task LoadFromHtmlContent()
{
    var renderer = new ChromePdfRenderer();
    var htmlContent = "<h1>Generated PDF</h1><p>Dynamic content from Blazor.</p>";
    var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);
    await DisplayPdfContent(pdfDocument);
}

private Task DisplayPdfContent(PdfDocument document)
{
    var data = document.BinaryData;
    pdfUrl = $"data:application/pdf;base64,{Convert.ToBase64String(data)}";
    return Task.CompletedTask;
}

Imports System
Imports System.Net.Http
Imports System.Threading.Tasks

Private Async Function LoadFromUrl(url As String) As Task
    Using client As New HttpClient()
        client.Timeout = TimeSpan.FromSeconds(30)
        Dim response = Await client.GetAsync(url)
        response.EnsureSuccessStatusCode()
        Dim stream = Await response.Content.ReadAsStreamAsync()
        Dim pdfDocument As New PdfDocument(stream)
        Await DisplayPdfContent(pdfDocument)
    End Using
End Function

Private Async Function LoadFromHtmlContent() As Task
    Dim renderer As New ChromePdfRenderer()
    Dim htmlContent As String = "<h1>Generated PDF</h1><p>Dynamic content from Blazor.</p>"
    Dim pdfDocument = renderer.RenderHtmlAsPdf(htmlContent)
    Await DisplayPdfContent(pdfDocument)
End Function

Private Function DisplayPdfContent(document As PdfDocument) As Task
    Dim data = document.BinaryData
    pdfUrl = $"data:application/pdf;base64,{Convert.ToBase64String(data)}"
    Return Task.CompletedTask
End Function

Metoda LoadFromUrl pobiera dokumenty PDF ze zdalnych lokalizacji, natomiast LoadFromHtmlContent pokazuje, jak na bieżąco konwertować HTML na PDF. Silnik renderujący Chrome zapewnia dokładną konwersję HTML. Dodatkowe opcje źródłowe obejmują Azure Magazyn obiektów Blob, strumienie pamięci baz danych oraz dokumenty DOCX.

Jak dodać funkcje interaktywne do przeglądarki plików PDF?

Rozszerz przeglądarkę plików PDF o funkcje nawigacji po stronach, obracania, drukowania i pobierania:

@code {
    private int currentPage = 1;
    private int totalPages;
    private byte[] pdfData = Array.Empty<byte>();
    private string pdfUrl = "";
    private string rotationClass = "";
    private string documentId = Guid.NewGuid().ToString();

    private async Task NavigateToPage(int page)
    {
        currentPage = page;
        await JSRuntime.InvokeVoidAsync("navigateTo", page);
    }

    private void RotateCounterclockwise()
    {
        rotationClass = "rotate-270";
    }

    private async Task PrintPdf()
    {
        await JSRuntime.InvokeVoidAsync("printDocument", documentId);
    }

    private async Task DownloadPdf()
    {
        await JSRuntime.InvokeVoidAsync("downloadFile", pdfData, "document.pdf");
    }
}

@code {
    private int currentPage = 1;
    private int totalPages;
    private byte[] pdfData = Array.Empty<byte>();
    private string pdfUrl = "";
    private string rotationClass = "";
    private string documentId = Guid.NewGuid().ToString();

    private async Task NavigateToPage(int page)
    {
        currentPage = page;
        await JSRuntime.InvokeVoidAsync("navigateTo", page);
    }

    private void RotateCounterclockwise()
    {
        rotationClass = "rotate-270";
    }

    private async Task PrintPdf()
    {
        await JSRuntime.InvokeVoidAsync("printDocument", documentId);
    }

    private async Task DownloadPdf()
    {
        await JSRuntime.InvokeVoidAsync("downloadFile", pdfData, "document.pdf");
    }
}

Imports System

Public Class CodeBehind
    Private currentPage As Integer = 1
    Private totalPages As Integer
    Private pdfData As Byte() = Array.Empty(Of Byte)()
    Private pdfUrl As String = ""
    Private rotationClass As String = ""
    Private documentId As String = Guid.NewGuid().ToString()

    Private Async Function NavigateToPage(page As Integer) As Task
        currentPage = page
        Await JSRuntime.InvokeVoidAsync("navigateTo", page)
    End Function

    Private Sub RotateCounterclockwise()
        rotationClass = "rotate-270"
    End Sub

    Private Async Function PrintPdf() As Task
        Await JSRuntime.InvokeVoidAsync("printDocument", documentId)
    End Function

    Private Async Function DownloadPdf() As Task
        Await JSRuntime.InvokeVoidAsync("downloadFile", pdfData, "document.pdf")
    End Function
End Class

Ten kod dodaje funkcje nawigacji po stronie, obracania, PRINT i pobierania. W przypadku dokumentów zawierających dużo elementów nawigacyjnych warto rozważyć dodanie numerów stron i zakładek. Zaawansowane funkcje mogą obejmować wyodrębnianie tekstu oraz konwersję plików PDF do formatu HTML.

Jak radzisz sobie z formularzami PDF i adnotacjami?

W przypadku dokumentów PDF zawierających pola formularzy i adnotacje, IronPDF zapewnia solidne wsparcie dla programowego odczytu i zapisu wartości pól:

private async Task ProcessFormFields()
{
    var pdfDocument = PdfDocument.FromFile("form.pdf");

    foreach (var field in pdfDocument.Form.Fields)
    {
        if (field.Type == PdfFormFieldType.Text)
        {
            field.Value = "User Input";
        }
    }

    await DisplayPdfContent(pdfDocument);
}

private async Task SaveFormData()
{
    var pdfWithFormData = PdfDocument.FromFile("filled-form.pdf");
    var formData = pdfWithFormData.Form.Fields
        .ToDictionary(f => f.Name, f => f.Value);

    var json = System.Text.Json.JsonSerializer.Serialize(formData);
    await File.WriteAllTextAsync("form-data.json", json);

    pdfWithFormData.Form.Flatten();
    pdfWithFormData.SaveAs("form-submission.pdf");
}

private async Task ProcessFormFields()
{
    var pdfDocument = PdfDocument.FromFile("form.pdf");

    foreach (var field in pdfDocument.Form.Fields)
    {
        if (field.Type == PdfFormFieldType.Text)
        {
            field.Value = "User Input";
        }
    }

    await DisplayPdfContent(pdfDocument);
}

private async Task SaveFormData()
{
    var pdfWithFormData = PdfDocument.FromFile("filled-form.pdf");
    var formData = pdfWithFormData.Form.Fields
        .ToDictionary(f => f.Name, f => f.Value);

    var json = System.Text.Json.JsonSerializer.Serialize(formData);
    await File.WriteAllTextAsync("form-data.json", json);

    pdfWithFormData.Form.Flatten();
    pdfWithFormData.SaveAs("form-submission.pdf");
}

Imports System.IO
Imports System.Threading.Tasks
Imports System.Text.Json

Private Async Function ProcessFormFields() As Task
    Dim pdfDocument = PdfDocument.FromFile("form.pdf")

    For Each field In pdfDocument.Form.Fields
        If field.Type = PdfFormFieldType.Text Then
            field.Value = "User Input"
        End If
    Next

    Await DisplayPdfContent(pdfDocument)
End Function

Private Async Function SaveFormData() As Task
    Dim pdfWithFormData = PdfDocument.FromFile("filled-form.pdf")
    Dim formData = pdfWithFormData.Form.Fields.ToDictionary(Function(f) f.Name, Function(f) f.Value)

    Dim json = JsonSerializer.Serialize(formData)
    Await File.WriteAllTextAsync("form-data.json", json)

    pdfWithFormData.Form.Flatten()
    pdfWithFormData.SaveAs("form-submission.pdf")
End Function

Umożliwia to wypełnianie formularzy w przeglądarce plików PDF Blazor, pozwalając użytkownikom na interakcję z polami formularza bezpośrednio w przeglądarce. Kod iteruje przez pola formularza i programowo ustawia wartości, co jest idealnym rozwiązaniem dla aplikacji wymagających dynamicznego wstępnego wypełniania. IronPDF obsługuje również podpisy cyfrowe i adnotacje tekstowe.

Obsługiwane typy pól obejmują pola tekstowe, pola wyboru, przyciski opcji, listy rozwijane, pola podpisu cyfrowego, wielowierszowe obszary tekstowe oraz selektory daty.

Jak zoptymalizować wydajność w przypadku dużych plików PDF?

Aby zapewnić dobrą wydajność podczas wyświetlania plików PDF, zwłaszcza w przypadku dużych plików, należy stosować ładowanie fragmentaryczne i zarządzanie pamięcią:

private async Task LoadLargePdf()
{
    const int chunkSize = 1024 * 1024; // 1MB chunks
    var pdfPath = "largefile.pdf";

    using var fileStream = File.OpenRead(pdfPath);
    var buffer = new byte[chunkSize];
    var chunks = new List<byte[]>();
    int bytesRead;

    while ((bytesRead = await fileStream.ReadAsync(buffer)) > 0)
    {
        var chunk = new byte[bytesRead];
        Array.Copy(buffer, chunk, bytesRead);
        chunks.Add(chunk);
    }

    await ProcessPdfChunks(chunks);
}

private async Task LoadLargePdf()
{
    const int chunkSize = 1024 * 1024; // 1MB chunks
    var pdfPath = "largefile.pdf";

    using var fileStream = File.OpenRead(pdfPath);
    var buffer = new byte[chunkSize];
    var chunks = new List<byte[]>();
    int bytesRead;

    while ((bytesRead = await fileStream.ReadAsync(buffer)) > 0)
    {
        var chunk = new byte[bytesRead];
        Array.Copy(buffer, chunk, bytesRead);
        chunks.Add(chunk);
    }

    await ProcessPdfChunks(chunks);
}

Imports System.IO
Imports System.Threading.Tasks

Private Async Function LoadLargePdf() As Task
    Const chunkSize As Integer = 1024 * 1024 ' 1MB chunks
    Dim pdfPath As String = "largefile.pdf"

    Using fileStream As FileStream = File.OpenRead(pdfPath)
        Dim buffer(chunkSize - 1) As Byte
        Dim chunks As New List(Of Byte())()
        Dim bytesRead As Integer

        Do
            bytesRead = Await fileStream.ReadAsync(buffer, 0, buffer.Length)
            If bytesRead > 0 Then
                Dim chunk(bytesRead - 1) As Byte
                Array.Copy(buffer, chunk, bytesRead)
                chunks.Add(chunk)
            End If
        Loop While bytesRead > 0
    End Using

    Await ProcessPdfChunks(chunks)
End Function

To podejście ładuje duże pliki PDF w fragmentach, zapobiegając problemom z pamięcią i zapewniając płynne działanie nawet w przypadku obszernych dokumentów. Jest to szczególnie przydatne podczas pracy z plikami PDF na urządzeniach mobilnych lub systemach o ograniczonych zasobach. Dodatkowe opcje dostosowywania można znaleźć w przewodniku wydajności IronPDF.

Dodatkowe strategie optymalizacji obejmują linearyzację w celu szybkiego przeglądania stron internetowych, kompresję w celu zmniejszenia rozmiarów plików oraz przetwarzanie asynchroniczne umożliwiające jednoczesną obsługę wielu plików PDF. Zgodnie z najlepszymi praktykami Stowarzyszenia PDF, zlinearyzowane (zoptymalizowane pod kątem sieci) pliki PDF mogą skrócić początkowy czas ładowania dużych dokumentów o 30–60%.

Jak zabezpieczyć przeglądarkę plików PDF Blazor dla plików chronionych hasłem?

Podczas pracy z plikami PDF chronionymi hasłem należy przekazać hasło bezpośrednio do PdfDocument.FromFile i skonfigurować odpowiednie nagłówki bezpieczeństwa HTTP:

private async Task LoadSecurePdf(string password)
{
    var pdfDocument = PdfDocument.FromFile("secure.pdf", password);

    var headers = new Dictionary<string, string>
    {
        { "X-Frame-Options", "SAMEORIGIN" },
        { "Content-Bezpieczeństwo-Policy", "default-src 'self'" },
        { "X-Content-Type-Options", "nosniff" },
        { "Referrer-Policy", "no-referrer" }
    };

    await DisplayPdfContent(pdfDocument);
}

private async Task LoadSecurePdf(string password)
{
    var pdfDocument = PdfDocument.FromFile("secure.pdf", password);

    var headers = new Dictionary<string, string>
    {
        { "X-Frame-Options", "SAMEORIGIN" },
        { "Content-Bezpieczeństwo-Policy", "default-src 'self'" },
        { "X-Content-Type-Options", "nosniff" },
        { "Referrer-Policy", "no-referrer" }
    };

    await DisplayPdfContent(pdfDocument);
}

Private Async Function LoadSecurePdf(ByVal password As String) As Task
    Dim pdfDocument = PdfDocument.FromFile("secure.pdf", password)

    Dim headers = New Dictionary(Of String, String) From {
        {"X-Frame-Options", "SAMEORIGIN"},
        {"Content-Bezpieczeństwo-Policy", "default-src 'self'"},
        {"X-Content-Type-Options", "nosniff"},
        {"Referrer-Policy", "no-referrer"}
    }

    Await DisplayPdfContent(pdfDocument)
End Function

Ten kod pokazuje ładowanie dokumentów PDF chronionych hasłem przy zachowaniu bezpieczeństwa dzięki odpowiedniej konfiguracji nagłówka. Rozważ zastosowanie podpisów cyfrowych w celu poprawy uwierzytelniania. Należy zastosować proces oczyszczania plików PDF w celu usunięcia potencjalnie złośliwych treści oraz zredagowania informacji wrażliwych.

W przypadku haseł nigdy nie należy przechowywać ich w postaci zwykłego tekstu ani w kodzie po stronie klienta. Należy stosować bezpieczne metody wprowadzania danych z odpowiednią walidacją, wdrażać limity czasu sesji dla dokumentów wrażliwych oraz usuwać hasła z pamięci po użyciu. Wytyczne Microsoftu dotyczące bezpieczeństwa .NET Core zalecają, aby zawsze weryfikować i oczyszczać wszelkie dane uwierzytelniające dostarczone przez użytkownika przed przekazaniem ich do dalszych interfejsów API.

Jakie są najważniejsze wnioski dotyczące wyświetlania plików PDF w Blazorze?

Wdrożenie przeglądarki plików PDF Blazor z wykorzystaniem IronPDF zapewnia programistom kompletne rozwiązanie do wyświetlania plików PDF w aplikacjach internetowych. Od podstawowego wyświetlania po zaawansowane funkcje, takie jak wypełnianie formularzy i adnotacje, komponent przeglądarki PDF firmy IronPDF oferuje funkcjonalność niezbędną w profesjonalnych aplikacjach.

Przedstawione przykłady pokazują, jak stworzyć niezawodną przeglądarkę plików PDF dla Blazora, która obsługuje różne źródła plików PDF, zapewnia interaktywne funkcje i zachowuje wysoką wydajność. Niezależnie od tego, czy tworzysz prostą przeglądarkę dokumentów, czy złożony system zarządzania dokumentami, integracja IronPDF z aplikacjami Blazor Server ułatwia wdrożenie profesjonalnych funkcji przeglądania plików PDF.

Główne zalety to:

• Kompatybilność międzyplatformowa z jednolitym wyświetlaniem we wszystkich przeglądarkach
• Zaawansowane funkcje bezpieczeństwa dla poufnych dokumentów
• Optymalizacja wydajności w przypadku dużych plików dzięki asynchronicznemu i fragmentarycznemu ładowaniu
• Pełne możliwości obsługi formularzy, w tym podpisy cyfrowe
• Płynna integracja z istniejącymi aplikacjami .NET

IronPDF obsługuje środowiska Azure, AWS, Docker oraz tradycyjne środowiska Windows. Gotowy do stworzenia własnej przeglądarki? Zacznij od bezpłatnej wersji próbnej IronPDF i zapoznaj się z pełną dokumentacją oraz przykładami kodu, aby zapewnić użytkownikom aplikacji Blazor komfortowe przeglądanie plików PDF.