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
Publié:

Introduction

La gestion des documents PDF dans les applications ASP.NET nécessite souvent de stocker les fichiers PDF directement dans une base de données plutôt que dans le système de fichiers. Cette approche 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 ce processus entier avec son API puissante pour gérer les documents PDF dans les applications ASP.NET.

Ce tutoriel démontre la fonctionnalité d'affichage de PDF depuis une base de données ASP.NET en utilisant les fonctionnalités robustes d'IronPDF. Vous apprendrez à créer une solution complète pour télécharger, stocker et afficher des fichiers PDF avec une performance et une sécurité optimales.

Prérequis et Configuration

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

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 :

using IronPdf;
using System.Data.SqlClient;
using System.IO;
using IronPdf;
using System.Data.SqlClient;
using System.IO;
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Configurez votre chaîne de connexion dans le fichier web.config pour établir une connectivité à la base de données. L'implémentation du visionneur de 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 transparente.

Création de la Table de Base de Données

Commencez par créer une table de base de données spécialement conçue pour stocker des documents PDF. La structure de la table doit accueillir à la fois les données binaires et les métadonnées essentielles :

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

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, 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 d'ajouter des index sur les colonnes fréquemment interrogées pour une meilleure performance lors de la récupération de documents PDF. Le code suivant crée un index sur la colonne UploadDate :

CREATE INDEX IX_PdfDocuments_UploadDate 
ON PdfDocuments(UploadDate DESC);

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.

Téléchargement de Fichiers PDF vers la 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, peut-être dans un élément de formulaire :

<div>
    <asp:FileUpload ID="FileUpload1" runat="server" />
    <asp:Button ID="btnUpload" Text="Upload PDF" 
                OnClick="btnUpload_Click" runat="server" />
    <asp:Label ID="lblMessage" runat="server" />
</div>
<div>
    <asp:FileUpload ID="FileUpload1" runat="server" />
    <asp:Button ID="btnUpload" Text="Upload PDF" 
                OnClick="btnUpload_Click" runat="server" />
    <asp:Label ID="lblMessage" runat="server" />
</div>
HTML

Exemple de Sortie de l'Interface Utilisateur

Comment afficher un PDF depuis une base de données en ASP.NET : Figure 1 - Exemple d'IU

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. Nous écrirons la logique pour traiter la requête POST :

protected void btnUpload_Click(object sender, EventArgs e)
{
    if (FileUpload1.HasFile && FileUpload1.PostedFile.ContentType == "application/pdf")
    {
        string fileName = FileUpload1.FileName;
        byte[] fileBytes = FileUpload1.FileBytes;
        // 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) " +
                           "VALUES (@FileName, @FileData, @FileSize)";
            using (SqlCommand cmd = new SqlCommand(query, conn))
            {
                cmd.Parameters.AddWithValue("@FileName", fileName);
                cmd.Parameters.AddWithValue("@FileData", fileBytes);
                cmd.Parameters.AddWithValue("@FileSize", fileBytes.Length);
                conn.Open();
                cmd.ExecuteNonQuery();
            }
        }
        lblMessage.Text = "PDF document uploaded successfully!";
        LoadPdfList(); // Refresh the list after upload
    }
    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")
    {
        string fileName = FileUpload1.FileName;
        byte[] fileBytes = FileUpload1.FileBytes;
        // 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) " +
                           "VALUES (@FileName, @FileData, @FileSize)";
            using (SqlCommand cmd = new SqlCommand(query, conn))
            {
                cmd.Parameters.AddWithValue("@FileName", fileName);
                cmd.Parameters.AddWithValue("@FileData", fileBytes);
                cmd.Parameters.AddWithValue("@FileSize", fileBytes.Length);
                conn.Open();
                cmd.ExecuteNonQuery();
            }
        }
        lblMessage.Text = "PDF document uploaded successfully!";
        LoadPdfList(); // Refresh the list after upload
    }
    else
    {
        lblMessage.Text = "Please select a valid PDF file.";
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Ce code valide le type de fichier avant le téléchargement, en veillant à ce que seuls les fichiers PDF soient stockés dans la base de données. La conversion en tableau d'octets se fait automatiquement via la propriété FileBytes.

Interface Utilisateur avec Fichiers Téléchargés

Comment afficher un PDF depuis une base de données en ASP.NET : Figure 2 - Exemple d'IU avec les PDFs téléchargés dans notre base de données

Récupération et Affichage de Documents PDF avec IronPDF

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. 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 FROM PdfDocuments ORDER BY UploadDate DESC";
        using (SqlCommand cmd = new SqlCommand(query, conn))
        {
            conn.Open();
            GridView1.DataSource = cmd.ExecuteReader();
            GridView1.DataBind();
        }
    }
}

// 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 == "Download Pdf")
    {
        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);
        }
        // Configure response to display inline in the browser
        Response.Clear();
        Response.ContentType = "application/pdf";
        Response.AddHeader("content-disposition", $"inline; filename={pdfData.FileName}");
        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 FROM PdfDocuments ORDER BY UploadDate DESC";
        using (SqlCommand cmd = new SqlCommand(query, conn))
        {
            conn.Open();
            GridView1.DataSource = cmd.ExecuteReader();
            GridView1.DataBind();
        }
    }
}

// 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 == "Download Pdf")
    {
        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);
        }
        // Configure response to display inline in the browser
        Response.Clear();
        Response.ContentType = "application/pdf";
        Response.AddHeader("content-disposition", $"inline; filename={pdfData.FileName}");
        Response.BinaryWrite(pdf.BinaryData);
        Response.End();
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

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 gère ensuite le streaming du document vers le client.

Visualiser un Fichier PDF Téléchargé

Comment afficher un PDF depuis une base de données en ASP.NET : Figure 3 - PDF téléchargé en train d'être affiché

IronPDF's les capacités du visionneur PDF vont au-delà de la simple affichage. Vous pouvez manipuler le document PDF avant le rendu :

// Add watermark before displaying
pdf.ApplyWatermark("<h2>CONFIDENTIAL</h2>", rotation: 30, opacity: 50);
// Convert specific pages to images for preview
var previewImage = pdf.RasterizeToImageFiles("preview*.png", 1, 3);
// Add watermark before displaying
pdf.ApplyWatermark("<h2>CONFIDENTIAL</h2>", rotation: 30, opacity: 50);
// Convert specific pages to images for preview
var previewImage = pdf.RasterizeToImageFiles("preview*.png", 1, 3);
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Affichage PDF avec Filigrane

Comment afficher un PDF depuis une base de données en ASP.NET : Figure 4

Le soutien du visionneur PDF est robuste. Pour une meilleure intégration web et un contrôle de la largeur d'affichage du contenu, utilisez CSS et JavaScript pour ouvrir un document dans une boîte de dialogue ou un nouvel onglet, centré sur l'écran.

<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');
    }
</script>
<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');
    }
</script>
HTML

Exemple Complet : Visionneur PDF en ASP.NET C

Voici un exemple de code complet combinant tous les composants pour créer un système entièrement fonctionnel pour gérer des fichiers PDF dans votre base de données :

using IronPdf;
using System;
using System.Configuration; // Required for ConfigurationManager
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")
            {
                string fileName = FileUpload1.FileName;
                byte[] fileBytes = FileUpload1.FileBytes;
                // 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) " +
                                   "VALUES (@FileName, @FileData, @FileSize)";
                    using (SqlCommand cmd = new SqlCommand(query, conn))
                    {
                        cmd.Parameters.AddWithValue("@FileName", fileName);
                        cmd.Parameters.AddWithValue("@FileData", fileBytes);
                        cmd.Parameters.AddWithValue("@FileSize", fileBytes.Length);
                        conn.Open();
                        cmd.ExecuteNonQuery();
                    }
                }
                lblMessage.Text = "PDF document uploaded successfully!";
                LoadPdfList(); // Refresh the list after upload
            }
            else
            {
                lblMessage.Text = "Please select a valid PDF file.";
            }
        }

        // ----------------- 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 FROM PdfDocuments ORDER BY UploadDate DESC";
                using (SqlCommand cmd = new SqlCommand(query, conn))
                {
                    conn.Open();
                    GridView1.DataSource = cmd.ExecuteReader();
                    GridView1.DataBind();
                }
            }
        }

        // 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 == "Download Pdf")
            {
                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);
                }
                pdf.ApplyWatermark("<h2 style='color:red'>CONFIDENTIAL</h2>", rotation: 30, opacity: 50);

                // Configure response to display inline in the browser
                Response.Clear();
                Response.ContentType = "application/pdf";
                Response.AddHeader("content-disposition", $"inline; filename={pdfData.FileName}");
                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.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; }
}
using IronPdf;
using System;
using System.Configuration; // Required for ConfigurationManager
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")
            {
                string fileName = FileUpload1.FileName;
                byte[] fileBytes = FileUpload1.FileBytes;
                // 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) " +
                                   "VALUES (@FileName, @FileData, @FileSize)";
                    using (SqlCommand cmd = new SqlCommand(query, conn))
                    {
                        cmd.Parameters.AddWithValue("@FileName", fileName);
                        cmd.Parameters.AddWithValue("@FileData", fileBytes);
                        cmd.Parameters.AddWithValue("@FileSize", fileBytes.Length);
                        conn.Open();
                        cmd.ExecuteNonQuery();
                    }
                }
                lblMessage.Text = "PDF document uploaded successfully!";
                LoadPdfList(); // Refresh the list after upload
            }
            else
            {
                lblMessage.Text = "Please select a valid PDF file.";
            }
        }

        // ----------------- 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 FROM PdfDocuments ORDER BY UploadDate DESC";
                using (SqlCommand cmd = new SqlCommand(query, conn))
                {
                    conn.Open();
                    GridView1.DataSource = cmd.ExecuteReader();
                    GridView1.DataBind();
                }
            }
        }

        // 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 == "Download Pdf")
            {
                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);
                }
                pdf.ApplyWatermark("<h2 style='color:red'>CONFIDENTIAL</h2>", rotation: 30, opacity: 50);

                // Configure response to display inline in the browser
                Response.Clear();
                Response.ContentType = "application/pdf";
                Response.AddHeader("content-disposition", $"inline; filename={pdfData.FileName}");
                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.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; }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Cette implémentation inclut la gestion des erreurs et la validation pour assurer une gestion robuste des documents PDF. Le code source démontre les meilleures pratiques pour travailler avec des données binaires et des opérations de fichiers.

Conclusion

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 les complexités du rendu des documents PDF tout en offrant de vastes options de personnalisation. Des scénarios d'affichage simples à la manipulation complexe de documents, IronPDF offre les outils nécessaires pour une gestion professionnelle des PDF dans les applications ASP.NET.

Les techniques couvertes dans cet article fournissent une base solide pour construire des systèmes robustes de gestion de documents. L'API complète d'IronPDF garantit que votre application peut gérer divers besoins liés aux PDF de manière efficace, du simple téléchargement et stockage de fichiers aux fonctionnalités avancées de rendu et de manipulation.

Prêt à implémenter une fonctionnalité PDF professionnelle dans vos applications ASP.NET ? Commencez votre essai gratuit d'IronPDF aujourd'hui et découvrez la puissance d'une gestion PDF sans faille. Pour les déploiements en production, explorez nos options de licence flexibles qui s'adaptent à 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. Démarrer l'essai gratuit