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

Comment afficher un PDF depuis une base de données dans ASP.NET

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

Pourquoi stocker les PDF dans une base de données plutôt que dans un système de fichiers ?

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 à son API efficace pour la gestion des documents PDF dans les applications ASP.NET.

Quels sont les avantages offerts par IronPDF ?

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

Quelles sont les conditions préalables nécessaires à l'affichage d'une base de données PDF ?

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 l'Explorateur de Solutions de Visual Studio et exécutez :

Install-Package IronPdf

Quelle structure de base de données est requise ?

La structure de votre table de base de données nécessite 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. Voici le code suivant pour configurer votre environnement de travail avec les fichiers PDF dans ASP.NET :

using IronPdf;
using System.Data.SqlClient;
using System.IO;
using System.Configuration;
using System.Web.UI.WebControls;
using IronPdf;
using System.Data.SqlClient;
using System.IO;
using System.Configuration;
using System.Web.UI.WebControls;
$vbLabelText   $csharpLabel

Comment configurer la connectivité à la base de données ?

Configurez votre chaîne de connexion dans le fichier web.config pour établir une connectivité à 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. Envisagez la mise en place d'une journalisation personnalisée pour le débogage des opérations de base de données.

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

Quels types de données devez-vous utiliser pour le stockage des fichiers PDF ?

Cette table 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 jusqu'à 2 Go, ce qui est suffisant pour la plupart des documents PDF . Le champ FileName préserve le nom de fichier original pour les besoins d'affichage et de téléchargement. Envisagez de compresser les fichiers PDF avant de les stocker afin d'économiser de l'espace dans la base de données.

Comment améliorer les performances de votre base de données ?

Envisagez d'ajouter des index sur les colonnes fréquemment interrogées pour améliorer les performances lors de la récupération de documents PDF . Le code suivant crée un index sur la colonne UploadDate pour améliorer les opérations PDF :

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 volumineux , envisagez la mise en œuvre d'opérations de flux .

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, par exemple 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 affichant un formulaire de téléchargement de PDF avec les boutons " Choisir un fichier " et " Télécharger un PDF ", ainsi qu'une section vide " Liste des 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 depuis le chemin de fichier spécifié en un tableau d'octets et les stocke. Vous écrirez la logique permettant de traiter la requête POST 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;
                }
            }

            // Connection string is retrieved from web.config
            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(); // Refresh the list after upload
        }
        catch (Exception ex)
        {
            lblMessage.Text = "Error uploading file: " + ex.Message;
            // Log error details
        }
    }
    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;
                }
            }

            // Connection string is retrieved from web.config
            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(); // Refresh the list after upload
        }
        catch (Exception ex)
        {
            lblMessage.Text = "Error uploading file: " + ex.Message;
            // Log error details
        }
    }
    else
    {
        lblMessage.Text = "Please select a valid PDF file.";
    }
}
$vbLabelText   $csharpLabel

Quelle validation devez-vous mettre en œuvre ?

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 en tableau d'octets se fait automatiquement via 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.

Interface Utilisateur avec Fichiers Téléchargés

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

Comment récupérer et afficher des fichiers PDF avec IronPDF ?

IronPDF excelle dans le rendu des documents PDF extraits d'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 . Tout d'abord, récupérez les données binaires de votre table de base de données :

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

            // Format file sizes for display
            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";
}

// Helper method to retrieve PDF data from the database
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())
                {
                    // Retrieve binary data
                    pdfBytes = (byte[])reader["FileData"];
                    filename = reader["FileName"].ToString();
                }
            }
        }
    }
    if (pdfBytes != null)
    {
        return new PdfData { Bytes = pdfBytes, FileName = filename };
    }
    return null;
}

// ----------------- GridView Command Handlers -----------------
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 if needed
        pdf.SecuritySettings.AllowUserPrinting = true;
        pdf.SecuritySettings.AllowUserCopyPasteContent = false;

        // Configure response to display inline in the browser
        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);

            // Format file sizes for display
            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";
}

// Helper method to retrieve PDF data from the database
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())
                {
                    // Retrieve binary data
                    pdfBytes = (byte[])reader["FileData"];
                    filename = reader["FileName"].ToString();
                }
            }
        }
    }
    if (pdfBytes != null)
    {
        return new PdfData { Bytes = pdfBytes, FileName = filename };
    }
    return null;
}

// ----------------- GridView Command Handlers -----------------
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 if needed
        pdf.SecuritySettings.AllowUserPrinting = true;
        pdf.SecuritySettings.AllowUserCopyPasteContent = false;

        // Configure response to display inline in the browser
        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();
    }
}
$vbLabelText   $csharpLabel

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

Les paramètres pour la commande SQL sont cruciaux pour récupérer en toute sécurité le PDF spécifique. La méthode ViewPdfDocument se charge ensuite de renvoyer le document au client avec les paramètres de sécurité appropriés .

Visualiser un Fichier PDF Téléchargé

Interface de visualisation PDF affichant un document intitulé " Qu'est-ce qu'un PDF ? " avec un texte explicatif sur le format PDF (Portable Document Format), affiché à un zoom de 100 % avec des commandes de navigation et des indicateurs de prise en charge des documents multipages.

Quelles fonctionnalités avancées peut-on ajouter aux PDF ?

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 annotations et des signatures numériques :

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

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

// Convert specific pages to images for preview
var previewImages = pdf.RasterizeToImageFiles("preview_*.png", 1, 3, 150, 
                                              IronPdf.Imaging.ImageType.Png);

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

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

// Convert specific pages to images for preview
var previewImages = pdf.RasterizeToImageFiles("preview_*.png", 1, 3, 150, 
                                              IronPdf.Imaging.ImageType.Png);

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

Affichage PDF avec Filigrane

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

Comment améliorer l'intégration du navigateur ?

La prise en charge des visionneuses PDF est fiable. Pour une meilleure intégration web et un contrôle précis de la largeur d'affichage du contenu, utilisez CSS et JavaScript pour ouvrir les documents dans une boîte de dialogue ou un nouvel onglet, centrés sur l'écran. Vous pouvez également implémenter des paramètres de fenêtre d'affichage personnalisés :

<script type="text/javascript">
    function openPdfInNewTab(documentId) {
        // This generates a simple HTTP GET request to a handler URL
        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';
    }
</script>

<div id="pdfModal" class="modal">
    <div class="modal-content">
        <span class="close">&times;</span>
        <iframe id="pdfFrame" width="100%" height="600px"></iframe>
    </div>
</div>
```## What Does a Complete PDF Viewer Example Look Like?

Here's a complete sample code combining all components to create a fully functional system for [managing PDF files](https://ironpdf.com/tutorials/organize-pdfs-complete-tutorial/) in your database with [improved security features](https://ironpdf.com/tutorials/csharp-pdf-security-complete-tutorial/):

```csharp
using IronPdf;
using System;
using System.Configuration;
using System.Data;
using System.Data.SqlClient;
using System.IO;
using System.Web.UI.WebControls;

namespace PdfDatabaseViewer
{
    public partial class Default : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            if (!IsPostBack)
            {
                LoadPdfList();
            }
            License.LicenseKey = "Your-License-Key";
        }

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

                    if (fileBytes.Length > maxFileSize)
                    {
                        lblMessage.Text = "File size exceeds 10MB limit.";
                        lblMessage.CssClass = "error-message";
                        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.";
                            lblMessage.CssClass = "error-message";
                            return;
                        }
                        lblFileInfo.Text = $"Pages: {testPdf.PageCount}, Size: {FormatFileSize(fileBytes.Length)}";
                    }

                    // Connection string is retrieved from web.config
                    string constr = ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;
                    using (SqlConnection conn = new SqlConnection(constr))
                    {
                        string query = @"INSERT INTO PdfDocuments 
                                       (FileName, FileData, FileSize, CreatedBy, LastModified) 
                                       VALUES (@FileName, @FileData, @FileSize, @CreatedBy, GETDATE())";
                        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!";
                    lblMessage.CssClass = "success-message";
                    LoadPdfList(); // Refresh the list after upload
                }
                catch (Exception ex)
                {
                    lblMessage.Text = "Error uploading file: " + ex.Message;
                    lblMessage.CssClass = "error-message";
                    // Log error details for debugging
                    System.Diagnostics.Trace.WriteLine($"Upload Error: {ex}");
                }
            }
            else
            {
                lblMessage.Text = "Please select a valid PDF file.";
                lblMessage.CssClass = "warning-message";
            }
        }

        // ----------------- Data Retrieval and List Display -----------------
        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);

                    // Add formatted columns
                    dt.Columns.Add("FormattedSize", typeof(string));
                    dt.Columns.Add("FormattedDate", typeof(string));

                    foreach (DataRow row in dt.Rows)
                    {
                        int fileSize = Convert.ToInt32(row["FileSize"]);
                        row["FormattedSize"] = FormatFileSize(fileSize);
                        row["FormattedDate"] = Convert.ToDateTime(row["UploadDate"]).ToString("MMM dd, yyyy HH:mm");
                    }

                    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.0).ToString("F2") + " MB";
        }

        // Helper method to retrieve PDF data from the database
        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())
                        {
                            // Retrieve binary data
                            pdfBytes = (byte[])reader["FileData"];
                            filename = reader["FileName"].ToString();
                        }
                    }
                }
            }
            if (pdfBytes != null)
            {
                return new PdfData { Bytes = pdfBytes, FileName = filename };
            }
            return null;
        }

        // ----------------- GridView Command Handlers -----------------
        protected void GridView1_RowCommand(object sender, GridViewCommandEventArgs e)
        {
            try
            {
                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);
                }
            }
            catch (Exception ex)
            {
                lblMessage.Text = "Error processing request: " + ex.Message;
                lblMessage.CssClass = "error-message";
            }
        }

        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 watermark for viewing
                pdf.ApplyWatermark("<h2 style='color:red; font-family:Arial'>CONFIDENTIAL</h2>", 
                                 rotation: 30, 
                                 opacity: 50);

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

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

                // Configure response to display inline in the browser
                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 DownloadPdfDocument(int id)
        {
            var pdfData = GetPdfFromDatabase(id);
            if (pdfData != null)
            {
                // Configure response to force a download/save prompt
                Response.Clear();
                Response.ContentType = "application/pdf";
                Response.AddHeader("content-disposition", $"attachment; filename={pdfData.FileName}");
                Response.AddHeader("content-length", pdfData.Bytes.Length.ToString());
                Response.BinaryWrite(pdfData.Bytes);
                Response.End();
            }
        }
    }
}

// Helper class must be outside the Default class
public class PdfData
{
    public byte[] Bytes { get; set; }
    public string FileName { get; set; }
}
<script type="text/javascript">
    function openPdfInNewTab(documentId) {
        // This generates a simple HTTP GET request to a handler URL
        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';
    }
</script>

<div id="pdfModal" class="modal">
    <div class="modal-content">
        <span class="close">&times;</span>
        <iframe id="pdfFrame" width="100%" height="600px"></iframe>
    </div>
</div>
```## What Does a Complete PDF Viewer Example Look Like?

Here's a complete sample code combining all components to create a fully functional system for [managing PDF files](https://ironpdf.com/tutorials/organize-pdfs-complete-tutorial/) in your database with [improved security features](https://ironpdf.com/tutorials/csharp-pdf-security-complete-tutorial/):

```csharp
using IronPdf;
using System;
using System.Configuration;
using System.Data;
using System.Data.SqlClient;
using System.IO;
using System.Web.UI.WebControls;

namespace PdfDatabaseViewer
{
    public partial class Default : System.Web.UI.Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            if (!IsPostBack)
            {
                LoadPdfList();
            }
            License.LicenseKey = "Your-License-Key";
        }

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

                    if (fileBytes.Length > maxFileSize)
                    {
                        lblMessage.Text = "File size exceeds 10MB limit.";
                        lblMessage.CssClass = "error-message";
                        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.";
                            lblMessage.CssClass = "error-message";
                            return;
                        }
                        lblFileInfo.Text = $"Pages: {testPdf.PageCount}, Size: {FormatFileSize(fileBytes.Length)}";
                    }

                    // Connection string is retrieved from web.config
                    string constr = ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;
                    using (SqlConnection conn = new SqlConnection(constr))
                    {
                        string query = @"INSERT INTO PdfDocuments 
                                       (FileName, FileData, FileSize, CreatedBy, LastModified) 
                                       VALUES (@FileName, @FileData, @FileSize, @CreatedBy, GETDATE())";
                        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!";
                    lblMessage.CssClass = "success-message";
                    LoadPdfList(); // Refresh the list after upload
                }
                catch (Exception ex)
                {
                    lblMessage.Text = "Error uploading file: " + ex.Message;
                    lblMessage.CssClass = "error-message";
                    // Log error details for debugging
                    System.Diagnostics.Trace.WriteLine($"Upload Error: {ex}");
                }
            }
            else
            {
                lblMessage.Text = "Please select a valid PDF file.";
                lblMessage.CssClass = "warning-message";
            }
        }

        // ----------------- Data Retrieval and List Display -----------------
        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);

                    // Add formatted columns
                    dt.Columns.Add("FormattedSize", typeof(string));
                    dt.Columns.Add("FormattedDate", typeof(string));

                    foreach (DataRow row in dt.Rows)
                    {
                        int fileSize = Convert.ToInt32(row["FileSize"]);
                        row["FormattedSize"] = FormatFileSize(fileSize);
                        row["FormattedDate"] = Convert.ToDateTime(row["UploadDate"]).ToString("MMM dd, yyyy HH:mm");
                    }

                    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.0).ToString("F2") + " MB";
        }

        // Helper method to retrieve PDF data from the database
        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())
                        {
                            // Retrieve binary data
                            pdfBytes = (byte[])reader["FileData"];
                            filename = reader["FileName"].ToString();
                        }
                    }
                }
            }
            if (pdfBytes != null)
            {
                return new PdfData { Bytes = pdfBytes, FileName = filename };
            }
            return null;
        }

        // ----------------- GridView Command Handlers -----------------
        protected void GridView1_RowCommand(object sender, GridViewCommandEventArgs e)
        {
            try
            {
                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);
                }
            }
            catch (Exception ex)
            {
                lblMessage.Text = "Error processing request: " + ex.Message;
                lblMessage.CssClass = "error-message";
            }
        }

        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 watermark for viewing
                pdf.ApplyWatermark("<h2 style='color:red; font-family:Arial'>CONFIDENTIAL</h2>", 
                                 rotation: 30, 
                                 opacity: 50);

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

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

                // Configure response to display inline in the browser
                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 DownloadPdfDocument(int id)
        {
            var pdfData = GetPdfFromDatabase(id);
            if (pdfData != null)
            {
                // Configure response to force a download/save prompt
                Response.Clear();
                Response.ContentType = "application/pdf";
                Response.AddHeader("content-disposition", $"attachment; filename={pdfData.FileName}");
                Response.AddHeader("content-length", pdfData.Bytes.Length.ToString());
                Response.BinaryWrite(pdfData.Bytes);
                Response.End();
            }
        }
    }
}

// Helper class must be outside the Default class
public class PdfData
{
    public byte[] Bytes { get; set; }
    public string FileName { get; set; }
}
HTML

Cette implémentation inclut une gestion et une validation complètes des erreurs afin de garantir une gestion fiable des documents PDF. Le code source illustre les meilleures pratiques pour travailler avec des données binaires et effectuer des opérations sur les fichiers .

Pourquoi utiliser IronPDF pour l'affichage de PDF de bases de données ?

Implémenter la fonctionnalité d'affichage des fichiers PDF à partir de bases de données ASP.NET devient simple avec IronPDF. La bibliothèque gère la complexité du rendu des documents PDF tout en offrant de nombreuses options de personnalisation . Des scénarios d'affichage simples à la manipulation complexe de documents , IronPDF offre les outils nécessaires à une gestion professionnelle des PDF dans les applications ASP.NET.

Qu'est-ce qui rend cette solution prête pour la production ?

Les techniques présentées dans cet article constituent une base solide pour la construction de systèmes de gestion documentaire fiables. L'API complète d'IronPDF garantit que votre application peut gérer efficacement diverses exigences liées aux PDF , du téléchargement et du stockage de fichiers de base aux fonctionnalités avancées de rendu et de manipulation. La bibliothèque prend également en charge le déploiement sur des plateformes cloud telles qu'Azure et AWS .

Comment débuter avec IronPDF ?

Prêt à implémenter une fonctionnalité PDF professionnelle dans vos applications ASP.NET ? Démarrez votre essai gratuit d'IronPDF dès aujourd'hui et découvrez la puissance d'une gestion fluide des fichiers PDF. Pour les déploiements en production, découvrez nos options de licences flexibles qui évoluent en fonction de vos besoins.

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 en utilisant 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