Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronPDF
  2. Blog do IronPDF
  3. Usando o ironpdf
  4. Exibição de PDF a partir de banco de dados ASP.NET
USANDO O IRONPDF

Exibição de PDF a partir de banco de dados em ASP.NET (Guia do desenvolvedor)

Curtis Chau
Curtis Chau
Atualizado:

Para exibir PDFs de um banco de dados em ASP.NET, recupere os dados binários armazenados e renderize-os usando a classe PdfDocument do IronPDF , que manipula arrays de bytes de forma eficiente e fornece uma saída compatível com navegadores, além de opções de personalização.

O que é a exibição de banco de dados PDF em ASP.NET?

O gerenciamento de documentos PDF em aplicações ASP.NET geralmente envolve o armazenamento de arquivos PDF diretamente em um banco de dados, em vez do sistema de arquivos. Este método oferece maior segurança, backup centralizado e implantação simplificada. No entanto, recuperar e exibir documentos PDF de um banco de dados pode ser um desafio sem as ferramentas adequadas.

Armazenar arquivos PDF como dados binários em uma tabela de banco de dados permite um melhor controle sobre o acesso e o versionamento dos documentos. Quando você precisa exibir documentos PDF para os usuários, é necessário recuperar o array de bytes do banco de dados de forma eficiente e renderizá-lo no navegador. O IronPDF simplifica todo esse processo com uma API eficaz para lidar com documentos PDF em aplicações ASP.NET .

Este tutorial demonstra a funcionalidade de exibição de PDF a partir de um banco de dados em ASP.NET , utilizando os recursos comprovados do IronPDF. Você aprenderá a criar uma solução completa para carregar, armazenar e exibir arquivos PDF com desempenho e segurança ideais. A biblioteca oferece suporte a diversas opções de renderização e recursos avançados de manipulação de PDF, o que facilita a criação de sistemas de gerenciamento de documentos de nível profissional.

Como instalar a biblioteca PDF em seu projeto ASP.NET ?

Antes de implementar a funcionalidade de exibição de PDF, certifique-se de que o IronPDF esteja instalado em seu projeto ASP.NET . Abra o Console do Gerenciador de Pacotes no Visual Studio e execute um dos seguintes comandos, dependendo da sua preferência de ferramenta:

Install-Package IronPdf
dotnet add package IronPdf
Install-Package IronPdf
dotnet add package IronPdf
SHELL

Você também pode instalar o IronPDF através da interface do Gerenciador de Pacotes NuGet , pesquisando por IronPdf na aba Procurar do seu projeto. Após a instalação, defina sua chave de licença na inicialização do aplicativo:

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"
$vbLabelText   $csharpLabel

Uma licença de avaliação gratuita oferece acesso completo a todos os recursos durante o período de avaliação. Para implantações em produção, revise os níveis de licenciamento disponíveis para encontrar uma opção que se adeque à escala do seu projeto.

Qual a estrutura de banco de dados necessária?

A estrutura da sua tabela de banco de dados precisa de uma coluna varbinary(max) para armazenar arquivos PDF como dados binários. A tabela deve incluir campos de metadados como nome do arquivo, data de upload e tamanho do arquivo para melhor gerenciamento de documentos. O seguinte código SQL cria uma tabela adequada para este cenário:

using IronPdf;
using System.Data.SqlClient;
using System.IO;
using System.Configuration;
using IronPdf;
using System.Data.SqlClient;
using System.IO;
using System.Configuration;
Imports IronPdf
Imports System.Data.SqlClient
Imports System.IO
Imports System.Configuration
$vbLabelText   $csharpLabel

Configure sua string de conexão no arquivo web.config para estabelecer a conectividade com o banco de dados. A implementação do visualizador de PDF usará essa conexão para recuperar os arquivos carregados no banco de dados e exibir o conteúdo do PDF sem problemas.

Quais namespaces a solução requer?

A solução utiliza namespaces ADO .NET padrão juntamente com o namespace IronPDF . Você não precisa de nenhum ORM de terceiros -- a abordagem direta com .NET mantém as dependências mínimas e oferece controle total sobre a execução da consulta. Certifique-se de que a string de conexão aponte para uma instância do SQL Server onde sua tabela de armazenamento de PDF está localizada.

Como criar uma tabela de banco de dados para PDFs?

Comece criando uma tabela de banco de dados projetada especificamente para armazenar documentos PDF. A estrutura da tabela deve acomodar tanto os dados binários quanto os metadados essenciais para o gerenciamento de documentos PDF:

CREATE TABLE PdfDocuments (
    Id INT PRIMARY KEY IDENTITY(1,1),
    FileName NVARCHAR(255) NOT NULL,
    FileData VARBINARY(MAX) NOT NULL,
    ContentType NVARCHAR(100) DEFAULT 'application/pdf',
    FileSize INT,
    UploadDate DATETIME DEFAULT GETDATE(),
    CreatedBy NVARCHAR(100),
    LastModified DATETIME,
    DocumentVersion INT DEFAULT 1
);

Esta tabela armazena cada arquivo PDF como uma matriz de bytes na coluna FileData. O tipo de dados varbinary(max) pode armazenar arquivos de até 2 GB, o suficiente para a maioria dos documentos PDF. O campo FileName preserva o nome original do arquivo para fins de exibição e download.

Como posso melhorar o desempenho do banco de dados para recuperação de PDFs?

Considere adicionar índices nas colunas consultadas com frequência para obter melhor desempenho na recuperação de documentos PDF. O seguinte código SQL cria índices nas colunas com maior probabilidade de aparecerem nas cláusulas WHERE e ORDER BY:

CREATE INDEX IX_PdfDocuments_UploadDate
ON PdfDocuments(UploadDate DESC);

CREATE INDEX IX_PdfDocuments_FileName
ON PdfDocuments(FileName);

Essa estrutura garante o armazenamento e a recuperação eficientes dos arquivos enviados, mantendo a flexibilidade para adicionar campos de metadados adicionais conforme necessário. Para arquivos PDF muito grandes, considere se o armazenamento em banco de dados é a opção mais adequada para sua arquitetura ou se uma abordagem híbrida — armazenando os arquivos em disco ou em armazenamento de objetos e mantendo apenas os metadados no banco de dados — teria um desempenho melhor em grande escala.

Comparação de estratégias de armazenamento de PDFs
Estratégia Ideal para Vantagens Considerações
Banco de dados (VARBINARY) Arquivos de pequeno a médio porte, alta segurança Consistência transacional, backup centralizado Pode aumentar o tamanho do banco de dados rapidamente.
Sistema de arquivos Arquivos grandes, alta capacidade de processamento Entrada/saída de arquivos rápida, baixa sobrecarga do banco de dados Requer estratégia de backup separada
Armazenamento de objetos (Azure Blob/S3) Implantações em nuvem, escala ilimitada Custo-benefício excelente, alta disponibilidade Dependência adicional do SDK

Como faço para carregar arquivos PDF em um banco de dados?

Implemente a funcionalidade de upload usando o controle FileUpload do ASP.NET. Adicione este código HTML à sua página .aspx dentro de um elemento de formulário com a devida validação:

<div class="pdf-upload-container">
    <asp:FileUpload ID="FileUpload1" runat="server" accept=".pdf" />
    <asp:Button ID="btnUpload" Text="Upload PDF"
                OnClick="btnUpload_Click" runat="server" CssClass="btn-primary" />
    <asp:Label ID="lblMessage" runat="server" CssClass="status-message" />
    <div class="file-info">
        <asp:Label ID="lblFileInfo" runat="server" />
    </div>
</div>
<div class="pdf-upload-container">
    <asp:FileUpload ID="FileUpload1" runat="server" accept=".pdf" />
    <asp:Button ID="btnUpload" Text="Upload PDF"
                OnClick="btnUpload_Click" runat="server" CssClass="btn-primary" />
    <asp:Label ID="lblMessage" runat="server" CssClass="status-message" />
    <div class="file-info">
        <asp:Label ID="lblFileInfo" runat="server" />
    </div>
</div>
HTML

Exemplo de saída da interface do usuário

Interface de aplicação web ASP.NET exibindo um formulário de upload de PDF com os botões "Escolher arquivo" e "Enviar PDF", além de uma seção vazia de Lista de Documentos PDF abaixo para gerenciamento de documentos.

Como você lida com eventos de upload de arquivos?

O botão de upload aciona o manipulador de eventos do lado do servidor. Segue a implementação completa da função de upload que converte os arquivos enviados em um array de bytes e os armazena com o devido tratamento de erros:

protected void btnUpload_Click(object sender, EventArgs e)
{
    if (FileUpload1.HasFile && FileUpload1.PostedFile.ContentType == "application/pdf")
    {
        try
        {
            string fileName = FileUpload1.FileName;
            byte[] fileBytes = FileUpload1.FileBytes;
            int maxFileSize = 10 * 1024 * 1024; // 10MB limit

            if (fileBytes.Length > maxFileSize)
            {
                lblMessage.Text = "File size exceeds 10MB limit.";
                return;
            }

            // Validate PDF using IronPDF
            using (var stream = new MemoryStream(fileBytes))
            {
                var testPdf = new IronPdf.PdfDocument(stream);
                if (testPdf.PageCount == 0)
                {
                    lblMessage.Text = "Invalid PDF file.";
                    return;
                }
            }

            string constr = ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;
            using (SqlConnection conn = new SqlConnection(constr))
            {
                string query = "INSERT INTO PdfDocuments (FileName, FileData, FileSize, CreatedBy) " +
                               "VALUES (@FileName, @FileData, @FileSize, @CreatedBy)";
                using (SqlCommand cmd = new SqlCommand(query, conn))
                {
                    cmd.Parameters.AddWithValue("@FileName", fileName);
                    cmd.Parameters.AddWithValue("@FileData", fileBytes);
                    cmd.Parameters.AddWithValue("@FileSize", fileBytes.Length);
                    cmd.Parameters.AddWithValue("@CreatedBy", User.Identity.Name ?? "Anonymous");

                    conn.Open();
                    cmd.ExecuteNonQuery();
                }
            }
            lblMessage.Text = "PDF document uploaded successfully!";
            lblFileInfo.Text = $"File: {fileName} ({fileBytes.Length / 1024}KB)";
            LoadPdfList();
        }
        catch (Exception ex)
        {
            lblMessage.Text = "Error uploading file: " + ex.Message;
        }
    }
    else
    {
        lblMessage.Text = "Please select a valid PDF file.";
    }
}
protected void btnUpload_Click(object sender, EventArgs e)
{
    if (FileUpload1.HasFile && FileUpload1.PostedFile.ContentType == "application/pdf")
    {
        try
        {
            string fileName = FileUpload1.FileName;
            byte[] fileBytes = FileUpload1.FileBytes;
            int maxFileSize = 10 * 1024 * 1024; // 10MB limit

            if (fileBytes.Length > maxFileSize)
            {
                lblMessage.Text = "File size exceeds 10MB limit.";
                return;
            }

            // Validate PDF using IronPDF
            using (var stream = new MemoryStream(fileBytes))
            {
                var testPdf = new IronPdf.PdfDocument(stream);
                if (testPdf.PageCount == 0)
                {
                    lblMessage.Text = "Invalid PDF file.";
                    return;
                }
            }

            string constr = ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;
            using (SqlConnection conn = new SqlConnection(constr))
            {
                string query = "INSERT INTO PdfDocuments (FileName, FileData, FileSize, CreatedBy) " +
                               "VALUES (@FileName, @FileData, @FileSize, @CreatedBy)";
                using (SqlCommand cmd = new SqlCommand(query, conn))
                {
                    cmd.Parameters.AddWithValue("@FileName", fileName);
                    cmd.Parameters.AddWithValue("@FileData", fileBytes);
                    cmd.Parameters.AddWithValue("@FileSize", fileBytes.Length);
                    cmd.Parameters.AddWithValue("@CreatedBy", User.Identity.Name ?? "Anonymous");

                    conn.Open();
                    cmd.ExecuteNonQuery();
                }
            }
            lblMessage.Text = "PDF document uploaded successfully!";
            lblFileInfo.Text = $"File: {fileName} ({fileBytes.Length / 1024}KB)";
            LoadPdfList();
        }
        catch (Exception ex)
        {
            lblMessage.Text = "Error uploading file: " + ex.Message;
        }
    }
    else
    {
        lblMessage.Text = "Please select a valid PDF file.";
    }
}
Imports System
Imports System.IO
Imports System.Data.SqlClient
Imports System.Configuration
Imports IronPdf

Protected Sub btnUpload_Click(sender As Object, e As EventArgs)
    If FileUpload1.HasFile AndAlso FileUpload1.PostedFile.ContentType = "application/pdf" Then
        Try
            Dim fileName As String = FileUpload1.FileName
            Dim fileBytes As Byte() = FileUpload1.FileBytes
            Dim maxFileSize As Integer = 10 * 1024 * 1024 ' 10MB limit

            If fileBytes.Length > maxFileSize Then
                lblMessage.Text = "File size exceeds 10MB limit."
                Return
            End If

            ' Validate PDF using IronPDF
            Using stream As New MemoryStream(fileBytes)
                Dim testPdf As New IronPdf.PdfDocument(stream)
                If testPdf.PageCount = 0 Then
                    lblMessage.Text = "Invalid PDF file."
                    Return
                End If
            End Using

            Dim constr As String = ConfigurationManager.ConnectionStrings("DefaultConnection").ConnectionString
            Using conn As New SqlConnection(constr)
                Dim query As String = "INSERT INTO PdfDocuments (FileName, FileData, FileSize, CreatedBy) " &
                                      "VALUES (@FileName, @FileData, @FileSize, @CreatedBy)"
                Using cmd As New SqlCommand(query, conn)
                    cmd.Parameters.AddWithValue("@FileName", fileName)
                    cmd.Parameters.AddWithValue("@FileData", fileBytes)
                    cmd.Parameters.AddWithValue("@FileSize", fileBytes.Length)
                    cmd.Parameters.AddWithValue("@CreatedBy", If(User.Identity.Name, "Anonymous"))

                    conn.Open()
                    cmd.ExecuteNonQuery()
                End Using
            End Using
            lblMessage.Text = "PDF document uploaded successfully!"
            lblFileInfo.Text = $"File: {fileName} ({fileBytes.Length \ 1024}KB)"
            LoadPdfList()
        Catch ex As Exception
            lblMessage.Text = "Error uploading file: " & ex.Message
        End Try
    Else
        lblMessage.Text = "Please select a valid PDF file."
    End If
End Sub
$vbLabelText   $csharpLabel

Este código valida o tipo de arquivo antes do upload, garantindo que apenas arquivos PDF válidos sejam armazenados no banco de dados. A conversão do array de bytes ocorre automaticamente através da propriedade FileBytes. A validação adicional inclui a verificação da integridade do PDF e dos limites de tamanho do arquivo. Usar o IronPDF para abrir a matriz de bytes antes de salvar confirma que o arquivo é um documento PDF genuíno e analisável, e não apenas um arquivo com a extensão renomeada.

Interface do usuário com arquivos carregados

Interface de aplicação web ASP.NET que demonstra a funcionalidade de upload de PDFs com um formulário para upload de arquivos e uma tabela listando os documentos PDF enviados, com botões de visualização e download para gerenciamento completo de documentos.

Como recuperar e exibir PDFs do banco de dados?

O IronPDF se destaca na renderização de documentos PDF recuperados de um banco de dados. A biblioteca oferece diversas opções para exibir conteúdo PDF em navegadores com recursos avançados de renderização. Primeiro, recupere os dados binários da tabela do seu banco de dados e, em seguida, passe-os para o IronPDF para processamento antes de transmiti-los de volta para o cliente:

private void LoadPdfList()
{
    string constr = ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;
    using (SqlConnection conn = new SqlConnection(constr))
    {
        string query = @"SELECT Id, FileName, FileSize, UploadDate, CreatedBy
                        FROM PdfDocuments
                        ORDER BY UploadDate DESC";
        using (SqlCommand cmd = new SqlCommand(query, conn))
        {
            conn.Open();
            SqlDataAdapter adapter = new SqlDataAdapter(cmd);
            DataTable dt = new DataTable();
            adapter.Fill(dt);

            foreach (DataRow row in dt.Rows)
            {
                int fileSize = Convert.ToInt32(row["FileSize"]);
                row["FileSize"] = FormatFileSize(fileSize);
            }

            GridView1.DataSource = dt;
            GridView1.DataBind();
        }
    }
}

private string FormatFileSize(int bytes)
{
    if (bytes < 1024) return bytes + " B";
    if (bytes < 1048576) return (bytes / 1024) + " KB";
    return (bytes / 1048576) + " MB";
}

private PdfData GetPdfFromDatabase(int id)
{
    byte[] pdfBytes = null;
    string filename = "";
    string constr = ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;
    using (SqlConnection conn = new SqlConnection(constr))
    {
        string query = "SELECT FileData, FileName FROM PdfDocuments WHERE Id = @Id";
        using (SqlCommand cmd = new SqlCommand(query, conn))
        {
            cmd.Parameters.AddWithValue("@Id", id);
            conn.Open();
            using (SqlDataReader reader = cmd.ExecuteReader())
            {
                if (reader.Read())
                {
                    pdfBytes = (byte[])reader["FileData"];
                    filename = reader["FileName"].ToString();
                }
            }
        }
    }
    if (pdfBytes != null)
    {
        return new PdfData { Bytes = pdfBytes, FileName = filename };
    }
    return null;
}

protected void GridView1_RowCommand(object sender, GridViewCommandEventArgs e)
{
    if (e.CommandName == "ViewPdf")
    {
        int documentId = Convert.ToInt32(e.CommandArgument);
        ViewPdfDocument(documentId);
    }
    else if (e.CommandName == "DownloadPdf")
    {
        int documentId = Convert.ToInt32(e.CommandArgument);
        DownloadPdfDocument(documentId);
    }
}

private void ViewPdfDocument(int id)
{
    var pdfData = GetPdfFromDatabase(id);
    if (pdfData != null)
    {
        IronPdf.PdfDocument pdf;
        using (var stream = new System.IO.MemoryStream(pdfData.Bytes))
        {
            pdf = new IronPdf.PdfDocument(stream);
        }

        // Apply security settings
        pdf.SecuritySettings.AllowUserPrinting = true;
        pdf.SecuritySettings.AllowUserCopyPasteContent = false;

        Response.Clear();
        Response.ContentType = "application/pdf";
        Response.AddHeader("content-disposition", $"inline; filename={pdfData.FileName}");
        Response.AddHeader("content-length", pdf.BinaryData.Length.ToString());
        Response.BinaryWrite(pdf.BinaryData);
        Response.End();
    }
}
private void LoadPdfList()
{
    string constr = ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;
    using (SqlConnection conn = new SqlConnection(constr))
    {
        string query = @"SELECT Id, FileName, FileSize, UploadDate, CreatedBy
                        FROM PdfDocuments
                        ORDER BY UploadDate DESC";
        using (SqlCommand cmd = new SqlCommand(query, conn))
        {
            conn.Open();
            SqlDataAdapter adapter = new SqlDataAdapter(cmd);
            DataTable dt = new DataTable();
            adapter.Fill(dt);

            foreach (DataRow row in dt.Rows)
            {
                int fileSize = Convert.ToInt32(row["FileSize"]);
                row["FileSize"] = FormatFileSize(fileSize);
            }

            GridView1.DataSource = dt;
            GridView1.DataBind();
        }
    }
}

private string FormatFileSize(int bytes)
{
    if (bytes < 1024) return bytes + " B";
    if (bytes < 1048576) return (bytes / 1024) + " KB";
    return (bytes / 1048576) + " MB";
}

private PdfData GetPdfFromDatabase(int id)
{
    byte[] pdfBytes = null;
    string filename = "";
    string constr = ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;
    using (SqlConnection conn = new SqlConnection(constr))
    {
        string query = "SELECT FileData, FileName FROM PdfDocuments WHERE Id = @Id";
        using (SqlCommand cmd = new SqlCommand(query, conn))
        {
            cmd.Parameters.AddWithValue("@Id", id);
            conn.Open();
            using (SqlDataReader reader = cmd.ExecuteReader())
            {
                if (reader.Read())
                {
                    pdfBytes = (byte[])reader["FileData"];
                    filename = reader["FileName"].ToString();
                }
            }
        }
    }
    if (pdfBytes != null)
    {
        return new PdfData { Bytes = pdfBytes, FileName = filename };
    }
    return null;
}

protected void GridView1_RowCommand(object sender, GridViewCommandEventArgs e)
{
    if (e.CommandName == "ViewPdf")
    {
        int documentId = Convert.ToInt32(e.CommandArgument);
        ViewPdfDocument(documentId);
    }
    else if (e.CommandName == "DownloadPdf")
    {
        int documentId = Convert.ToInt32(e.CommandArgument);
        DownloadPdfDocument(documentId);
    }
}

private void ViewPdfDocument(int id)
{
    var pdfData = GetPdfFromDatabase(id);
    if (pdfData != null)
    {
        IronPdf.PdfDocument pdf;
        using (var stream = new System.IO.MemoryStream(pdfData.Bytes))
        {
            pdf = new IronPdf.PdfDocument(stream);
        }

        // Apply security settings
        pdf.SecuritySettings.AllowUserPrinting = true;
        pdf.SecuritySettings.AllowUserCopyPasteContent = false;

        Response.Clear();
        Response.ContentType = "application/pdf";
        Response.AddHeader("content-disposition", $"inline; filename={pdfData.FileName}");
        Response.AddHeader("content-length", pdf.BinaryData.Length.ToString());
        Response.BinaryWrite(pdf.BinaryData);
        Response.End();
    }
}
Imports System.Configuration
Imports System.Data
Imports System.Data.SqlClient
Imports System.IO
Imports IronPdf

Private Sub LoadPdfList()
    Dim constr As String = ConfigurationManager.ConnectionStrings("DefaultConnection").ConnectionString
    Using conn As New SqlConnection(constr)
        Dim query As String = "SELECT Id, FileName, FileSize, UploadDate, CreatedBy FROM PdfDocuments ORDER BY UploadDate DESC"
        Using cmd As New SqlCommand(query, conn)
            conn.Open()
            Dim adapter As New SqlDataAdapter(cmd)
            Dim dt As New DataTable()
            adapter.Fill(dt)

            For Each row As DataRow In dt.Rows
                Dim fileSize As Integer = Convert.ToInt32(row("FileSize"))
                row("FileSize") = FormatFileSize(fileSize)
            Next

            GridView1.DataSource = dt
            GridView1.DataBind()
        End Using
    End Using
End Sub

Private Function FormatFileSize(bytes As Integer) As String
    If bytes < 1024 Then Return bytes & " B"
    If bytes < 1048576 Then Return (bytes \ 1024) & " KB"
    Return (bytes \ 1048576) & " MB"
End Function

Private Function GetPdfFromDatabase(id As Integer) As PdfData
    Dim pdfBytes As Byte() = Nothing
    Dim filename As String = ""
    Dim constr As String = ConfigurationManager.ConnectionStrings("DefaultConnection").ConnectionString
    Using conn As New SqlConnection(constr)
        Dim query As String = "SELECT FileData, FileName FROM PdfDocuments WHERE Id = @Id"
        Using cmd As New SqlCommand(query, conn)
            cmd.Parameters.AddWithValue("@Id", id)
            conn.Open()
            Using reader As SqlDataReader = cmd.ExecuteReader()
                If reader.Read() Then
                    pdfBytes = CType(reader("FileData"), Byte())
                    filename = reader("FileName").ToString()
                End If
            End Using
        End Using
    End Using
    If pdfBytes IsNot Nothing Then
        Return New PdfData With {.Bytes = pdfBytes, .FileName = filename}
    End If
    Return Nothing
End Function

Protected Sub GridView1_RowCommand(sender As Object, e As GridViewCommandEventArgs)
    If e.CommandName = "ViewPdf" Then
        Dim documentId As Integer = Convert.ToInt32(e.CommandArgument)
        ViewPdfDocument(documentId)
    ElseIf e.CommandName = "DownloadPdf" Then
        Dim documentId As Integer = Convert.ToInt32(e.CommandArgument)
        DownloadPdfDocument(documentId)
    End If
End Sub

Private Sub ViewPdfDocument(id As Integer)
    Dim pdfData = GetPdfFromDatabase(id)
    If pdfData IsNot Nothing Then
        Dim pdf As PdfDocument
        Using stream As New MemoryStream(pdfData.Bytes)
            pdf = New PdfDocument(stream)
        End Using

        ' Apply security settings
        pdf.SecuritySettings.AllowUserPrinting = True
        pdf.SecuritySettings.AllowUserCopyPasteContent = False

        Response.Clear()
        Response.ContentType = "application/pdf"
        Response.AddHeader("content-disposition", $"inline; filename={pdfData.FileName}")
        Response.AddHeader("content-length", pdf.BinaryData.Length.ToString())
        Response.BinaryWrite(pdf.BinaryData)
        Response.End()
    End If
End Sub
$vbLabelText   $csharpLabel

O método ViewPdfDocument transmite o documento de volta para o cliente com as configurações de segurança apropriadas aplicadas. A disposição de conteúdo inline instrui o navegador a exibir o PDF em vez de solicitar um download. Você pode ajustar as configurações de segurança, como permissões de impressão e restrições de copiar e colar, para que correspondam aos requisitos da sua política de documentos.

Como gerenciar os parâmetros de renderização de PDF?

Os parâmetros do comando SQL são cruciais para recuperar com segurança um PDF específico por meio de sua chave primária. Consultas parametrizadas previnem ataques de injeção de SQL e garantem a vinculação correta dos dados. Após recuperar os dados binários, o IronPDF os carrega de um MemoryStream, dando a você acesso total ao objeto do documento para manipulação adicional antes de enviá-lo ao navegador.

Visualizando um arquivo PDF carregado

Interface do visualizador de PDF exibindo um documento intitulado "O que é um PDF?" com texto explicativo sobre o formato de documento portátil, visualizado com zoom de 100%, controles de navegação e indicadores de suporte a várias páginas.

Que recursos avançados você pode adicionar aos PDFs antes da exibição?

Os recursos de manipulação de PDF do IronPDF vão além da simples visualização. Você pode manipular o documento PDF antes da renderização com marcas d'água , cabeçalhos e rodapés , e assinaturas digitais :

// Add a confidentiality watermark before displaying
pdf.ApplyWatermark("<h2 style='color:red; font-family:Arial'>CONFIDENTIAL</h2>",
                   rotation: 30,
                   opacity: 50);

// Add page numbers in the footer
pdf.AddTextHeaders("{page} of {total-pages}",
                  IronPdf.Editing.TextHeaderFooter.DisplayLocation.BottomCenter);

// Add document metadata
pdf.MetaData.Author = "Your Application";
pdf.MetaData.ModifiedDate = DateTime.Now;
// Add a confidentiality watermark before displaying
pdf.ApplyWatermark("<h2 style='color:red; font-family:Arial'>CONFIDENTIAL</h2>",
                   rotation: 30,
                   opacity: 50);

// Add page numbers in the footer
pdf.AddTextHeaders("{page} of {total-pages}",
                  IronPdf.Editing.TextHeaderFooter.DisplayLocation.BottomCenter);

// Add document metadata
pdf.MetaData.Author = "Your Application";
pdf.MetaData.ModifiedDate = DateTime.Now;
' Add a confidentiality watermark before displaying
pdf.ApplyWatermark("<h2 style='color:red; font-family:Arial'>CONFIDENTIAL</h2>", 
                   rotation:=30, 
                   opacity:=50)

' Add page numbers in the footer
pdf.AddTextHeaders("{page} of {total-pages}", 
                   IronPdf.Editing.TextHeaderFooter.DisplayLocation.BottomCenter)

' Add document metadata
pdf.MetaData.Author = "Your Application"
pdf.MetaData.ModifiedDate = DateTime.Now
$vbLabelText   $csharpLabel

Visualizando PDF com marca d'água

! Visualizador de PDF exibindo um documento sobre "O que é um PDF?" com conteúdo de texto detalhado e uma marca d'água diagonal "CONFIDENCIAL" demonstrando os recursos de marca d'água do IronPDF para segurança de documentos.

A marca d'água é particularmente útil ao exibir documentos que os usuários devem visualizar, mas não reproduzir na íntegra. Você também pode extrair texto do PDF antes da exibição para criar índices de pesquisa ou converter páginas específicas em imagens para geração de miniaturas.

Por que essa abordagem funciona bem para aplicações de produção?

A combinação do ADO .NET com o IronPDF oferece um padrão simples que pode ser dimensionado desde pequenas ferramentas internas até sistemas de gerenciamento de documentos corporativos. A abordagem é inteiramente do lado do servidor — nenhuma biblioteca de renderização de PDF do lado do cliente é necessária, e o visualizador de PDF integrado do navegador lida com a exibição assim que o tipo MIME correto é retornado.

Os principais pontos fortes desse padrão são:

  • Validação no momento do upload : O IronPDF abre o arquivo antes que ele chegue ao banco de dados, rejeitando imediatamente arquivos corrompidos ou que não sejam PDF.
  • Controle de segurança em tempo de visualização : Permissões como impressão e copiar e colar são aplicadas pelo IronPDF antes que os bytes cheguem ao navegador.
  • Código mínimo no lado do cliente : O navegador lida com a renderização nativamente, reduzindo a complexidade do JavaScript .
  • Pré-processamento flexível : você pode aplicar a conversão de string HTML para PDF , mesclar documentos com operações de mesclagem e divisão ou adicionar marcas d'água personalizadas antes do streaming — tudo dentro do mesmo método do lado do servidor.

Como vocês lidam com a integração do navegador e as opções de download?

Para uma melhor integração com a web, utilize JavaScript para abrir documentos em uma nova aba, em vez de substituir a página atual. Isso proporciona aos usuários uma melhor experiência ao navegar em uma lista de documentos:

function openPdfInNewTab(documentId) {
    window.open('/PdfHandler.ashx?id=' + documentId, '_blank');
}

function openPdfInModal(documentId) {
    var modal = document.getElementById('pdfModal');
    var iframe = document.getElementById('pdfFrame');
    iframe.src = '/PdfHandler.ashx?id=' + documentId;
    modal.style.display = 'block';
}
function openPdfInNewTab(documentId) {
    window.open('/PdfHandler.ashx?id=' + documentId, '_blank');
}

function openPdfInModal(documentId) {
    var modal = document.getElementById('pdfModal');
    var iframe = document.getElementById('pdfFrame');
    iframe.src = '/PdfHandler.ashx?id=' + documentId;
    modal.style.display = 'block';
}
JAVASCRIPT

O caminho de download segue a mesma lógica de recuperação do banco de dados, mas usa attachment em vez de inline como disposição de conteúdo. Isso força o navegador a salvar o arquivo em vez de exibi-lo. Ambos os caminhos compartilham o mesmo auxiliar GetPdfFromDatabase, mantendo o código de acesso a dados DRY (Don't Repeat Yourself).

Para fluxos de trabalho com documentos baseados em formulários, explore os recursos de preenchimento de formulários PDF do IronPDF — você pode preencher previamente os campos do formulário antes de exibir ou baixar um documento, o que é útil para a geração de faturas e cenários de gerenciamento de contratos.

Quais são as considerações de segurança para o compartilhamento de PDFs?

Sempre verifique se o usuário solicitante tem permissão para acessar o ID do documento solicitado antes de fornecer os bytes. Um ID inteiro simples em uma string de consulta é fácil de enumerar -- sem verificações de autorização, qualquer usuário autenticado poderia visualizar qualquer documento adivinhando os IDs.

As melhores práticas incluem:

  • Armazene uma coluna CreatedBy ou OwnerId e verifique-a em relação à identidade do usuário atual antes de consultar FileData.
  • Use GUIDs em vez de números inteiros sequenciais como identificadores de documentos para tornar a enumeração impraticável.
  • Aplique proteção por senha em PDF no momento do upload para documentos altamente confidenciais, de forma que o próprio arquivo fique protegido mesmo se acessado fora do seu aplicativo.
  • Registre todos os eventos de visualização e download para fins de auditoria.

Para referências externas sobre padrões de segurança do ASP.NET , o OWASP ASP.NET Security Cheat Sheet e as diretrizes de codificação segura da Microsoft para ASP.NET fornecem orientações confiáveis. A entrada da galeria NuGet para IronPDF também documenta o histórico de versões e as dependências.

Como começar a usar a visualização de bancos de dados em PDF?

Para implementar esta solução em seu próprio projeto:

  1. Instale o IronPDF via NuGet (Install-Package IronPdf ou dotnet add package IronPdf).
  2. Crie a tabela PdfDocuments usando o esquema SQL acima.
  3. Adicione o manipulador de upload ao código subjacente do seu arquivo .aspx.
  4. Adicione os manipuladores de visualização e download que transmitem bytes através do IronPDF.
  5. Conecte o GridView com comandos de linha apontando para os manipuladores.

Você pode explorar o conjunto completo de recursos do IronPDF para descobrir funcionalidades adicionais, como conversão de HTML para PDF e mesclagem e divisão de PDFs , que se integram naturalmente aos fluxos de trabalho de gerenciamento de documentos. Inicie um teste gratuito para experimentar a API completa antes de adquirir uma licença .

Perguntas frequentes

Qual é o principal objetivo de exibir PDFs de um banco de dados em ASP.NET?

O objetivo principal é fornecer aos desenvolvedores métodos eficazes para exibir PDFs diretamente de um banco de dados em um aplicativo web ASP.NET, aprimorando a funcionalidade e a experiência do usuário do projeto.

Como o IronPDF pode ajudar a exibir PDFs de um banco de dados em ASP.NET?

O IronPDF pode simplificar o processo, fornecendo bibliotecas robustas que permitem aos desenvolvedores renderizar PDFs perfeitamente a partir do armazenamento em banco de dados, garantindo uma integração perfeita em aplicativos ASP.NET.

Quais são as vantagens de usar o IronPDF para exibir PDFs em ASP.NET?

O uso do IronPDF oferece vantagens como fácil integração, renderização de alta qualidade e suporte a diversos recursos de PDF, o que pode melhorar significativamente a usabilidade e o desempenho do seu aplicativo ASP.NET.

O IronPDF consegue lidar com arquivos PDF grandes provenientes de um banco de dados de forma eficiente?

Sim, o IronPDF foi projetado para lidar com arquivos PDF grandes de forma eficiente, garantindo tempos de carregamento e renderização rápidos, o que é crucial para manter o desempenho do aplicativo.

É possível personalizar a exibição de PDFs usando o IronPDF em ASP.NET?

Sem dúvida, o IronPDF oferece diversas opções de personalização, permitindo que os desenvolvedores adaptem a exibição do PDF de acordo com suas necessidades específicas em um ambiente ASP.NET.

Quais formatos de arquivo o IronPDF pode converter para PDF em aplicações ASP.NET?

O IronPDF suporta a conversão de vários formatos de arquivo, como HTML, imagens e outros, em PDFs, o que pode ser particularmente útil para a geração de conteúdo dinâmico em aplicações ASP.NET.

O IronPDF oferece suporte ao tratamento seguro de PDFs em aplicações ASP.NET?

Sim, o IronPDF oferece suporte ao manuseio seguro de PDFs, incluindo criptografia e proteção por senha, o que ajuda a proteger informações confidenciais em aplicativos ASP.NET.

O IronPDF pode ser integrado a outros produtos da Iron Software para funcionalidades aprimoradas?

Sim, o IronPDF pode ser integrado a outros produtos da Iron Software, como o IronOCR e o IronBarcode, para fornecer soluções abrangentes para gerenciamento e processamento de documentos em aplicativos ASP.NET.

Curtis Chau
Curtis Chau
  Converse agora mesmo com a equipe de engenharia.
Redator Técnico

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

Leia mais

Artigos relacionados

Teste grátis por 30 dias → Produto completo. Sem limites. Sem cartão. Teste gratuito

Equipe de suporte de ferro

Estamos online 24 horas por dia, 5 dias por semana.
Bater papo
E-mail
Liga para mim