Comment afficher des PDF dans Blazor avec IronPDF

Pourquoi une application Blazor a-t-elle besoin d'une visionneuse PDF dédiée ?

L'affichage de fichiers PDF dans les applications web modernes nécessite un composant de visualisation fiable qui dépasse les capacités de base d'un navigateur. Pour les développeurs .NET qui créent des applications Blazor , IronPDF fournit une solution de visualisation PDF efficace qui s'intègre à votre application Blazor Server . Cela permet un rendu PDF haute performance et des fonctionnalités riches sans dépendre d'outils tiers du navigateur.

La prise en charge native des fichiers PDF par les navigateurs varie considérablement d'un navigateur à l'autre et d'une plateforme à l'autre, ce qui entraîne des expériences utilisateur incohérentes. En intégrant une visionneuse PDF personnalisée à votre application Blazor , vous obtenez un contrôle total sur l'expérience de visualisation, garantissant ainsi une fonctionnalité cohérente sur toutes les plateformes. Ceci est particulièrement important pour les applications exigeant des normes de conformité et des fonctionnalités de sécurité avancées.

Le framework Blazor , basé sur ASP.NET Core de Microsoft , permet un développement par composants qui s'intègre naturellement aux bibliothèques de manipulation de PDF. Plutôt que d'intégrer un widget de visualisation tiers provenant d'un CDN externe, vous pouvez créer un composant adapté aux exigences exactes de votre application.

Comment installer IronPDF dans un projet Blazor ?

Avant d'implémenter votre visionneuse PDF Blazor , installez IronPDF. Ajoutez-le à votre application Blazor Server via NuGet en utilisant soit la console du gestionnaire de packages, soit l'interface de ligne de commande .NET :

Install-Package IronPdf

Install-Package IronPdf

dotnet add package IronPdf

dotnet add package IronPdf

Ensuite, créez une nouvelle application Blazor et assurez-vous d'avoir installé la dernière version de .NET . Stockez les fichiers PDF dans le dossier wwwroot pour un accès facile, ou chargez-les à partir d'autres sources comme des tableaux d'octets ou des URL. La présentation de l'installation fournit des instructions détaillées pour différents scénarios de déploiement.

Comment créer un composant de visualisation PDF Blazor ?

Créez un composant de visualisation PDF Blazor basique capable d'afficher des documents PDF. Créez un nouveau composant Razor dans votre projet :

@page "/pdfviewer"
@rendermode InteractiveServer
@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 InteractiveServer
@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
End Code

Ce code crée un composant de visualisation PDF qui charge un document PDF et l'affiche à l'aide d'une iframe. La méthode LoadPdfDocument lit un PDF du dossier wwwroot et le convertit en une URL de données base64 que l'iframe affiche directement. Cette approche fonctionne bien avec différentes versions de PDF et prend en charge l'encodage UTF-8 pour les documents internationaux.

Comment utiliser l'interopérabilité JavaScript pour un meilleur affichage des PDF ?

Pour un meilleur contrôle de l'affichage du contenu PDF, utilisez l'interopérabilité JavaScript pour gérer les fonctionnalités de la visionneuse PDF. Ce modèle charge un module JavaScript de manière asynchrone et délègue le rendu aux API blob/URL natives du navigateur – une technique bien adaptée au cycle de vie des composants Blazor :

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

Ajoutez la fonction JavaScript correspondante à votre fichier wwwroot/pdfViewerInterop.js. Notez que ce fichier utilise JavaScript (et non C#), enregistré en tant que module .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.

Cette fonction JavaScript crée un blob à partir des données PDF, génère une URL d'objet et ajoute une iframe au conteneur. Cette technique prend en charge le rendu JavaScript et les délais de rendu personnalisés pour les documents complexes.

Comment charger des fichiers PDF provenant de sources multiples ?

Votre visionneuse PDF Blazor peut récupérer et afficher des documents PDF provenant de diverses sources. L'exemple ci-dessous illustre le chargement à partir d'une URL et à partir de contenu 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

La méthode LoadFromUrl récupère des documents PDF à partir d'emplacements distants, tandis que LoadFromHtmlContent montre comment convertir du HTML en PDF à la volée. Le moteur de rendu de Chrome garantit une conversion HTML précise. Les options de source supplémentaires incluent Azure Stockage Blob, les flux de mémoire de base de données et les documents DOCX .

Comment ajouter des fonctionnalités interactives à une visionneuse PDF ?

Étendez les fonctionnalités de la visionneuse PDF avec la navigation entre les pages, la rotation, l'impression et le téléchargement :

@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

Ce code ajoute des fonctionnalités de navigation, de rotation , d'impression et de téléchargement de pages. Pensez à ajouter des numéros de page et des signets pour les documents comportant de nombreuses sections à naviguer. Les fonctionnalités avancées peuvent inclure l'extraction de texte et la conversion de PDF en HTML.

Comment gérez-vous les formulaires PDF et les annotations ?

Pour les documents PDF comportant des champs de formulaire et des annotations , IronPDF offre une prise en charge robuste de la lecture et de l'écriture programmatique des valeurs des champs :

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

Cela permet d'intégrer des fonctionnalités de remplissage de formulaires directement dans la visionneuse PDF Blazor , permettant ainsi aux utilisateurs d'interagir avec les champs du formulaire directement dans le navigateur. Le code parcourt les champs du formulaire et définit les valeurs par programmation, ce qui est idéal pour les applications nécessitant un pré-remplissage dynamique. IronPDF prend également en charge les signatures numériques et les annotations textuelles.

Les types de champs pris en charge incluent les champs de texte, les cases à cocher, les boutons radio, les listes déroulantes, les champs de signature numérique, les zones de texte multilignes et les sélecteurs de date.

Comment optimiser les performances des fichiers PDF volumineux ?

Pour garantir de bonnes performances lors de l'affichage de fichiers PDF, notamment pour les fichiers volumineux, utilisez le chargement par blocs et la gestion de la mémoire :

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

Cette approche charge les fichiers PDF volumineux par blocs, évitant ainsi les problèmes de mémoire et garantissant des performances fluides même avec des documents volumineux. Il est particulièrement utile pour la manipulation de fichiers PDF sur des appareils mobiles ou des systèmes aux ressources limitées. Consultez le guide de performance d'IronPDF pour connaître les options de réglage supplémentaires.

Les stratégies d'optimisation supplémentaires comprennent la linéarisation pour un affichage Web rapide, la compression pour réduire la taille des fichiers et le traitement asynchrone pour gérer plusieurs fichiers PDF simultanément. Selon les bonnes pratiques de la PDF Association , les PDF linéarisés (optimisés pour le Web) peuvent réduire le temps de chargement initial de 30 à 60 % pour les documents volumineux.

Comment sécuriser une visionneuse PDF Blazor pour les fichiers protégés par mot de passe ?

Lorsque vous travaillez avec des fichiers PDF protégés par mot de passe , transmettez le mot de passe directement à PdfDocument.FromFile et configurez les en-têtes de sécurité HTTP appropriés :

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

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

    Await DisplayPdfContent(pdfDocument)
End Function

Ce code illustre le chargement de documents PDF protégés par mot de passe tout en maintenant la sécurité grâce à une configuration d'en-tête appropriée. Envisagez l'utilisation de signatures numériques pour une authentification renforcée. Mettre en œuvre un processus de nettoyage des fichiers PDF afin de supprimer les contenus potentiellement malveillants et de masquer les informations sensibles.

Lors de la gestion des mots de passe, ne les stockez jamais en clair ni dans le code côté client. Utilisez des méthodes de saisie sécurisées avec une validation appropriée, mettez en œuvre des délais d'expiration de session pour les documents sensibles et effacez les mots de passe de la mémoire après utilisation. Les recommandations de sécurité de Microsoft concernant ASP.NET Core préconisent de toujours valider et nettoyer les informations d'identification fournies par l'utilisateur avant de les transmettre aux API en aval.

Quels sont les points clés à retenir pour l'affichage des PDF dans Blazor?

L'intégration d'une visionneuse PDF Blazor avec IronPDF offre aux développeurs une solution complète pour l'affichage de fichiers PDF dans les applications web. De l'affichage de base aux fonctionnalités avancées telles que le remplissage de formulaires et les annotations, le composant de visualisation PDF d'IronPDF offre les fonctionnalités nécessaires aux applications Professional .

Les exemples présentés démontrent comment créer une visionneuse PDF Blazor fiable qui gère diverses sources PDF, offre des fonctionnalités interactives et maintient de bonnes performances. Qu'il s'agisse de créer une simple visionneuse de documents ou un système complexe de gestion de documents, l'intégration d'IronPDF avec les applications Blazor Server simplifie la mise en œuvre de fonctionnalités Professional de visualisation de PDF.

Les principaux avantages comprennent :

• Compatibilité multiplateforme avec un rendu cohérent sur tous les navigateurs
• Fonctionnalités de sécurité avancées pour les documents sensibles
• Optimisation des performances pour les fichiers volumineux grâce au chargement asynchrone et par blocs
• Fonctionnalités complètes de gestion des formulaires, y compris les signatures numériques
• Intégration fluide avec les applications .NET existantes

IronPDF prend en charge Azure, AWS, Docker et les environnements Windows traditionnels. Prêt à créer votre propre visionneuse ? Commencez par un essai gratuit d' IronPDF et consultez la documentation complète et les exemples de code pour créer des expériences de visualisation PDF efficaces dans vos applications Blazor .