Aby wyświetlać pliki PDF w aplikacjach Blazor, należy użyć komponentu przeglądarki PDF firmy IronPDF, który integruje się z aplikacjami Blazor Server i zapewnia wysokowydajne renderowanie plików PDF z funkcjami takimi jak wypełnianie formularzy, adnotacje i obsługa urządzeń mobilnych — wszystko to bez konieczności korzystania z narzędzi przeglądarkowych innych firm.
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.
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:
Następnie utwórz nową aplikację Blazor i upewnij się, że masz zainstalowaną najnowszą wersję .NET. Przechowuj pliki PDF w folderze wwwroot dla latwego dostepu lub laduj je z innych zrodel, takich jak tablice bajtow lub URL-e. Przegląd instalacji zawiera szczegółowe wskazówki dotyczące różnych scenariuszy wdrożenia.
Aby pomyślnie wdrożyć przeglądarkę plików PDF Blazor, upewnij się, że masz:
wwwroot)W przypadku wdrożenia w systemie Windows upewnij się, że masz odpowiednie środowisko uruchomieniowe Visual C++. Użytkownicy systemu Linux powinni zainstalować wymagane zależności, natomiast programiści korzystający z systemu macOS muszą wziąć pod uwagę kompatybilność procesorów Intel i Apple Silicon.
Lokalizacja przechowywania plików PDF ma znaczący wpływ na wydajność i bezpieczeństwo aplikacji. W przypadku aplikacji Blazor rozważ następujące opcje:
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}";
}
}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 PDF z folderu wwwroot i konwertuje go do danych URL w formacie base64, które iframe renderuje bezposrednio. 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.
Komponent wykorzystuje możliwości ładowania dokumentów IronPDF do wydajnego odczytu plików PDF. Gdy użytkownik kliknie przycisk "Otwórz plik", metoda:
PdfDocument.FromFileTakie podejście zapewnia kompatybilność z różnymi przeglądarkami, zachowując jednocześnie dobrą wydajność wyświetlania plików PDF. Komponent obsługuje różne rozmiary papieru i orientacje stron.
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();
}
}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 odpowiednia funkcje JavaScript do swojego pliku wwwroot/pdfViewerInterop.js. Pamietaj, ze plik ten uzywa JavaScript (nie C#), zapisany jako modul .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);
}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.
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;
}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 FunctionMetoda LoadFromUrl pobiera dokumenty PDF z miejsc zdalnych, podczas gdy LoadFromHtmlContent pokazuje, jak konwertowac HTML na PDF dynamicznie. 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.
| Typ źródła | Najlepsze dla | Wydajność | Bezpieczeństwo |
|---|---|---|---|
| Pliki lokalne | Treści statyczne | Doskonałe | Niski |
| Adresy URL | Dokumenty zewnętrzne | Dobrze | Srednie |
| Konwersja HTML | Raporty dynamiczne | Zmienna | Duze |
| Magazyn obiektów Blob | Aplikacje dla Enterprise | Doskonałe | Duze |
| Strumienie pamięci | Tymczasowe pliki PDF | Doskonałe | Duze |
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");
}
}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 ClassTen 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.
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");
}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 FunctionUmoż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.
| Podejście | Zastosowanie | Korzyści |
|---|---|---|
| Programowe | Wstępne wypełnienie znanych danych | Szybsze, spójne, zautomatyzowane |
| Interaktywne | Wymagane dane od użytkownika | Elastyczna, natychmiastowa weryfikacja |
| Hybrydowy | Dostępne są dane częściowe | Najlepsze z obu podejść |
Rozważ spłaszczenie formularzy po przesłaniu, aby zapobiec manipulacjom. Ze względów bezpieczeństwa należy zastosować czyszczenie 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);
}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 FunctionTo 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%.
| Rozmiar pliku | Strategia ładowania | Wpływ na pamięć |
|---|---|---|
| Poniżej 5 MB | Bezpośrednie ładowanie | Minimalne |
| 5–20 MB | Opcjonalne podział na fragmenty | Umiarkowany |
| 20–50 MB | Zalecany podział na fragmenty | Istotne |
| Ponad 50 MB | Wymagane podział na fragmenty | Krytyczne |
Renderowanie po stronie serwera staje się korzystne podczas przetwarzania plików PDF większych niż 100 MB, wdrażania złożonych adnotacji lub obsługi wielu użytkowników jednocześnie.
Pracujac z plikami PDF zabezpieczonymi haslem, przekaz haslo bezposrednio do PdfDocument.FromFile i skonfiguruj odpowiednie naglowki zabezpieczen 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 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 FunctionTen 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.
| Typ deszyfrowania | Przykład zastosowania | Poziom bezpieczeństwa |
|---|---|---|
| Po stronie klienta | Dokumenty publiczne | Niski |
| Po stronie serwera | Dane wrażliwe | Duze |
| Hybrydowy | Treści mieszane | Srednie |
Aby zapewnić maksymalne bezpieczeństwo, zawsze należy przeprowadzać deszyfrowanie po stronie serwera i bezpiecznie przesyłać deszyfrowaną treść do klienta. Wprowadź zgodność z formatem PDF/A na potrzeby długoterminowej archiwizacji.
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:
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.
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ęczników.
IronPDF jest częścią IRONSUITE
10 produktów API .NET dla twoich dokumentów biurowych
Kiedy potrzebujesz, aby twój PDF wyglądał jak HTML, szybko.
