Blazor'da IronPDF ile PDF'leri Nasıl Görüntülenir

Blazor Uygulamasının Neden Özel bir PDF Görüntüleyiciye İhtiyacı Var?

Modern web uygulamalarında PDF'leri görüntülemek, temel tarayıcı yeteneklerinin ötesine geçen güvenilir bir görüntüleyici bileşeni gerektirir. .NET geliştiricileri için Blazor uygulamaları oluşturanlar için IronPDF, Blazor Sunucu uygulamanız ile etkili PDF görüntüleyici çözümü sağlar. Bu sayede üçüncü parti tarayıcı araçlarına güvenmeden yüksek performanslı PDF renderi ve zengin işlevsellik sunar.

Doğal tarayıcı PDF desteği farklı tarayıcılar ve platformlar arasında önemli ölçüde değişir, bu da tutarsız kullanıcı deneyimlerine yol açar. Blazor uygulamanızda özel bir PDF görüntüleyici uygulayarak, izleme deneyimini tamamen kontrol edebilir ve tüm platformlarda tutarlı işlevsellik sağlayabilirsiniz. Bu, uyumluluk standartları ve üstün güvenlik özellikleri gerektiren uygulamalar için özellikle önemlidir.

Blazor çerçevesi, Microsoft'un ASP.NET Core üzerine inşa edilmiştir ve bileşen tabanlı geliştirme, PDF işleme kitaplıklarıyla doğal olarak eşleşir. Harici bir CDN'den üçüncü parti bir görüntüleyici widget'ı yerleştirmek yerine, uygulamanızın kesin gereksinimlerine uygun bir bileşen oluşturabilirsiniz.

IronPDF'i Blazor Projesine Nasıl Kurarsınız?

Blazor PDF görüntüleyicinizi uygulamadan önce IronPDF'i yükleyin. NuGet aracılığıyla Paket Yöneticisi Konsolu veya .NET CLI kullanarak Blazor Server uygulamanıza ekleyin:

Install-Package IronPdf

Install-Package IronPdf

dotnet add package IronPdf

dotnet add package IronPdf

Sonrasında, yeni bir Blazor uygulaması oluşturun ve en son .NET sürümünü yüklü olduğundan emin olun. Kolay erişim için PDF dosyalarını wwwroot klasöründe saklayın ya da bayt dizileri veya URL'ler gibi diğer kaynaklardan yükleyin. Kurulum genel bakışı, çeşitli dağıtım senaryoları için ayrıntılı kılavuz sağlar.

Blazor PDF Görüntüleyici Bileşeni Nasıl Oluşturulur?

PDF belgelerini görüntüleyebilen basit bir Blazor PDF görüntüleyici bileşeni inşa edin. Projenizde yeni bir Razor bileşeni oluşturun:

@page "/pdfviewer"
@rendermode EtkileşimliServer
@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 EtkileşimliServer
@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.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
}

Bu kod, bir PDF görüntüleyici bileşeni oluşturur ve PDF belgesini yükleyip bir iframe kullanarak görüntüler. LoadPdfDocument yöntemi, PDF'yi wwwroot klasöründen okur ve iframenin doğrudan render ettiği bir base64 veri URL'sine dönüştürür. Bu yaklaşım, çeşitli PDF sürümleriyle iyi çalışır ve uluslararası belgeler için UTF-8 kodlaması desteği sunar.

Daha İyi PDF Görüntüleme için JavaScript Interop Nasıl Kullanılır?

PDF içeriği üzerinde daha iyi kontrol sağlamak için JavaScript interop kullanarak PDF görüntüleyici işlevselliğini yönetin. Bu desen, bir JavaScript modülünü eşzamansız olarak yükler ve Blazor'un bileşen yaşam döngüsüne uygun bir teknik olan tarayıcının yerel blob/URL API'lerine işlemi devreder:

@page "/pdf-jsinterop"
@rendermode EtkileşimliServer
@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 EtkileşimliServer
@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
}

Karşılık gelen JavaScript fonksiyonunu wwwroot/pdfViewerInterop.js dosyanıza ekleyin. Bu dosyanın JavaScript (C# değil) kullandığını ve bir .js modülü olarak kaydedildiğini unutmayın:

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.

Bu JavaScript işlevi, PDF verilerinden bir blob oluşturur, bir nesne URL'si üretir ve kapsayıcıya bir iframe ekler. Teknik, JavaScript işleme ve karmaşık belgeler için özel render gecikmelerini destekler.

PDF'leri Birden Fazla Kaynaktan Nasıl Yüklenir?

Blazor PDF görüntüleyiciniz, çeşitli kaynaklardan PDF belgeleri alabilir ve görüntüleyebilir. Aşağıdaki örnek, bir URL'den ve HTML içeriğinden yükleme gösterir:

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

LoadFromUrl yöntemi, PDF belgelerini uzak konumlardan alırken, LoadFromHtmlContent HTML'yi PDF'ye dönüştürmeyi anında nasıl yapacağını gösterir. Chrome işleme motoru doğru HTML dönüşümünü sağlar. Ek kaynak seçenekleri arasında Azure Blob Depolama, veritabanı hafıza akışları ve DOCX belgeleri bulunur.

PDF Görüntüleyiciye Etkileşimli Özellikler Nasıl Eklenir?

PDF görüntüleyiciyi sayfa gezinme, döndürme, yazdırma ve indirme işlevselliği ile genişletin:

@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

Bu kod, sayfa gezinme, döndürme, yazdırma ve indirme işlevselliği ekler. Yoğun gezinme gerektiren belgeler için sayfa numaraları ve yer imleri eklemeyi düşünün. Gelişmiş özellikler metin çıkarma ve PDF'den HTML'ye dönüştürmeyi içerebilir.

PDF Formları ve Açıklamalar Nasıl Yönlendirilir?

Form alanları ve açıklamalar içeren PDF belgeleri için IronPDF, alan değerlerini programatik olarak okuma ve yazma konusunda sağlam destek sağlar:

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

Bu, Blazor PDF görüntüleyici içindeki form doldurma yetenekleri sağlar, kullanıcıların form alanlarıyla doğrudan tarayıcıda etkileşimde bulunmasına olanak tanır. Kod, form alanlarından geçer ve değerleri programatik olarak ayarlar, dinamik ön doldurma gerektiren uygulamalar için idealdir. IronPDF ayrıca dijital imzaları ve metin açıklamalarını destekler.

Desteklenen alan türleri arasında metin girişleri, onay kutuları, radyo düğmeleri, açılır listeler, dijital imza alanları, çok satırlı metin alanları ve tarih seçiciler bulunur.

Büyük PDF'ler İçin Performans Nasıl Optimize Edilir?

Özellikle büyük dosyalar için PDF'leri görüntülerken iyi performansı sağlamak için parçalı yükleme ve bellek yönetimi kullanın:

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

Bu yaklaşım, büyük PDF dosyalarını parçalar halinde yükler, bellek sorunlarını önler ve yoğun belgelerle bile sorunsuz performansı sağlar. Mobil cihazlardaki veya sınırlı kaynaklara sahip sistemlerdeki PDF dosyalarını işlerken özellikle yararlıdır. Ek ayar seçenekleri için IronPDF'in performans kılavuzuna bakın.

Ek optimizasyon stratejileri, hızlı web görüntüleme için lineerleştirme, dosya boyutlarını küçültmek için sıkıştırma ve birçok PDF'yi eşzamanlı olarak işlemek için eş zamanlı işleme içerir. PDF Association en iyi uygulamalara göre, lineerleştirilmiş (web optimizasyonu yapılmış) PDF'ler, büyük belgeler için başlangıç yükleme süresini %30-60 oranında azaltabilir.

Parola Korumalı Dosyalar için Bir Blazor PDF Görüntüleyiciyi Nasıl Güvenli Hale Getirirsiniz?

Parola korumalı PDF dosyaları ile çalışırken, parolayı doğrudan PdfDocument.FromFile yöntemine iletin ve uygun HTTP güvenlik başlıklarını yapılandırın:

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

    var headers = new Dictionary<string, string>
    {
        { "X-Frame-Options", "SAMEORIGIN" },
        { "Content-Güvenlik-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-Güvenlik-Policy", "default-src 'self'" },
        { "X-Content-Type-Options", "nosniff" },
        { "Referrer-Policy", "no-referrer" }
    };

    await DisplayPdfContent(pdfDocument);
}

Private Async Function LoadSecurePdf(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-Güvenlik-Policy", "default-src 'self'"},
        {"X-Content-Type-Options", "nosniff"},
        {"Referrer-Policy", "no-referrer"}
    }

    Await DisplayPdfContent(pdfDocument)
End Function

Bu kod, doğru başlık yapılandırması aracılığıyla güvenliği koruyarak parola korumalı PDF belgeleri yüklemeyi gösterir. Gelişmiş kimlik doğrulama için dijital imzaları düşünün. PDF temizleme işlemini uygulayarak, potansiyel olarak zararlı içerikleri kaldırın ve hassas bilgileri karartın.

Parolalarla çalışırken, asla düz metin veya istemci tarafı kodda saklamayın. Güvenli giriş yöntemlerini uygun doğrulama ile kullanın, hassas belgeler için oturum zaman aşımı uygulayın ve kullanım sonrası parolaları bellekten temizleyin. Microsoft'un ASP.NET Core güvenlik kılavuzu, kullanıcı tarafından sağlanan herhangi bir kimlik bilgisini, aşağı akış API'lerine geçirmeden önce her zaman doğrulamanızı ve temizlemenizi önerir.

Blazor'da PDF Görüntülemeye Yönelik Temel Dersler Nelerdir?

IronPDF ile bir Blazor PDF görüntüleyici uygulamak, geliştiricilere web uygulamalarında PDF'leri görüntülemek için eksiksiz bir çözüm sunar. Temel görüntülemeden form doldurma ve açıklama gibi gelişmiş özelliklere kadar, IronPDF'nin PDF görüntüleyici bileşeni profesyonel uygulamalar için gereken işlevselliği sunar.

Gösterilen örnekler, çeşitli PDF kaynaklarını işleyen, etkileşimli özellikler sunan ve iyi performans sağlayan güvenilir bir Blazor PDF görüntüleyici nasıl oluşturulacağını gösterir. Basit bir belge görüntüleyici veya karmaşık bir belge yönetim sistemi oluştururken, IronPDF'nin Blazor Server uygulamaları ile entegrasyonu, profesyonel PDF görüntüleme yeteneklerini uygulamayı kolaylaştırır.

Anahtar faydalar şunlardır:

• Platformlar arası uyumluluk ile tüm tarayıcılarda tutarlı render
• Gelişmiş güvenlik özellikleri hassas belgeler için
• Performans optimizasyonu büyük dosyalar için async ve parçalı yükleme aracılığıyla
• Tam form işleme yetenekleri, dijital imzalar dahil
• Mevcut .NET uygulamaları ile sorunsuz entegrasyon

IronPDF, Azure, AWS, Docker ve geleneksel Windows ortamlarını destekler. Kendi görüntüleyicinizi oluşturmaya hazır mısınız? IronPDF'nin ücretsiz deneme sürümü ile başlayın ve Blazor uygulamalarınızda etkili PDF görüntüleme deneyimleri oluşturmak için tam belgeleri ve kod örneklerini inceleyin.