Un visualiseur PDF Blazor rend les documents PDF en ligne en les convertissant en une URI de données base64 et en chargeant le résultat dans un élément <iframe>. Le ChromePdfRenderer de IronPDF convertit les chaînes HTML, les URLs en direct, ou le contenu dynamique en octets PDF dans un seul appel asynchrone, offrant aux applications Blazor Server et Blazor WebAssembly une capacité complète de génération et d'affichage de PDF sans plugins de visualiseur externes.
Les applications métier doivent régulièrement afficher des factures, des contrats et des rapports sans rediriger les utilisateurs vers un onglet séparé ni dépendre de la prise en charge des fichiers PDF par le navigateur, qui varie selon les appareils. Le modèle de composants de Blazor simplifie la génération d'un PDF sur le serveur, son encodage et son intégration dans n'importe quel composant de page, à condition que la bibliothèque gère la conversion de manière fiable.
Ce guide couvre l'installation, le rendu basé sur les URL et le HTML, la personnalisation avec les en-têtes et les pieds de page, les téléchargements du navigateur utilisant l'interopérabilité JavaScript , une comparaison des approches Blazor Server et Blazor WebAssembly, et quatre opérations étendues : la fusion, les annotations, la protection par mot de passe et l'affichage des fichiers téléchargés par l'utilisateur. Des composants Razor et des exemples C# de haut niveau équivalents sont fournis pour chaque technique.
Démarrez un essai gratuit IronPDF pour suivre les exemples de ce guide.
Pour commencer, il est nécessaire d'installer le package NuGet et d'ajouter une clé de licence à Program.cs. Installez IronPDF depuis la console du Package Manager :
Alternativement, recherchez 'IronPDF' dans l'interface de gestion des packages NuGet et sélectionnez la dernière version.
Installer avec NuGetAprès l'installation, ajoutez votre clé de licence à Program.cs avant toute opération PDF :
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"IronPDF est compatible avec .NET 10, .NET 9, .NET 8, .NET 6 et .NET Framework 4.6.2 et versions ultérieures. Pour le développement et les tests, la bibliothèque fonctionne sans clé de licence, mais appose un filigrane sur les PDF générés. Une licence d'essai gratuite supprime le filigrane pendant l'évaluation.
IronPDF prend en charge les projets Blazor Server et Blazor WebAssembly. Dans Blazor Server, le moteur de rendu s'exécute directement sur le serveur. Dans Blazor WebAssembly, la génération de PDF nécessite un point de terminaison API côté serveur ; La section consacrée à l'architecture, plus loin dans ce guide, explique les deux approches.
Le moyen le plus direct de créer un visualiseur PDF Blazor est de convertir une URL en PDF et de l'afficher dans un <iframe>. Le ChromePdfRenderer de IronPDF récupère la page web et la convertit en format PDF en utilisant le même moteur de rendu Chrome qui alimente Google Chrome, préservant fidèlement le CSS, la sortie JavaScript et la mise en page.
Le composant Razor suivant convertit une URL en PDF et l'affiche en ligne. La méthode GeneratePdf s'exécute sur le serveur dans une application Blazor Server, donc le moteur de rendu Chrome complet est disponible :
@page "/pdfviewer"
@using IronPdf
<h3>PDF Viewer</h3>
<button @onclick="GeneratePdf" class="btn btn-primary">Load PDF</button>
@if (!string.IsNullOrEmpty(pdfDataUri))
{
<iframe src="@pdfDataUri" style="width:100%; height:600px; border:1px solid #ccc; margin-top:20px;"></iframe>
}
@code {
private string pdfDataUri = string.Empty;
private async Task GeneratePdf()
{
var renderer = new ChromePdfRenderer();
// Convert the URL to PDF using the Chrome rendering engine
var pdf = await renderer.RenderUrlAsPdfAsync("https://ironpdf.com");
// Encode the PDF bytes as a base64 data URI for iframe display
var base64 = Convert.ToBase64String(pdf.BinaryData);
pdfDataUri = $"data:application/pdf;base64,{base64}";
}
}Pour les services en arrière-plan, les applications console ou les points de terminaison d'API côté serveur, la même conversion utilise des appels d'API identiques en dehors de tout contexte de composant :
using IronPdf;
var renderer = new ChromePdfRenderer();
// Fetch and convert the target URL to a PDF document
var pdf = await renderer.RenderUrlAsPdfAsync("https://ironpdf.com");
// Save to disk or use BinaryData for in-memory operations
pdf.SaveAs("output.pdf");
byte[] pdfBytes = pdf.BinaryData;Imports IronPdf
Dim renderer As New ChromePdfRenderer()
' Fetch and convert the target URL to a PDF document
Dim pdf = Await renderer.RenderUrlAsPdfAsync("https://ironpdf.com")
' Save to disk or use BinaryData for in-memory operations
pdf.SaveAs("output.pdf")
Dim pdfBytes As Byte() = pdf.BinaryDataRenderUrlAsPdfAsync récupère la page, exécute tous les JavaScript, applique le CSS et retourne un objet PdfDocument contenant le rendu. La propriété BinaryData expose les octets bruts du PDF pour le stockage, le streaming ou l'affichage. Le <iframe> affiche le rendu avec une barre d'outils de navigateur intégrée pour le zoom, la navigation et l'impression.
IronPDF fournit un contrôle de sortie via la classe ChromePdfRenderOptions. Vous pouvez définir le format du papier, ajuster les marges et ajouter des en-têtes et des pieds de page (texte ou HTML) à chaque page. Le guide des options de rendu présente la liste complète des propriétés disponibles.
Le composant suivant configure le papier A4 avec des marges et ajoute un texte d'en-tête et de pied de page à chaque page. Attribuez RenderingOptions avant d'appeler toute méthode de rendu pour les appliquer globalement à l'instance de rendu :
@page "/pdfcustom"
@using IronPdf
<h3>Customized PDF Viewer</h3>
<button @onclick="GenerateCustomizedPdf" class="btn btn-primary">Generate Customized PDF</button>
@if (!string.IsNullOrEmpty(pdfDataUri))
{
<iframe src="@pdfDataUri" style="width:100%; height:600px; border:1px solid #ccc; margin-top:20px;"></iframe>
}
@code {
private string pdfDataUri = string.Empty;
private async Task GenerateCustomizedPdf()
{
var renderer = new ChromePdfRenderer
{
RenderingOptions = new ChromePdfRenderOptions
{
PaperSize = IronPdf.Rendering.PdfPaperSize.A4,
MarginTop = 25,
MarginBottom = 25,
MarginLeft = 20,
MarginRight = 20,
// Header with dynamic date replacement
TextHeader = new TextHeaderFooter
{
CenterText = "Monthly Report - {date}",
FontSize = 12
},
// Footer with page numbering
TextFooter = new TextHeaderFooter
{
LeftText = "Confidential",
RightText = "Page {page} of {total-pages}",
FontSize = 10
}
}
};
var pdf = await renderer.RenderUrlAsPdfAsync("https://example.com/report");
pdfDataUri = $"data:application/pdf;base64,{Convert.ToBase64String(pdf.BinaryData)}";
}
}Les mêmes options s'appliquent dans n'importe quel contexte .NET . Ce modèle fonctionne bien au sein d'une API minimale ASP.NET Core ou d'un générateur de rapports planifié :
using IronPdf;
using IronPdf.Rendering;
var renderer = new ChromePdfRenderer
{
RenderingOptions = new ChromePdfRenderOptions
{
PaperSize = PdfPaperSize.A4,
MarginTop = 25,
MarginBottom = 25,
TextHeader = new TextHeaderFooter { CenterText = "Report - {date}", FontSize = 12 },
TextFooter = new TextHeaderFooter { RightText = "Page {page} of {total-pages}", FontSize = 10 }
}
};
var pdf = await renderer.RenderUrlAsPdfAsync("https://example.com/report");
pdf.SaveAs("customized-report.pdf");Imports IronPdf
Imports IronPdf.Rendering
Dim renderer As New ChromePdfRenderer With {
.RenderingOptions = New ChromePdfRenderOptions With {
.PaperSize = PdfPaperSize.A4,
.MarginTop = 25,
.MarginBottom = 25,
.TextHeader = New TextHeaderFooter With {.CenterText = "Report - {date}", .FontSize = 12},
.TextFooter = New TextHeaderFooter With {.RightText = "Page {page} of {total-pages}", .FontSize = 10}
}
}
Dim pdf = Await renderer.RenderUrlAsPdfAsync("https://example.com/report")
pdf.SaveAs("customized-report.pdf")Les variables de modèle, y compris {page}, {total-pages}, et {date} sont remplacées par des valeurs réelles au moment du rendu. Pour des mises en page complexes de marques, utilisez les propriétés HtmlHeader et HtmlFooter au lieu de TextHeader et TextFooter. Le guide des en-têtes et pieds de page contient des exemples complets pour les deux approches.
Afficher des PDFs dans un <iframe> offre une visualisation, mais les utilisateurs ont souvent besoin de télécharger le fichier. L'interopérabilité JavaScript déclenche un téléchargement de navigateur à partir d'un flux d'octets .NET. Pour obtenir d'autres modèles à télécharger et à exporter, consultez le guide PDF d'exportation et d'enregistrement .
Injectez IJSRuntime dans le composant et appelez une fonction d'assistance JavaScript pour initier le téléchargement. Le DotNetStreamReference diffuse les octets du PDF sans charger l'intégralité du fichier dans la mémoire JavaScript à la fois :
@page "/pdfdownload"
@using IronPdf
@inject IJSRuntime JSRuntime
<h3>Download PDF</h3>
<button @onclick="DownloadPdf" class="btn btn-success">Download PDF</button>
@code {
private async Task DownloadPdf()
{
var renderer = new ChromePdfRenderer();
var pdf = await renderer.RenderHtmlAsPdfAsync("<h1>Invoice</h1><p>Total: $1,299</p>");
// Stream the PDF bytes to the browser as a downloadable file
using var streamRef = new DotNetStreamReference(stream: new MemoryStream(pdf.BinaryData));
await JSRuntime.InvokeVoidAsync("downloadFileFromStream", "invoice.pdf", streamRef);
}
}Ajoutez cette fonction JavaScript à votre fichier _Host.cshtml ou App.razor, comme décrit dans la documentation d'interopérabilité JavaScript de Microsoft pour Blazor :
window.downloadFileFromStream = async (fileName, contentStreamReference) => {
const arrayBuffer = await contentStreamReference.arrayBuffer();
const blob = new Blob([arrayBuffer]);
const url = URL.createObjectURL(blob);
const anchorElement = document.createElement('a');
anchorElement.href = url;
anchorElement.download = fileName ?? '';
anchorElement.click();
anchorElement.remove();
URL.revokeObjectURL(url);
};Dans un point d'extrémité API côté serveur, renvoyez directement les octets du PDF en utilisant Results.File. Le navigateur reçoit le fichier avec les en-têtes Content-Disposition corrects et déclenche automatiquement le téléchargement :
using IronPdf;
// ASP.NET Core minimal API endpoint
app.MapGet("/api/pdf/invoice", async () =>
{
var renderer = new ChromePdfRenderer();
var pdf = await renderer.RenderHtmlAsPdfAsync("<h1>Invoice</h1><p>Total: $1,299</p>");
// Return with file download headers
return Results.File(pdf.BinaryData, "application/pdf", "invoice.pdf");
});Imports IronPdf
' ASP.NET Core minimal API endpoint
app.MapGet("/api/pdf/invoice", Async Function()
Dim renderer As New ChromePdfRenderer()
Dim pdf = Await renderer.RenderHtmlAsPdfAsync("<h1>Invoice</h1><p>Total: $1,299</p>")
' Return with file download headers
Return Results.File(pdf.BinaryData, "application/pdf", "invoice.pdf")
End Function)La génération de PDF à partir de HTML offre un contrôle total sur la mise en page, la liaison des données et le style. Cette approche convient aux factures, aux rapports et à tout document créé à partir de données d'application en temps réel. Pour des techniques de rendu plus avancées, consultez le guide de conversion HTML vers PDF .
Le composant ci-dessous génère une chaîne HTML de facture à partir de données C# et la convertit en PDF. Le ChromePdfRenderer traite la chaîne HTML de la même manière qu'une page web, appliquant tous les CSS et la rendant avec le moteur Chrome :
@page "/invoicedemo"
@using IronPdf
<h3>Invoice Generator</h3>
<button @onclick="GenerateInvoice" class="btn btn-primary">Generate Invoice PDF</button>
@if (!string.IsNullOrEmpty(pdfDataUri))
{
<iframe src="@pdfDataUri" style="width:100%; height:600px; border:1px solid #ccc; margin-top:20px;"></iframe>
}
@code {
private string pdfDataUri = string.Empty;
private async Task GenerateInvoice()
{
var invoiceHtml = $@"
<html>
<head>
<style>
body {{font-family: Arial, sans-serif;}}
.header {{background-color: #f0f0f0; padding: 20px;}}
.invoice-table {{width: 100%; border-collapse: collapse;}}
.invoice-table th, .invoice-table td {{border: 1px solid #ddd; padding: 8px;}}
.total {{font-weight: bold; font-size: 18px;}}
</style>
</head>
<body>
<div class='header'>
<h1>Invoice #INV-2025-001</h1>
<p>Date: {DateTime.Now:MM/dd/yyyy}</p>
</div>
<table class='invoice-table'>
<thead>
<tr>
<th>Item</th><th>Quantity</th><th>Price</th><th>Total</th>
</tr>
</thead>
<tbody>
<tr>
<td>IronPDF License</td><td>1</td><td>$999</td><td>$999</td>
</tr>
<tr>
<td>Priority Support</td><td>1</td><td>$250</td><td>$250</td>
</tr>
</tbody>
</table>
<p class='total'>Total Amount: $999</p>
</body>
</html>";
var renderer = new ChromePdfRenderer();
var pdf = await renderer.RenderHtmlAsPdfAsync(invoiceHtml);
pdfDataUri = $"data:application/pdf;base64,{Convert.ToBase64String(pdf.BinaryData)}";
}
}La même approche de chaîne HTML fonctionne dans n'importe quel contexte .NET , y compris les applications console, les services en arrière-plan et les points de terminaison d'API . L'interpolation de chaînes C# ou une bibliothèque de modèles insère des données dynamiques avant de transmettre la chaîne au moteur de rendu :
using IronPdf;
var html = """
<html>
<body>
<h1>Invoice #INV-2025-001</h1>
<table>
<tr><th>Item</th><th>Total</th></tr>
<tr><td>IronPDF License</td><td>$999</td></tr>
<tr><td>Priority Support</td><td>$250</td></tr>
</table>
<p><strong>Total: $999</strong></p>
</body>
</html>
""";
var renderer = new ChromePdfRenderer();
var pdf = await renderer.RenderHtmlAsPdfAsync(html);
pdf.SaveAs("invoice.pdf");RenderHtmlAsPdfAsync accepte toute chaîne HTML valide, y compris le CSS en ligne et le JavaScript intégré. L'implémentation gère automatiquement la mise en page, le rendu des polices et les sauts de page.
Le modèle d'hébergement détermine où s'exécute la génération du PDF et comment les octets parviennent au navigateur. Comprendre cette distinction permet d'éviter une erreur architecturale courante lors de la création de visionneuses PDF Blazor .
Blazor Server exécute tout le code C# sur le serveur. ChromePdfRenderer s'exécute côté serveur, et les octets résultants sont envoyés au navigateur via la connexion SignalR existante. Il s'agit du chemin d'intégration le plus simple, ne nécessitant aucun point de terminaison API ou appel réseau supplémentaire au-delà de ce qui est indiqué dans les sections précédentes.
Blazor WebAssembly exécute C# dans le bac à sable du navigateur en utilisant WASM. Le moteur de rendu de IronPDF dépend de binaires natifs qui ne peuvent pas s'exécuter dans le bac à sable du navigateur, donc ChromePdfRenderer n'est pas disponible dans un projet WASM directement. La méthode correcte consiste à appeler un point de terminaison d'API côté serveur qui effectue la génération de PDF et renvoie les octets en réponse.
Sur le serveur, définissez un point de terminaison API minimal qui génère et renvoie le PDF :
// Program.cs (ASP.NET Core host project)
using IronPdf;
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
app.MapGet("/api/pdf/report", async () =>
{
var renderer = new ChromePdfRenderer();
var pdf = await renderer.RenderHtmlAsPdfAsync("<h1>Quarterly Report</h1><p>Generated server-side.</p>");
// Return PDF bytes with file download headers
return Results.File(pdf.BinaryData, "application/pdf", "report.pdf");
});Imports IronPdf
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"
app.MapGet("/api/pdf/report", Async Function()
Dim renderer = New ChromePdfRenderer()
Dim pdf = Await renderer.RenderHtmlAsPdfAsync("<h1>Quarterly Report</h1><p>Generated server-side.</p>")
' Return PDF bytes with file download headers
Return Results.File(pdf.BinaryData, "application/pdf", "report.pdf")
End Function)Sur le client WASM, injectez HttpClient et appelez le point d'extrémité API. Le modèle de projet hébergé Blazor WASM préconfigure HttpClient pour cibler l'adresse de base du serveur :
@page "/wasm-pdf-viewer"
@inject HttpClient Http
<h3>PDF Viewer</h3>
<button @onclick="LoadPdf" class="btn btn-primary">Load Report</button>
@if (!string.IsNullOrEmpty(pdfDataUri))
{
<iframe src="@pdfDataUri" style="width:100%; height:600px;"></iframe>
}
@code {
private string pdfDataUri = string.Empty;
private async Task LoadPdf()
{
// Fetch PDF bytes from the server-side generation endpoint
var bytes = await Http.GetByteArrayAsync("/api/pdf/report");
pdfDataUri = $"data:application/pdf;base64,{Convert.ToBase64String(bytes)}";
}
}Ce modèle permet de confier tout le travail de rendu lourd au serveur, tandis que le client WASM ne gère que l'affichage. Pour une utilisation en production, ajoutez une authentification au point de terminaison de l'API et limitez le contenu PDF généré aux données de l'utilisateur authentifié.
L'API d'IronPDF va bien au-delà de la simple visualisation. Les sections suivantes couvrent quatre opérations couramment nécessaires dans les flux de travail de documents Blazor : la fusion de plusieurs documents, l'ajout d'annotations, l'application d'une protection par mot de passe et l'affichage des fichiers téléchargés par l'utilisateur.
La fusion combine plusieurs instances PdfDocument en un seul fichier, utile pour assembler des sections de rapport, ajouter des annexes, ou concaténer des fichiers sélectionnés par l'utilisateur. Le guide sur la fusion et la division des fichiers PDF couvre les opérations d'insertion et de division au niveau de la page.
using IronPdf;
var renderer = new ChromePdfRenderer();
// Generate two separate sections as individual PDF documents
var section1 = await renderer.RenderHtmlAsPdfAsync("<h1>Section 1: Overview</h1>");
var section2 = await renderer.RenderHtmlAsPdfAsync("<h1>Section 2: Details</h1>");
// Merge into a single document preserving all pages
var merged = PdfDocument.Merge(section1, section2);
merged.SaveAs("combined-report.pdf");Imports IronPdf
Dim renderer As New ChromePdfRenderer()
' Generate two separate sections as individual PDF documents
Dim section1 = Await renderer.RenderHtmlAsPdfAsync("<h1>Section 1: Overview</h1>")
Dim section2 = Await renderer.RenderHtmlAsPdfAsync("<h1>Section 2: Details</h1>")
' Merge into a single document preserving all pages
Dim merged = PdfDocument.Merge(section1, section2)
merged.SaveAs("combined-report.pdf")Pour afficher le document fusionné dans un composant Blazor, passez merged.BinaryData au motif d'URI de données base64 des sections précédentes. L'objet PdfDocument fusionné accepte également d'autres opérations (marquage, paramètres de sécurité, ou ajouts de pages supplémentaires) avant d'être encodé pour l'affichage.
Les annotations permettent d'associer des notes et des commentaires du réviseur à des emplacements précis sur les pages, sans modifier le contenu du document sous-jacent. IronPDF prend en charge les annotations textuelles, les zones de texte libre et d'autres types de balisage. Consultez le guide des annotations pour obtenir la liste complète des propriétés d'annotation.
using IronPdf;
using IronPdf.Annotations;
var renderer = new ChromePdfRenderer();
var pdf = await renderer.RenderHtmlAsPdfAsync("<h1>Contract Document</h1><p>Review required on clause 3.</p>");
// Add a text annotation to page 0 at position (50, 650)
var annotation = new TextAnnotation(pageIndex: 0)
{
Title = "Reviewer Note",
Contents = "Please confirm clause 3 before signing.",
X = 50,
Y = 650,
Width = 200,
Height = 50,
Printable = false,
OpenByDefault = true
};
pdf.Annotations.Add(annotation);
pdf.SaveAs("annotated-contract.pdf");Imports IronPdf
Imports IronPdf.Annotations
Dim renderer As New ChromePdfRenderer()
Dim pdf = Await renderer.RenderHtmlAsPdfAsync("<h1>Contract Document</h1><p>Review required on clause 3.</p>")
' Add a text annotation to page 0 at position (50, 650)
Dim annotation As New TextAnnotation(pageIndex:=0) With {
.Title = "Reviewer Note",
.Contents = "Please confirm clause 3 before signing.",
.X = 50,
.Y = 650,
.Width = 200,
.Height = 50,
.Printable = False,
.OpenByDefault = True
}
pdf.Annotations.Add(annotation)
pdf.SaveAs("annotated-contract.pdf")Les annotations sont préservées lorsque le PDF est ouvert dans tout visualiseur standard, y compris l'affichage <iframe> du navigateur. Pour les applications Blazor, exécutez la logique d'annotation côté serveur et retournez pdf.BinaryData au composant pour l'affichage.
La protection par mot de passe restreint l'accès aux documents sensibles tels que les rapports financiers ou les dossiers RH. IronPDF prend en charge les mots de passe utilisateur (nécessaires pour ouvrir le document) et les mots de passe propriétaire (nécessaires pour modifier les autorisations). Le guide de sécurité PDF répertorie tous les indicateurs d'autorisation disponibles.
using IronPdf;
var renderer = new ChromePdfRenderer();
var pdf = await renderer.RenderHtmlAsPdfAsync("<h1>Confidential Report</h1>");
// Set the password required to open the document
pdf.Password = "user-open-password";
// Set the owner password to control editing and printing rights
pdf.SecuritySettings.OwnerPassword = "owner-edit-password";
pdf.SecuritySettings.AllowUserPrinting = IronPdf.Security.PdfPrintSecurity.FullPrintRights;
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SaveAs("protected-report.pdf");Imports IronPdf
Dim renderer As New ChromePdfRenderer()
Dim pdf = Await renderer.RenderHtmlAsPdfAsync("<h1>Confidential Report</h1>")
' Set the password required to open the document
pdf.Password = "user-open-password"
' Set the owner password to control editing and printing rights
pdf.SecuritySettings.OwnerPassword = "owner-edit-password"
pdf.SecuritySettings.AllowUserPrinting = IronPdf.Security.PdfPrintSecurity.FullPrintRights
pdf.SecuritySettings.AllowUserCopyPasteContent = False
pdf.SaveAs("protected-report.pdf")Les PDFs protégés par mot de passe affichent une invite de mot de passe dans l'<iframe> du navigateur. Cette approche fonctionne pour les documents distribués par téléchargement ; Pour un affichage intégré sans invite, appliquez le mot de passe uniquement aux documents renvoyés par téléchargement.
L'affichage d'un PDF téléchargé par un utilisateur nécessite la lecture des octets du fichier entrant et leur encodage sous forme d'URI de données. Le composant de téléchargement ci-dessous utilise le contrôle InputFile de Blazor pour capturer le fichier, puis l'affiche directement sans aucun rendu supplémentaire :
@page "/upload-viewer"
@using IronPdf
<h3>Upload and View a PDF</h3>
<InputFile OnChange="LoadUploadedPdf" accept=".pdf" />
@if (!string.IsNullOrEmpty(pdfDataUri))
{
<iframe src="@pdfDataUri" style="width:100%; height:600px; margin-top:20px;"></iframe>
}
@code {
private string pdfDataUri = string.Empty;
private async Task LoadUploadedPdf(InputFileChangeEventArgs e)
{
using var stream = e.File.OpenReadStream(maxAllowedSize: 10 * 1024 * 1024);
using var ms = new MemoryStream();
await stream.CopyToAsync(ms);
var bytes = ms.ToArray();
// Encode the uploaded PDF bytes directly for display
pdfDataUri = $"data:application/pdf;base64,{Convert.ToBase64String(bytes)}";
}
}Pour les PDFs téléversés qui nécessitent un traitement côté serveur avant l'affichage, comme le marquage, l'extraction de pages, ou le re-chiffrement, chargez d'abord les octets dans un PdfDocument :
var pdf = new PdfDocument(bytes);
// Apply operations, then re-encode
pdfDataUri = $"data:application/pdf;base64,{Convert.ToBase64String(pdf.BinaryData)}";Dim pdf As New PdfDocument(bytes)
' Apply operations, then re-encode
pdfDataUri = $"data:application/pdf;base64,{Convert.ToBase64String(pdf.BinaryData)}"Cela permet de conserver la même structure de composants tout en activant l'intégralité de l'API IronPDF sur le fichier téléchargé.
Ce guide couvrait le flux de travail complet d'une visionneuse PDF Blazor avec IronPDF: installation sur .NET 10, rendu URL et HTML, personnalisation de la sortie avec en-têtes et pieds de page, interopérabilité JavaScript pour les téléchargements du navigateur, la différence architecturale entre Blazor Server et Blazor WebAssembly, et quatre opérations sur les documents : fusion, annotations, protection par mot de passe et téléchargements par l'utilisateur.
Pour approfondir ces bases, explorez ces ressources :
Obtenez votre licence d'essai gratuite pour supprimer les filigranes et tester IronPDF sur votre application Blazor . IronPDF prend en charge .NET 10 , ASP.NET Core, Blazor Server et les projets Blazor WebAssembly hébergés sans configuration supplémentaire. Pour obtenir des conseils d'intégration supplémentaires, consultez la documentation officielle de Microsoft sur Blazor .
Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes et créer des manuels bien structurés et visuellement attrayants.
IronPDF fait partie de IRONSUITE
10 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
