Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. Verwendung von IronPDF
  4. PDF aus der Datenbank in ASP.NET anzeigen
IRONPDF NUTZEN

Wie man eine PDF aus einer Datenbank in ASP.NET anzeigt

Curtis Chau
Curtis Chau
Veröffentlicht:

Einführung

Das Verwalten von PDF-Dokumenten in ASP.NET-Anwendungen erfordert oft das direkte Speichern von PDF-Dateien in einer Datenbank anstelle des Dateisystems. Dieser Ansatz bietet bessere Sicherheit, zentralisierte Backups und eine vereinfachte Bereitstellung. Das Abrufen und Anzeigen von PDF-Dokumenten aus einer Datenbank kann jedoch ohne die richtigen Werkzeuge eine Herausforderung sein.

Das Speichern von PDF-Dateien als Binärdaten in einer Datenbanktabelle ermöglicht eine bessere Kontrolle über den Dokumentenzugriff und die Versionierung. Wenn Sie PDF-Dokumente für Benutzer anzeigen müssen, müssen Sie das Byte-Array effizient aus der Datenbank abrufen und im Browser rendern. IronPDF vereinfacht diesen gesamten Prozess mit seiner leistungsstarken API für die Handhabung von PDF-Dokumenten in ASP.NET-Anwendungen.

Dieses Tutorial demonstriert die Funktionalität der Anzeige von PDFs in ASP.NET aus der Datenbank unter Verwendung der robusten Funktionen von IronPDF. Sie lernen, eine komplette Lösung zum Hochladen, Speichern und Anzeigen von PDF-Dateien mit optimaler Leistung und Sicherheit zu erstellen.

Voraussetzungen und Einrichtung

Stellen Sie vor der Implementierung der PDF-Anzeigefunktionalität sicher, dass Ihr ASP.NET-Projekt IronPDF installiert hat. Öffnen Sie die Paket-Manager-Konsole im Solution Explorer von Visual Studio und führen Sie aus:

Install-Package IronPdf

Ihre Datenbanktabellenstruktur benötigt eine varbinary(max)-Spalte, um PDF-Dateien als Binärdaten zu speichern. Die Tabelle sollte Metadatenfelder wie Dateiname, Upload-Datum und Dateigröße enthalten, um eine bessere Dokumentenverwaltung zu gewährleisten. Hier ist der folgende Code, um Ihre Umgebung einzurichten:

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

Konfigurieren Sie Ihren Verbindungsstring in der web.config-Datei, um die Datenbankverbindung herzustellen. Die PDF-Viewer-Implementierung wird diese Verbindung nutzen, um hochgeladene Dateien aus der Datenbank abzurufen und PDF-Inhalte nahtlos anzuzeigen.

Erstellen der Datenbanktabelle

Beginnen Sie mit dem Erstellen einer Datenbanktabelle, die speziell für das Speichern von PDF-Dokumenten ausgelegt ist. Die Tabellenstruktur sollte sowohl Binärdaten als auch wesentliche Metadaten beibehalten:

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

Diese Tabelle speichert jede PDF-Datei als Byte-Array in der FileData-Spalte. Der varbinary(max)-Datentyp kann Dateien bis zu 2GB speichern, was für die meisten PDF-Dokumente ausreichend ist. Das FileName<\/code>-Feld bewahrt den urspr\u00fcnglichen Dateinamen f\u00fcr Anzeige- und Downloadzwecke.

Berücksichtigen Sie, Indizes auf häufig abgefragte Spalten hinzuzufügen, um die Leistung beim Abrufen von PDF-Dokumenten zu verbessern. Der folgende Code erstellt einen Index auf der Spalte UploadDate:

CREATE INDEX IX_PdfDocuments_UploadDate 
ON PdfDocuments(UploadDate DESC);

Diese Struktur gewährleistet eine effiziente Speicherung und den Abruf von hochgeladenen Dateien, während sie die Flexibilität erhält, zusätzliche Metadatenfelder nach Bedarf hinzuzufügen.

PDF-Dateien in die Datenbank hochladen

Implementieren Sie die Upload-Funktionalität mit dem FileUpload-Steuerelement von ASP.NET. Fügen Sie dieses HTML-Markup zu Ihrer .aspx-Seite hinzu, möglicherweise innerhalb eines Form-Elements hinzu:

<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

Beispiel für die UI-Ausgabe

So zeigen Sie ein PDF aus einer Datenbank in ASP.NET an: Abbildung 1 - Beispiel-UI

Die Upload-Schaltfläche löst den serverseitigen Ereignishandler aus. Hier ist die vollständige Implementierung für die Upload-Funktion, die hochgeladene Dateien vom angegebenen Dateipfad in ein Byte-Array umwandelt und speichert. Wir werden die Logik schreiben, um den Post-Request zu bearbeiten:

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

Dieser Code validiert den Dateityp vor dem Hochladen, um sicherzustellen, dass nur PDF-Dateien in der Datenbank gespeichert werden. Die Byte-Array-Konvertierung erfolgt automatisch über die FileBytes-Eigenschaft.

Benutzeroberfläche mit hochgeladenen Dateien

So zeigen Sie ein PDF aus einer Datenbank in ASP.NET an: Abbildung 2 - Beispiel-UI mit den in unserer Datenbank hochgeladenen PDFs

Abrufen und Anzeigen von PDF-Dokumenten mit IronPDF

IronPDF ist hervorragend darin, PDF-Dokumente, die aus einer Datenbank abgerufen werden, darzustellen. Die Bibliothek bietet mehrere Optionen, um PDF-Inhalte in Browsern anzuzeigen. Zuerst müssen Sie die Binärdaten aus Ihrer Datenbanktabelle abrufen:

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

Die Parameter für den SQL-Befehl sind entscheidend für das sichere Abrufen des spezifischen PDFs. Die ViewPdfDocument-Methode übernimmt dann das Streaming des Dokuments zurück an den Client.

Ansicht einer hochgeladenen PDF-Datei

So zeigen Sie ein PDF aus einer Datenbank in ASP.NET an: Abbildung 3 - Hochgeladenes PDF wird angezeigt

Die PDF-Viewer-Fähigkeiten von IronPDF gehen über die einfache Anzeige hinaus. Sie können das PDF-Dokument vor dem Rendern manipulieren:

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

PDF mit Wasserzeichen anzeigen

So zeigen Sie ein PDF aus einer Datenbank in ASP.NET an: Abbildung 4

Die Unterstützung des PDF-Viewers ist robust. Für eine bessere Web-Integration und zur Steuerung der Anzeigebreite des Inhalts verwenden Sie CSS und JavaScript, um ein Dokument im Dialog oder in einem neuen Tab zu öffnen, zentriert auf dem Bildschirm.

<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

Komplettes Arbeitsbeispiel: PDF-Viewer in ASP.NET C#;

Hier ist ein umfassendes, kombiniertes Beispielcode, das alle Komponenten umfasst, um ein voll funktionsfähiges System zur Verwaltung von PDF-Dateien in Ihrer Datenbank zu erstellen:

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

Diese Implementierung umfasst Fehlerbehandlung und Validierung, um ein robustes Management von PDF-Dokumenten zu gewährleisten. Der Quellcode demonstriert Best Practices für die Arbeit mit Binärdaten und Dateioperationen.

Abschluss

Die Implementierung der Funktionalität von ASP.NET zum Anzeigen von PDFs aus der Datenbank wird mit IronPDF einfach. Die Bibliothek handhabt die Komplexität der PDF-Dokumenten-Darstellung und bietet umfangreiche Anpassungsoptionen. Von einfachen Anzeigeszenarien bis zu komplexer Dokumentenmanipulation bietet IronPDF die erforderlichen Werkzeuge für das professionelle PDF-Management in ASP.NET-Anwendungen.

Die in diesem Artikel behandelten Techniken bieten eine solide Grundlage für den Aufbau robuster Dokumentenmanagementsysteme. Die umfassende API von IronPDF stellt sicher, dass Ihre Anwendung verschiedene PDF-bezogene Anforderungen effizient bewältigen kann, von grundlegenden Datei-Upload- und Speicherfunktionen bis zu fortgeschrittener Darstellung und Manipulation.

Bereit, professionelle PDF-Funktionen in Ihren ASP.NET-Anwendungen zu implementieren? Starten Sie heute Ihre kostenlose Testversion von IronPDF und erleben Sie die Vorteile eines nahtlosen PDF-Managements. Für Produktionsbereitstellungen erkunden Sie unsere flexiblen Lizenzierungsoptionen, die sich an Ihren Bedürfnissen orientieren.

Häufig gestellte Fragen

Was ist der Hauptfokus bei der Anzeige von PDFs aus einer Datenbank in ASP.NET?

Der Hauptfokus besteht darin, Entwicklern effektive Methoden zur Verfügung zu stellen, um PDFs direkt aus einer Datenbank innerhalb einer ASP.NET-Webanwendung anzuzeigen, wodurch die Funktionalität und Benutzererfahrung des Projekts verbessert wird.

Wie kann IronPDF bei der Anzeige von PDFs aus einer Datenbank in ASP.NET helfen?

IronPDF kann den Prozess vereinfachen, indem es robuste Bibliotheken bereitstellt, die es Entwicklern ermöglichen, PDFs nahtlos aus der Datenbankspeicherung zu rendern und so eine reibungslose Integration in ASP.NET-Anwendungen sicherzustellen.

Welche Vorteile bietet die Verwendung von IronPDF für die PDF-Anzeige in ASP.NET?

Die Verwendung von IronPDF bietet Vorteile wie einfache Integration, hochwertige Rendering und Unterstützung für verschiedene PDF-Funktionen, die die Benutzerfreundlichkeit und Leistung Ihrer ASP.NET-Anwendung erheblich verbessern können.

Kann IronPDF große PDF-Dateien aus einer Datenbank effizient verarbeiten?

Ja, IronPDF ist darauf ausgelegt, große PDF-Dateien effizient zu verarbeiten und sicherzustellen, dass Lade- und Rendering-Zeiten schnell sind, was entscheidend für die Aufrechterhaltung der Anwendungsleistung ist.

Ist es möglich, die PDF-Anzeige mit IronPDF in ASP.NET anzupassen?

Absolut, IronPDF bietet verschiedene Anpassungsoptionen, die es Entwicklern ermöglichen, die PDF-Anzeige gemäß ihren spezifischen Anforderungen innerhalb einer ASP.NET-Umgebung zu gestalten.

Welche Dateiformate kann IronPDF in PDF in ASP.NET-Anwendungen konvertieren?

IronPDF unterstützt die Konvertierung verschiedener Dateiformate wie HTML, Bilder und mehr in PDFs, was besonders nützlich für die dynamische Inhaltserstellung in ASP.NET-Anwendungen sein kann.

Unterstützt IronPDF die sichere PDF-Verarbeitung für ASP.NET-Anwendungen?

Ja, IronPDF unterstützt die sichere PDF-Verarbeitung, einschließlich Verschlüsselung und Kennwortschutz, was hilft, sensible Informationen innerhalb von ASP.NET-Anwendungen zu schützen.

Kann IronPDF mit anderen Iron Software-Produkten für erweiterte Funktionalität integriert werden?

Ja, IronPDF kann mit anderen Iron Software-Produkten wie IronOCR und IronBarcode integriert werden, um umfassende Lösungen für Dokumentenverwaltung und -verarbeitung in ASP.NET-Anwendungen zu bieten.

Curtis Chau
Curtis Chau
  Jetzt mit dem Ingenieurteam chatten
Technischer Autor

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen