USANDO O IRONPDF

Como mesclar PDFs em VB.NET com o IronPDF

Curtis Chau
Curtis Chau
Updated: 19 de julho de 2026

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.

Como começar a usar o IronPDF em um projeto Blazor ?

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:

PM > Install-Package IronPdf

Por outro lado, procure por "IronPDF" na interface do Gerenciador de Pacotes NuGet e selecione a versão mais recente.

NuGetInstalar com NuGet

PM > Install-Package IronPdf

Install IronPDF by running the command above in the NuGet Package Manager Console, or search for the package in the NuGet Package Manager.

Apó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";

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.

Como posso exibir um arquivo PDF a partir de uma URL no Blazor?

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.

Abordagem de Componentes de Razor

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}";
    }
}
Razor

Exemplo de C# de alto nível

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;

O 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.

Como Criar um Visualizador de PDF Blazor Usando IronPDF: Figura 1 - Saída do visualizador de PDF de URL para PDF

Como faço para personalizar a geração de PDFs?

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.

Abordagem de Componentes de Razor

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)}";
    }
}
Razor

Exemplo de C# de alto nível

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");

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.

Como Criar um Visualizador de PDF Blazor Usando IronPDF: Figura 2 - PDF Personalizado aberto no visualizador de PDF

Qual a melhor maneira de habilitar o download de PDFs?

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 .

Abordagem de Componentes de Razor

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);
    }
}
Razor

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);
};
JavaScript

Exemplo de C# de alto nível

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");
});

Como posso gerar PDFs a partir de componentes Razor ?

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 .

Abordagem de Componentes de Razor

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)}";
    }
}
Razor

Exemplo de C# de alto nível

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.

Como Criar um Visualizador de PDF Blazor Usando IronPDF: Figura 3 - PDF de fatura no visualizador

Qual a diferença entre um visualizador de PDF para Blazor Server e um visualizador para Blazor WebAssembly?

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.

Configurando uma API de geração de PDF para Blazor WebAssembly

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");
});

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)}";
    }
}
Razor

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.

Que outras operações em PDF posso realizar?

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.

Como faço para mesclar vários documentos PDF?

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");

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.

Como adiciono anotações a um PDF?

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");

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.

Como faço para aplicar proteção por senha a um PDF?

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");

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.

Como faço para exibir PDFs enviados pelo usuário?

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)}";
    }
}
Razor

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)}";

Isso mantém a mesma estrutura de componentes, ao mesmo tempo que permite o uso completo da API IronPDF no arquivo carregado.

Quais são os meus próximos passos?

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.

Leia mais

Artigos relacionados