Um visualizador de PDF Blazor renderiza documentos PDF inline convertendo-os em um URI de dados base64 e carregando o resultado em um elemento <iframe>. O ChromePdfRenderer do IronPDF converte cadeias de caracteres HTML, URLs ao vivo ou conteúdo dinâmico em bytes PDF em uma única chamada assíncrona, oferecendo às aplicações Blazor Server e Blazor WebAssembly capacidade total de geração e exibição de PDF sem plugins de visualização externos.
Aplicativos empresariais frequentemente precisam exibir faturas, contratos e relatórios sem redirecionar os usuários para uma aba separada ou depender do suporte a PDF do navegador, que varia de dispositivo para dispositivo. O modelo de componentes do Blazor facilita a geração de um PDF no servidor, sua codificação e transmissão para qualquer componente da página, desde que a biblioteca lide com a conversão de forma confiável.
Este guia aborda a instalação, a renderização baseada em URL e HTML, a personalização com cabeçalhos e rodapés, os downloads via navegador usando interoperabilidade com JavaScript , uma comparação das abordagens Blazor Server e Blazor WebAssembly e quatro operações avançadas: mesclagem, anotações, proteção por senha e exibição de arquivos enviados pelo usuário. Componentes Razor e exemplos de C# em nível superior equivalentes são fornecidos para cada técnica.
Inicie um teste gratuito do IronPDF para acompanhar os exemplos deste guia.
Começar requer instalar o pacote NuGet e adicionar uma chave de licença ao Program.cs. Instale o IronPDF a partir do Gerenciador de Pacotes:
Por outro lado, procure por "IronPDF" na interface do Gerenciador de Pacotes NuGet e selecione a versão mais recente.
Instalar com NuGetApós a instalação, adicione sua chave de licença ao Program.cs antes de qualquer operação de PDF:
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"O IronPDF é compatível com .NET 10, .NET 9, .NET 8, .NET 6 e .NET Framework 4.6.2 e versões posteriores. Para fins de desenvolvimento e teste, a biblioteca funciona sem uma chave de licença, mas adiciona uma marca d'água aos PDFs gerados. Uma licença de avaliação gratuita remove a marca d'água durante o período de teste.
O IronPDF é compatível com projetos Blazor Server e Blazor WebAssembly. No Blazor Server, o mecanismo de renderização é executado diretamente no servidor. Em Blazor WebAssembly, a geração de PDFs requer um endpoint de API do lado do servidor; A seção sobre arquitetura, apresentada mais adiante neste guia, explica ambas as abordagens.
A maneira mais direta de criar um visualizador de PDF Blazor é converter um URL em um PDF e exibi-lo em um <iframe>. O ChromePdfRenderer do IronPDF busca a página da web e a converte em formato PDF usando o mesmo motor de renderização Chrome que alimenta o Google Chrome, preservando CSS, saída de JavaScript e layout fielmente.
O seguinte componente Razor converte um URL para PDF e o exibe inline. O método GeneratePdf é executado no servidor em um aplicativo Blazor Server, então o motor de renderização Chrome completo está disponível:
@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}";
}
}Para serviços em segundo plano, aplicativos de console ou endpoints de API do lado do servidor, a mesma conversão usa chamadas de API idênticas fora de qualquer contexto de componente:
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.BinaryDataO RenderUrlAsPdfAsync busca a página, executa todo o JavaScript, aplica o CSS e retorna um objeto PdfDocument contendo a saída renderizada. A propriedade BinaryData expõe os bytes PDF brutos para armazenamento, streaming ou exibição. O <iframe> exibe a saída com uma barra de ferramentas de navegador embutida para zoom, navegação e impressão.
O IronPDF fornece controle de saída através da classe ChromePdfRenderOptions. Você pode definir o tamanho do papel, ajustar as margens e adicionar cabeçalhos e rodapés de texto ou HTML a cada página. O guia de opções de renderização abrange a lista completa de propriedades disponíveis.
O componente a seguir configura o papel A4 com margens e adiciona texto de cabeçalho e rodapé a cada página. Atribua RenderingOptions antes de chamar qualquer método de renderização para aplicá-los globalmente à instância de renderização:
@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)}";
}
}As mesmas opções se aplicam em qualquer contexto .NET . Esse padrão funciona bem dentro de uma API minimalista do ASP.NET Core ou de um gerador de relatórios agendados:
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")As variáveis de modelo, incluindo {page}, {total-pages} e {date}, são substituídas por valores reais no momento da renderização. Para layouts complexos de marca, use as propriedades HtmlHeader e HtmlFooter em vez de TextHeader e TextFooter. O guia de cabeçalhos e rodapés contém exemplos completos para ambas as abordagens.
Exibir PDFs em um <iframe> lida com a visualização, mas os usuários frequentemente precisam baixar o arquivo. A interoperabilidade do JavaScript aciona um download do navegador a partir de um fluxo de bytes .NET. Para obter mais informações sobre como baixar e exportar padrões, consulte o guia de exportação e salvamento em PDF .
Injete IJSRuntime no componente e chame uma função auxiliar JavaScript para iniciar o download. O DotNetStreamReference transmite os bytes do PDF sem carregar todo o arquivo na memória do JavaScript de uma vez:
@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);
}
}Adicione esta função JavaScript ao seu arquivo _Host.cshtml ou App.razor, conforme descrito na documentação de interoperabilidade de JavaScript do Blazor da Microsoft:
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);
};Em um ponto de extremidade da API do lado do servidor, retorne os bytes do PDF diretamente usando Results.File. O navegador recebe o arquivo com cabeçalhos Content-Disposition corretos e aciona o download automaticamente:
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)A geração de PDFs a partir de HTML oferece controle total sobre o layout, a vinculação de dados e o estilo. Essa abordagem é adequada para faturas, relatórios e qualquer documento criado a partir de dados de aplicativos em tempo real. Para técnicas de renderização mais avançadas, consulte o guia de conversão de HTML para PDF .
O componente abaixo constrói uma string HTML de fatura a partir de dados C# e a converte em um PDF. O ChromePdfRenderer trata a string HTML da mesma forma que uma página da web, aplicando todo o CSS e renderizando-o com o motor 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)}";
}
}A mesma abordagem de string HTML funciona em qualquer contexto .NET , incluindo aplicativos de console, serviços em segundo plano e endpoints de API . Interpolação de strings em C# ou uma biblioteca de templates insere dados dinâmicos antes de passar a string para o renderizador:
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");O RenderHtmlAsPdfAsync aceita qualquer string HTML válida, incluindo CSS inline e JavaScript incorporado. A implementação lida automaticamente com o layout, a renderização de fontes e as quebras de página.
O modelo de hospedagem determina onde a geração de PDFs é executada e como os bytes chegam ao navegador. Compreender essa distinção evita um erro arquitetônico comum ao criar visualizadores de PDF em Blazor .
Blazor Server executa todo o código C# no servidor. O ChromePdfRenderer é executado do lado do servidor, e os bytes resultantes são enviados para o navegador através da conexão SignalR existente. Este é o caminho de integração mais simples, não exigindo endpoints de API adicionais nem chamadas de rede além do que foi mostrado nas seções anteriores.
Blazor WebAssembly executa C# no sandbox do navegador usando WASM. O motor de renderização do IronPDF depende de binários nativos que não podem ser executados dentro do sandbox do navegador, então ChromePdfRenderer não está disponível diretamente em um projeto WASM. A abordagem correta é chamar um endpoint de API do lado do servidor que execute a geração do PDF e retorne os bytes como resposta.
No servidor, defina um endpoint de API mínimo que gere e retorne o 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)No cliente WASM, injete HttpClient e chame o ponto de extremidade da API. O modelo de projeto Blazor WASM hospedado pré-configura HttpClient para direcionar o endereço base do servidor:
@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)}";
}
}Esse padrão mantém todo o trabalho pesado de renderização no servidor, enquanto o cliente WASM lida apenas com a exibição. Para uso em produção, adicione autenticação ao endpoint da API e restrinja o conteúdo do PDF gerado aos dados do usuário autenticado.
A API do IronPDF vai muito além da simples visualização. As seções a seguir abordam quatro operações comumente necessárias em fluxos de trabalho de documentos Blazor : mesclar vários documentos, adicionar anotações, aplicar proteção por senha e exibir arquivos enviados pelo usuário.
A mesclagem combina múltiplas instâncias PdfDocument em um único arquivo, útil para montar seções de relatórios, adicionar apêndices ou concatenar arquivos selecionados pelo usuário. O guia de mesclagem e divisão de PDFs aborda operações de inserção e divisão em nível de página.
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")Para exibir o documento mesclado em um componente Blazor, passe merged.BinaryData para o padrão de URI de dados base64 das seções anteriores. O objeto mesclado PdfDocument também aceita mais operações (marcação d'água, configurações de segurança ou adição de páginas adicionais) antes de ser codificado para exibição.
As anotações anexam notas e comentários do revisor a locais específicos da página sem alterar o conteúdo original do documento. O IronPDF suporta anotações de texto, caixas de texto livre e outros tipos de marcação. Consulte o guia de anotações para obter a lista completa de propriedades de anotação.
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")Anotações são preservadas quando o PDF é aberto em qualquer visualizador padrão, incluindo a exibição <iframe> do navegador. Para aplicações Blazor, execute a lógica de anotações do lado do servidor e retorne pdf.BinaryData para o componente para exibição.
A proteção por senha restringe o acesso a documentos confidenciais, como relatórios financeiros ou registros de RH. O IronPDF suporta senhas de usuário (necessárias para abrir o documento) e senhas de proprietário (necessárias para alterar as permissões). O guia de segurança em PDF lista todas as opções de permissão disponíveis.
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")PDFs protegidos por senha exibem um prompt de senha no <iframe> do navegador. Essa abordagem funciona para documentos distribuídos por download; Para exibição direta sem aviso prévio, aplique a senha somente aos documentos retornados pelo método de download.
Exibir um PDF que um usuário carregou requer a leitura dos bytes do arquivo recebido e sua codificação como um URI de dados. O componente de upload abaixo usa o controle InputFile do Blazor para capturar o arquivo, em seguida, exibi-lo diretamente sem qualquer re-renderização:
@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)}";
}
}Para PDFs carregados que requerem processamento do lado do servidor antes da exibição, como marcação d'água, extração de páginas ou re-encriptação, carregue os bytes em um PdfDocument primeiro:
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)}"Isso mantém a mesma estrutura de componentes, ao mesmo tempo que permite o uso completo da API IronPDF no arquivo carregado.
Este guia abordou o fluxo de trabalho completo para um visualizador de PDF em Blazor com IronPDF: instalação no .NET 10, renderização de URL e HTML, personalização da saída com cabeçalhos e rodapés, interoperabilidade com JavaScript para downloads via navegador, a diferença arquitetônica entre Blazor Server e Blazor WebAssembly e quatro operações de documento: mesclagem, anotações, proteção por senha e uploads de usuários.
Para ampliar essa base, explore estes recursos:
Obtenha sua licença de avaliação gratuita para remover marcas d'água e testar o IronPDF em seu aplicativo Blazor . O IronPDF é compatível com .NET 10 , ASP.NET Core, Blazor Server e projetos Blazor WebAssembly hospedados sem configuração adicional. Para obter orientações adicionais sobre integração, consulte a documentação oficial do Blazor da Microsoft .
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronPDF faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
Quando você precisa que seu PDF tenha a aparência de HTML, rapidamente.
