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

PDF aus Datenbank in ASP.NET anzeigen (Entwicklerhandbuch)

Curtis Chau
Curtis Chau
Aktualisiert:

Um PDFs aus einer Datenbank in ASP.NET anzuzeigen, rufen Sie die gespeicherten Binärdaten ab und rendern Sie sie mit der PdfDocument-Klasse von IronPDF , die Byte-Arrays effizient verarbeitet und eine browserkompatible Ausgabe mit Anpassungsoptionen bietet.

Was ist die PDF-Datenbankanzeige in ASP.NET?

Die Verwaltung von PDF-Dokumenten in ASP.NET Anwendungen beinhaltet oft das direkte Speichern von PDF-Dateien in einer Datenbank anstatt im Dateisystem. Diese Methode bietet bessere Sicherheit, zentralisierte Datensicherung und 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 durch eine effektive API zur Verarbeitung von PDF-Dokumenten in ASP.NET -Anwendungen.

Dieses Tutorial demonstriert die ASP.NET Funktionalität zum Anzeigen von PDFs aus einer Datenbank unter Verwendung der bewährten Funktionen von IronPDF. Sie lernen, eine Komplettlösung zum Hochladen, Speichern und Anzeigen von PDF-Dateien mit optimaler Leistung und Sicherheit zu erstellen. Die Bibliothek unterstützt verschiedene Rendering-Optionen und erweiterte PDF-Bearbeitungsfunktionen, die den Aufbau von Dokumentenmanagementsystemen in Produktionsqualität vereinfachen.

Wie installiert man die PDF-Bibliothek in einem ASP.NET -Projekt?

Stellen Sie vor der Implementierung der PDF-Anzeigefunktionalität sicher, dass Ihr ASP.NET-Projekt IronPDF installiert hat. Öffnen Sie die Paket-Manager-Konsole in Visual Studio und führen Sie je nach Ihren bevorzugten Tools einen der folgenden Befehle aus:

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

Sie können IronPDF auch über die NuGet Package Manager UI installieren, indem Sie auf der Registerkarte Durchsuchen Ihres Projekts nach IronPdf suchen. Nach der Installation müssen Sie Ihren Lizenzschlüssel beim Start der Anwendung festlegen:

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

Mit einer kostenlosen Testlizenz erhalten Sie während der Testphase vollen Zugriff auf alle Funktionen. Bei Produktionsumgebungen sollten Sie die verfügbaren Lizenzstufen prüfen, um eine Option zu finden, die zu Ihrem Projektumfang passt.

Welche Datenbankstruktur ist erforderlich?

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. Der folgende SQL-Befehl erstellt eine geeignete Tabelle für dieses Szenario:

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

Konfigurieren Sie Ihre Verbindungszeichenfolge in der Datei web.config, um die Datenbankkonnektivität herzustellen. Die PDF-Viewer-Implementierung nutzt diese Verbindung, um hochgeladene Dateien aus der Datenbank abzurufen und PDF-Inhalte reibungslos anzuzeigen.

Welche Namensräume benötigt die Lösung?

Die Lösung verwendet neben dem IronPDF Namensraum auch die Standard- .NET -Namensräume. Sie benötigen kein ORM von Drittanbietern – der direkte ADO .NET Ansatz hält die Abhängigkeiten minimal und gibt Ihnen die volle Kontrolle über die Abfrageausführung. Stellen Sie sicher, dass die Verbindungszeichenfolge auf eine SQL Server-Instanz verweist, in der sich Ihre PDF-Speichertabelle befindet.

Wie erstellt man eine Datenbanktabelle für PDFs?

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

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

Diese Tabelle speichert jede PDF-Datei als Byte-Array in der Spalte FileData. Der Datentyp varbinary(max) kann Dateien bis zu 2 GB aufnehmen, was für die meisten PDF-Dokumente ausreicht. Das Feld FileName bewahrt den ursprünglichen Dateinamen für Anzeige- und Downloadzwecke.

Wie lässt sich die Datenbankleistung für den PDF-Abruf verbessern?

Berücksichtigen Sie, Indizes auf häufig abgefragte Spalten hinzuzufügen, um die Leistung beim Abrufen von PDF-Dokumenten zu verbessern. Der folgende SQL-Code erstellt Indizes für die Spalten, die am wahrscheinlichsten in WHERE- und ORDER BY-Klauseln vorkommen:

CREATE INDEX IX_PdfDocuments_UploadDate
ON PdfDocuments(UploadDate DESC);

CREATE INDEX IX_PdfDocuments_FileName
ON PdfDocuments(FileName);

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. Bei sehr großen PDF-Dateien sollten Sie überlegen, ob die Speicherung in einer Datenbank für Ihre Architektur geeignet ist oder ob ein hybrider Ansatz – bei dem die Dateien auf der Festplatte oder im Objektspeicher abgelegt und nur die Metadaten in der Datenbank gespeichert werden – bei großem Umfang eine bessere Leistung erbringen würde.

Vergleich von PDF-Speicherstrategien
Strategie Am besten für Vorteile Überlegungen
Datenbank (VARBINÄR) Kleine bis mittlere Dateien, hohe Sicherheit Transaktionskonsistenz, zentralisierte Datensicherung Kann die Datenbankgröße schnell erhöhen
Dateisystem Große Dateien, hoher Durchsatz Schnelle Datei-E/A, geringer Datenbank-Overhead Erfordert eine separate Backup-Strategie
Objektspeicher (Azure Blob/S3) Cloud-Bereitstellungen, unbegrenzte Skalierbarkeit Kostengünstig, hohe Verfügbarkeit Zusätzliche SDK-Abhängigkeit

Wie lädt man PDF-Dateien in eine Datenbank hoch?

Implementieren Sie die Upload-Funktionalität mithilfe des ASP.NET-Steuerelements FileUpload. Fügen Sie diesen HTML-Code in Ihre .aspx-Seite innerhalb eines Formularelements mit entsprechender Validierung ein:

<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

Beispiel für die UI-Ausgabe

ASP.NET-Webanwendungsschnittstelle, die ein PDF-Upload-Formular mit den Schaltflächen Choose file und Upload PDF sowie einen leeren Abschnitt mit einer PDF-Dokumentenliste für die Dokumentenverwaltung zeigt

Wie gehen Sie mit Datei-Upload-Ereignissen um?

Die Upload-Schaltfläche löst den serverseitigen Ereignishandler aus. Hier ist die vollständige Implementierung der Upload-Funktion, die hochgeladene Dateien in ein Byte-Array umwandelt und sie mit entsprechender Fehlerbehandlung speichert:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Dieser Code überprüft den Dateityp vor dem Hochladen und stellt so sicher, dass nur gültige PDF-Dateien in der Datenbank gespeichert werden. Die Konvertierung von Byte-Arrays erfolgt automatisch über die Eigenschaft FileBytes. Die zusätzliche Validierung umfasst die Prüfung der PDF-Integrität und der Dateigrößenbeschränkungen. Durch die Verwendung von IronPDF zum Öffnen des Byte-Arrays vor dem Speichern wird bestätigt, dass es sich bei der Datei um ein echtes, auswertbares PDF-Dokument handelt – und nicht nur um eine Datei mit einer umbenannten Dateiendung.

Benutzeroberfläche mit hochgeladenen Dateien

ASP.NET-Webanwendungsschnittstelle mit PDF-Upload-Funktionalität mit einem Formular zum Hochladen von Dateien und einer Tabelle, in der die hochgeladenen PDF-Dokumente aufgelistet sind, mit Schaltflächen zum Anzeigen und Herunterladen für die vollständige Dokumentenverwaltung

Wie ruft man PDFs aus der Datenbank ab und zeigt sie an?

IronPDF ist hervorragend darin, PDF-Dokumente, die aus einer Datenbank abgerufen werden, darzustellen. Die Bibliothek bietet verschiedene Möglichkeiten, PDF-Inhalte in Browsern mit erweiterten Rendering-Funktionen anzuzeigen. Zuerst werden die Binärdaten aus der Datenbanktabelle abgerufen und anschließend zur Verarbeitung an IronPDF übergeben, bevor sie wieder an den Client gestreamt werden:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Mit der Methode ViewPdfDocument wird das Dokument mit den entsprechenden Sicherheitseinstellungen an den Kunden zurückgesendet. Die inline Inhaltsdisposition weist den Browser an, die PDF-Datei anzuzeigen, anstatt einen Download zu veranlassen. Sie können Sicherheitseinstellungen wie Druckberechtigungen und Kopier-/Einfügebeschränkungen an die Anforderungen Ihrer Dokumentrichtlinien anpassen.

Wie handhabt man PDF-Rendering-Parameter?

Die Parameter des SQL-Befehls sind entscheidend für das sichere Abrufen einer bestimmten PDF-Datei anhand ihres Primärschlüssels. Parametrisierte Abfragen verhindern SQL-Injection-Angriffe und gewährleisten eine korrekte Datenbindung. Nach dem Abrufen der Binärdaten lädt IronPDF diese aus einem MemoryStream, so dass Sie vollen Zugriff auf das Dokumentobjekt haben, um es weiter zu bearbeiten, bevor Sie es an den Browser senden.

Ansicht einer hochgeladenen PDF-Datei

PDF-Viewer-Benutzeroberfläche, die ein Dokument mit dem Titel 'Was ist ein PDF?' mit erläuterndem Text über das Portable Document Format zeigt, angezeigt bei 100 % Zoom mit Navigationssteuerungen und Indikatoren für die Unterstützung mehrerer Seiten

Welche erweiterten Funktionen können Sie PDFs vor der Anzeige hinzufügen?

Die PDF-Manipulationsfunktionen von IronPDF gehen über die einfache Anzeige hinaus. Sie können das PDF-Dokument vor dem Rendern mit Wasserzeichen , Kopf- und Fußzeilen sowie digitalen Signaturen bearbeiten:

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

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

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

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

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

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

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

PDF mit Wasserzeichen anzeigen

PDF-Viewer, der ein Dokument zum Thema Was ist ein PDF? mit detailliertem Textinhalt und einem diagonalen CONFIDENTIAL-Wasserzeichen anzeigt, das die IronPDF-Wasserzeichenfunktionen zur Dokumentensicherheit demonstriert

Wasserzeichen sind besonders nützlich, wenn Dokumente angezeigt werden sollen, die Benutzer zwar ansehen, aber nicht wortgetreu reproduzieren sollen. Sie können auch Text aus der PDF-Datei extrahieren , bevor diese angezeigt wird, um Suchindizes zu erstellen, oder bestimmte Seiten in Bilder umwandeln, um Miniaturansichten zu generieren.

Warum eignet sich dieser Ansatz gut für Produktionsanwendungen?

Die Kombination von ADO .NET mit IronPDF bietet ein unkompliziertes Muster, das von kleinen internen Tools bis hin zu Dokumentenmanagementsystemen für Enterprise skalierbar ist. Der Ansatz ist rein serverseitig – es wird keine clientseitige PDF-Rendering-Bibliothek benötigt, und der im Browser integrierte PDF-Viewer übernimmt die Anzeige, sobald der korrekte MIME-Typ zurückgegeben wird.

Die wichtigsten Stärken dieses Musters sind:

  • Validierung beim Hochladen : IronPDF öffnet die Datei, bevor sie die Datenbank erreicht, und weist beschädigte oder Nicht-PDF-Dateien sofort zurück.
  • Sicherheitskontrolle zur Anzeigezeit : Berechtigungen wie Drucken und Kopieren/Einfügen werden von IronPDF durchgesetzt, bevor die Bytes den Browser erreichen.
  • Minimaler clientseitiger Code : Der Browser übernimmt das Rendering nativ, wodurch die JavaScript Komplexität reduziert wird.
  • Flexible Vorverarbeitung : Sie können HTML-Strings in PDF konvertieren , Dokumente mit Merge- und Split-Operationen zusammenführen oder vor dem Streaming benutzerdefinierte Wasserzeichen hinzufügen – alles innerhalb derselben serverseitigen Methode.

Wie handhaben Sie die Browserintegration und die Downloadoptionen?

Für eine bessere Webintegration sollten Sie JavaScript verwenden, um Dokumente in einem neuen Tab zu öffnen, anstatt die aktuelle Seite zu ersetzen. Dies bietet Nutzern ein besseres Erlebnis beim Durchsuchen einer Dokumentenliste:

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

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

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

Der Download-Pfad folgt der gleichen Datenbankabfragelogik, verwendet aber attachment anstelle von inline als Inhaltsdisposition. Dadurch wird der Browser gezwungen, die Datei zu speichern, anstatt sie anzuzeigen. Beide Pfade verwenden dieselbe GetPdfFromDatabase-Hilfe, um den Datenzugriffscode DRY zu halten.

Für formularbasierte Dokumenten-Workflows sollten Sie die PDF-Formularausfüllfunktionen von IronPDF erkunden – Sie können Formularfelder vor dem Anzeigen oder Herunterladen eines Dokuments vorausfüllen, was für Szenarien der Rechnungserstellung und des Vertragsmanagements nützlich ist.

Welche Sicherheitsaspekte sind beim PDF-Serving zu berücksichtigen?

Vor der Auslieferung der Bytes muss stets geprüft werden, ob der anfragende Benutzer die Berechtigung zum Zugriff auf die angeforderte Dokument-ID besitzt. Eine einfache ganzzahlige ID in einer Abfragezeichenfolge ist leicht zu ermitteln – ohne Autorisierungsprüfungen könnte jeder authentifizierte Benutzer jedes Dokument durch Erraten der IDs anzeigen.

Zu den bewährten Verfahren gehören:

  • Speichern Sie eine CreatedBy oder OwnerId Spalte und überprüfen Sie sie mit der aktuellen Benutzeridentität, bevor Sie FileData abfragen.
  • Verwenden Sie GUIDs anstelle von fortlaufenden Ganzzahlen als Dokumentbezeichner, um eine Aufzählung unpraktisch zu machen.
  • Wenden Sie beim Hochladen von hochsensiblen Dokumenten einen PDF-Passwortschutz an, sodass die Datei selbst auch dann geschützt ist, wenn von außerhalb Ihrer Anwendung darauf zugegriffen wird.
  • Alle Ansichts- und Downloadereignisse werden für Prüfprotokolle protokolliert.

Als externe Referenz für ASP.NET Sicherheitsmuster bieten das OWASP ASP.NET Security Cheat Sheet und die sicheren Codierungsrichtlinien von Microsoft für ASP.NET maßgebliche Anleitungen. Der NuGet Galerieeintrag für IronPDF dokumentiert auch die Versionshistorie und Abhängigkeiten.

Wie fange ich mit der PDF-Datenbankanzeige an?

So implementieren Sie diese Lösung in Ihrem eigenen Projekt:

  1. Installieren Sie IronPDF über NuGet (Install-Package IronPdf oder dotnet add package IronPdf).
  2. Erstellen Sie die Tabelle PdfDocuments unter Verwendung des obigen SQL-Schemas.
  3. Fügen Sie den Upload-Handler zu Ihrem .aspx-Code-Behind hinzu.
  4. Fügen Sie die View- und Download-Handler hinzu, die Bytes durch IronPDF streamen.
  5. Verbinden Sie das GridView mit Zeilenbefehlen, die auf die Handler verweisen.

Sie können den vollen Funktionsumfang von IronPDF erkunden und zusätzliche Funktionen wie die Konvertierung von HTML in PDF sowie das Zusammenführen und Aufteilen von PDFs entdecken, die sich nahtlos in Dokumentenmanagement-Workflows einfügen. Starten Sie eine kostenlose Testphase , um die vollständige API zu testen, bevor Sie sich für eine Lizenz entscheiden.

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

Iron Support Team

Wir sind 24 Stunden am Tag, 5 Tage die Woche online.
Chat
E-Mail
Rufen Sie mich an