Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. Utilisation de ironpdf
  4. Afficher un PDF à partir de la base de données ASP .NET
UTILISATION DE IRONPDF

Afficher un PDF à partir de la base de données dans ASP.NET (Guide du développeur)

Curtis Chau
Curtis Chau
Mis à jour:

Pour afficher des PDF provenant d'une base de données dans ASP.NET, récupérez les données binaires stockées et affichez-les à l'aide de la classe PdfDocument d'IronPDF , qui gère efficacement les tableaux d'octets et fournit une sortie compatible avec les navigateurs avec des options de personnalisation.

Qu'est-ce que l'affichage de base de données PDF dans ASP.NET?

La gestion des documents PDF dans les applications ASP.NET implique souvent de stocker les fichiers PDF directement dans une base de données plutôt que dans le système de fichiers. Cette méthode offre une meilleure sécurité, une sauvegarde centralisée et un déploiement simplifié. Cependant, récupérer et afficher des documents PDF depuis une base de données peut être difficile sans les bons outils.

Stocker les fichiers PDF en tant que données binaires dans une table de base de données permet un meilleur contrôle sur l'accès aux documents et la gestion des versions. Lorsque vous devez afficher des documents PDF aux utilisateurs, vous devez extraire efficacement le tableau d'octets depuis la base de données et l'afficher dans le navigateur. IronPDF simplifie l'ensemble de ce processus grâce à une API efficace pour la gestion des documents PDF dans les applications ASP.NET .

Ce tutoriel présente la fonctionnalité d'affichage de PDF à partir d'une base de données en ASP.NET, en utilisant les fonctionnalités éprouvées d'IronPDF. Vous apprendrez à créer une solution complète pour le chargement, le stockage et l'affichage de fichiers PDF avec des performances et une sécurité optimales. La bibliothèque prend en charge diverses options de rendu et des fonctionnalités avancées de manipulation de fichiers PDF, ce qui simplifie la création de systèmes de gestion de documents de qualité professionnelle.

Comment installer la bibliothèque PDF dans votre projet ASP.NET ?

Avant de mettre en œuvre la fonctionnalité d'affichage PDF, assurez-vous que votre projet ASP.NET a IronPDF installé. Ouvrez la console du gestionnaire de packages dans Visual Studio et exécutez l'une des commandes suivantes en fonction de vos préférences d'outils :

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

Vous pouvez également installer IronPDF via l'interface utilisateur NuGet Package Manager en recherchant IronPdf dans l'onglet Browse de votre projet. Après l'installation, définissez votre clé de licence au démarrage de l'application :

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

Une licence d'essai gratuite vous donne un accès complet à toutes les fonctionnalités pendant la période d'évaluation. Pour les déploiements en production, consultez les niveaux de licence disponibles afin de trouver une option adaptée à l'envergure de votre projet.

Quelle structure de base de données est requise ?

La structure de votre table de base de données a besoin d'une colonne varbinary(max) pour stocker les fichiers PDF en tant que données binaires. La table doit inclure des champs de métadonnées comme le nom du fichier, la date de téléchargement, et la taille du fichier pour une meilleure gestion des documents. La requête SQL suivante permet de créer une table adaptée à ce scénario :

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

Configurez votre chaîne de connexion dans le fichier web.config pour établir la connectivité avec la base de données. L'implémentation du visualiseur PDF utilisera cette connexion pour récupérer les fichiers téléchargés depuis la base de données et afficher le contenu PDF de manière fluide.

De quels espaces de noms la solution a-t-elle besoin ?

La solution utilise les espaces de noms .NET standard ainsi que l'espace de noms IronPDF . Vous n'avez besoin d'aucun ORM tiers : l'approche directe .NET minimise les dépendances et vous offre un contrôle total sur l'exécution des requêtes. Assurez-vous que la chaîne de connexion pointe vers une instance SQL Server où se trouve votre table de stockage PDF.

Comment créer une table de base de données pour les fichiers PDF ?

Commencez par créer une table de base de données spécialement conçue pour stocker des documents PDF. La structure du tableau doit pouvoir accueillir à la fois les données binaires et les métadonnées essentielles à la gestion des documents 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
);

Ce tableau stocke chaque fichier PDF sous forme de tableau d'octets dans la colonne FileData. Le type de données varbinary(max) peut contenir des fichiers allant jusqu'à 2 Go, ce qui est suffisant pour la plupart des documents PDF. Le champ FileName préserve le nom du fichier original à des fins d'affichage et de téléchargement.

Comment améliorer les performances des bases de données pour la récupération de fichiers PDF ?

Envisagez d'ajouter des index sur les colonnes fréquemment interrogées pour une meilleure performance lors de la récupération de documents PDF. La requête SQL suivante crée des index sur les colonnes les plus susceptibles d'apparaître dans les clauses WHERE et ORDER BY :

CREATE INDEX IX_PdfDocuments_UploadDate
ON PdfDocuments(UploadDate DESC);

CREATE INDEX IX_PdfDocuments_FileName
ON PdfDocuments(FileName);

Cette structure garantit un stockage et une récupération efficaces des fichiers téléchargés tout en conservant la flexibilité d'ajouter des champs de métadonnées supplémentaires si nécessaire. Pour les fichiers PDF très volumineux, il convient de déterminer si le stockage en base de données est adapté à votre architecture, ou si une approche hybride – stockant les fichiers sur disque ou sur un stockage objet et ne conservant que les métadonnées dans la base de données – serait plus performante à grande échelle.

Comparaison des stratégies de stockage des fichiers PDF
Stratégie Idéal pour Avantages Considérations
Base de données (VARBINAIRE) Fichiers de petite à moyenne taille, haute sécurité Cohérence transactionnelle, sauvegarde centralisée Peut augmenter rapidement la taille de la base de données
Système de fichiers Fichiers volumineux, débit élevé E/S de fichiers rapides, faible surcharge de la base de données Nécessite une stratégie de sauvegarde distincte
Stockage d'objets (Azure Blob/S3) Déploiements dans le cloud, échelle illimitée Rentable, très disponible Dépendance supplémentaire du SDK

Comment importer des fichiers PDF dans une base de données ?

Implémentez la fonctionnalité de téléchargement en utilisant le contrôle FileUpload d'ASP.NET. Ajoutez ce balisage HTML à votre page .aspx, dans un élément de formulaire avec une validation appropriée :

<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

Exemple de Sortie de l'Interface Utilisateur

Interface d'application web ASP.NET montrant un formulaire de téléchargement de PDF avec un bouton "Choisir un fichier" et un bouton "Télécharger un PDF", ainsi qu'une section vide de liste de documents PDF en dessous pour la gestion des documents

Comment gérez-vous les événements de téléchargement de fichiers ?

Le bouton de téléchargement déclenche le gestionnaire d'événements côté serveur. Voici l'implémentation complète de la fonction de téléchargement qui convertit les fichiers téléchargés en un tableau d'octets et les stocke avec une gestion des erreurs appropriée :

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

Ce code valide le type de fichier avant le téléchargement, garantissant ainsi que seuls les fichiers PDF valides sont stockés dans la base de données. La conversion des tableaux d'octets se fait automatiquement grâce à la propriété FileBytes. La validation supplémentaire comprend la vérification de l'intégrité du PDF et des limites de taille des fichiers. L'utilisation IronPDF pour ouvrir le tableau d'octets avant l'enregistrement confirme que le fichier est un véritable document PDF analysable, et non pas simplement un fichier avec une extension renommée.

Interface Utilisateur avec Fichiers Téléchargés

Interface d'application web ASP.NET montrant la fonctionnalité de téléchargement de PDF avec un formulaire de téléchargement de fichier et un tableau listant les documents PDF téléchargés avec des boutons d'action de visualisation et de téléchargement pour une gestion complète des documents

Comment récupérer et afficher les fichiers PDF à partir de la base de données ?

IronPDF excelle à rendre des documents PDF récupérés depuis une base de données. La bibliothèque offre plusieurs options pour afficher le contenu PDF dans les navigateurs dotés de capacités de rendu avancées. Commencez par récupérer les données binaires de votre table de base de données, puis transmettez-les à IronPDF pour traitement avant de les renvoyer au client :

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

La méthode ViewPdfDocument renvoie le document au client avec les paramètres de sécurité appropriés. La disposition du contenu inline indique au navigateur d'afficher le PDF plutôt que de demander un téléchargement. Vous pouvez ajuster les paramètres de sécurité, tels que les autorisations d'impression et les restrictions de copier-coller, afin de les adapter aux exigences de votre politique documentaire.

Comment gérer les paramètres de rendu PDF ?

Les paramètres de la commande SQL sont essentiels pour récupérer en toute sécurité un PDF spécifique grâce à sa clé primaire. Les requêtes paramétrées empêchent les attaques par injection SQL et garantissent une liaison de données correcte. Après avoir récupéré les données binaires, IronPDF les charge à partir d'un MemoryStream, ce qui vous donne un accès complet à l'objet document pour une manipulation plus poussée avant de l'envoyer au navigateur.

Visualiser un Fichier PDF Téléchargé

Interface de visualisation PDF montrant un document intitulé "Qu'est-ce qu'un PDF ?" avec un texte explicatif sur le format Portable Document, affiché à un zoom de 100 % avec des commandes de navigation et des indicateurs de prise en charge de plusieurs pages

Quelles fonctionnalités avancées pouvez-vous ajouter aux PDF avant leur affichage ?

Les fonctionnalités de manipulation de fichiers PDF d'IronPDF vont bien au-delà du simple affichage. Vous pouvez manipuler le document PDF avant le rendu en y ajoutant des filigranes , des en-têtes et des pieds de page , ainsi que des signatures numériques :

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

Affichage PDF avec Filigrane

Visionneuse PDF affichant un document sur " Qu'est-ce qu'un PDF ? " avec un contenu textuel détaillé et un filigrane " CONFIDENTIEL " en diagonale démontrant les capacités de filigrane d'IronPDF pour la sécurité des documents

Le filigrane est particulièrement utile pour afficher des documents que les utilisateurs doivent consulter mais pas reproduire mot pour mot. Vous pouvez également extraire du texte du PDF avant l'affichage pour créer des index de recherche, ou convertir des pages spécifiques en images pour générer des vignettes.

Pourquoi cette approche fonctionne-t-elle bien pour les applications de production ?

L'association d' .NET et IronPDF offre un modèle simple et adaptable, allant des petits outils internes aux systèmes de gestion de documents Enterprise . Cette approche est entièrement côté serveur ; aucune bibliothèque de rendu PDF côté client n'est requise, et le visualiseur PDF intégré au navigateur gère l'affichage une fois que le type MIME correct est renvoyé.

Les principaux atouts de ce modèle sont :

  • Validation lors du téléchargement : IronPDF ouvre le fichier avant qu'il n'atteigne la base de données, rejetant immédiatement les fichiers corrompus ou non PDF.
  • Contrôle de sécurité lors de la consultation : Les autorisations telles que l'impression et le copier-coller sont appliquées par IronPDF avant que les octets n'atteignent le navigateur.
  • Code côté client minimal : le navigateur gère le rendu nativement, réduisant ainsi la complexité du JavaScript .
  • Prétraitement flexible : Vous pouvez appliquer une chaîne HTML à la conversion PDF , fusionner des documents avec des opérations de fusion et de division , ou ajouter des filigranes personnalisés avant la diffusion en continu, le tout dans la même méthode côté serveur.

Comment gérez-vous l'intégration au navigateur et les options de téléchargement ?

Pour une meilleure intégration web, utilisez JavaScript pour ouvrir les documents dans un nouvel onglet plutôt que de remplacer la page actuelle. Cela offre aux utilisateurs une meilleure expérience lors de la consultation d'une liste de documents :

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

Le chemin de téléchargement suit la même logique de récupération de la base de données mais utilise attachment au lieu de inline comme disposition du contenu. Cela oblige le navigateur à enregistrer le fichier plutôt qu'à l'afficher. Les deux chemins partagent le même GetPdfFromDatabase@ helper, ce qui permet de conserver le code d'accès aux données DRY.

Pour les flux de travail documentaires basés sur des formulaires, explorez les fonctionnalités de remplissage de formulaires PDF d'IronPDF : vous pouvez pré-remplir les champs du formulaire avant d'afficher ou de télécharger un document, ce qui est utile pour la génération de factures et la gestion des contrats.

Quelles sont les considérations de sécurité relatives à la diffusion de fichiers PDF ?

Vérifiez toujours que l'utilisateur demandeur est autorisé à accéder à l'identifiant du document demandé avant de transmettre les données. Un simple identifiant numérique dans une chaîne de requête est facile à dénombrer ; sans contrôle d'autorisation, n'importe quel utilisateur authentifié pourrait consulter n'importe quel document en devinant les identifiants.

Les meilleures pratiques comprennent :

  • Enregistrez une colonne CreatedBy ou OwnerId et vérifiez-la par rapport à l'identité de l'utilisateur actuel avant d'interroger FileData.
  • Utilisez des GUID au lieu d'entiers séquentiels comme identifiants de documents pour rendre l'énumération impraticable.
  • Appliquez une protection par mot de passe PDF lors du téléchargement des documents hautement sensibles, afin que le fichier lui-même soit protégé même s'il est consulté en dehors de votre application.
  • Consigner tous les événements de consultation et de téléchargement à des fins d'audit.

Pour des références externes sur les modèles de sécurité ASP.NET , le guide de sécurité OWASP ASP.NET et les directives de codage sécurisé de Microsoft pour ASP.NET constituent des conseils faisant autorité. La fiche NuGet d' IronPDF documente également l'historique des versions et les dépendances.

Comment débuter avec l'affichage de bases de données PDF ?

Pour mettre en œuvre cette solution dans votre propre projet :

  1. Installez IronPDF via NuGet (Install-Package IronPdf ou dotnet add package IronPdf).
  2. Créez la table PdfDocuments à l'aide du schéma SQL ci-dessus.
  3. Ajoutez le gestionnaire de téléchargement à votre code-behind .aspx.
  4. Ajoutez les gestionnaires de vue et de téléchargement qui diffusent les octets via IronPDF.
  5. Connectez le GridView aux commandes de ligne pointant vers les gestionnaires.

Vous pouvez explorer l'ensemble des fonctionnalités IronPDF pour découvrir des capacités supplémentaires telles que la conversion HTML vers PDF et la fusion et la division de PDF qui s'intègrent naturellement aux flux de travail de gestion de documents. Démarrez un essai gratuit pour tester l'intégralité de l'API avant de souscrire à une licence .

Questions Fréquemment Posées

Quel est le principal objectif d'afficher des PDF depuis une base de données dans ASP.NET?

L'objectif principal est de fournir aux développeurs des méthodes efficaces pour afficher des PDF directement depuis une base de données au sein d'une application web ASP.NET, améliorant ainsi la fonctionnalité et l'expérience utilisateur du projet.

Comment IronPDF peut-il aider à afficher des PDF depuis une base de données dans ASP.NET?

IronPDF peut simplifier le processus en fournissant des bibliothèques robustes qui permettent aux développeurs de rendre des PDF sans difficulté à partir du stockage de base de données, assurant une intégration fluide dans les applications ASP.NET.

Quels sont les avantages d'utiliser IronPDF pour l'affichage de PDF dans ASP.NET?

Utiliser IronPDF offre des avantages tels qu'une intégration facile, un rendu de haute qualité et un support pour diverses fonctionnalités PDF, ce qui peut améliorer significativement l'utilisabilité et la performance de votre application ASP.NET.

IronPDF peut-il gérer efficacement de grands fichiers PDF depuis une base de données?

Oui, IronPDF est conçu pour gérer efficacement de grands fichiers PDF, assurant des temps de chargement et de rendu rapides, ce qui est crucial pour maintenir la performance de l'application.

Est-il possible de personnaliser l'affichage PDF avec IronPDF dans ASP.NET ?

Absolument, IronPDF offre diverses options de personnalisation permettant aux développeurs d'adapter l'affichage du PDF selon leurs besoins spécifiques dans un environnement ASP.NET.

Quels formats de fichiers IronPDF peut-il convertir en PDF dans les applications ASP.NET?

IronPDF supporte la conversion de divers formats de fichiers comme HTML, images, et plus encore en PDFs, ce qui peut être particulièrement utile pour la génération de contenu dynamique dans les applications ASP.NET.

IronPDF supporte-t-il la gestion sécurisée des PDFs pour les applications ASP.NET?

Oui, IronPDF supporte la gestion sécurisée des PDFs, y compris le chiffrement et la protection par mot de passe, ce qui aide à protéger les informations sensibles dans les applications ASP.NET.

IronPDF peut-il être intégré avec d'autres produits Iron Software pour une fonctionnalité améliorée?

Oui, IronPDF peut être intégré avec d'autres produits Iron Software comme IronOCR et IronBarcode pour fournir des solutions complètes de gestion et de traitement de documents dans les applications ASP.NET.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

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

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit

Équipe de soutien Iron

Nous sommes en ligne 24 heures sur 24, 5 jours sur 7.
Chat
Email
Appelez-moi