Ikona wiadomości
Przejdź do treści stopki
  1. IronPDF
  2. Blog IronPDF
  3. Korzystanie z IronPDF
  4. Wyświetlanie plików PDF z bazy danych ASP .NET
KORZYSTANIE Z IRONPDF

Wyświetlanie plików PDF z bazy danych w ASP.NET (Przewodnik dla programistów)

Curtis Chau
Curtis Chau
Zaktualizowano:

Aby wyświetlić pliki PDF z bazy danych w ASP.NET, należy pobrać zapisane dane binarne i wyrenderować je za pomocą klasy PdfDocument biblioteki IronPDF, która efektywnie obsługuje tablice bajtów i zapewnia wynik zgodny z przeglądarkami wraz z opcjami dostosowywania.

Czym jest wyświetlanie bazy danych PDF w ASP.NET?

Zarządzanie dokumentami PDF w aplikacjach ASP.NET często wiąże się z przechowywaniem plików PDF bezpośrednio w bazie danych, a nie w systemie plików. Ta metoda zapewnia większe bezpieczeństwo, scentralizowane tworzenie kopii zapasowych oraz uproszczone wdrażanie. Jednak pobieranie i wyświetlanie dokumentów PDF z bazy danych może być trudne bez odpowiednich narzędzi.

Przechowywanie plików PDF jako danych binarnych w tabeli bazy danych pozwala na lepszą kontrolę nad dostępem do dokumentów i wersjonowaniem. Gdy chcesz wyświetlić użytkownikom dokumenty PDF, musisz sprawnie pobrać tablicę bajtów z bazy danych i wyrenderować ją w przeglądarce. IronPDF upraszcza cały ten proces dzięki wydajnemu interfejsowi API do obsługi dokumentów PDF w aplikacjach ASP.NET.

Ten samouczek pokazuje, jak wyświetlać pliki PDF z bazy danych w ASP.NET, korzystając ze sprawdzonych funkcji IronPDF. Nauczysz się tworzyć kompletne rozwiązanie do przesyłania, przechowywania i wyświetlania plików PDF, zapewniające optymalną wydajność i bezpieczeństwo. Biblioteka obsługuje różne opcje renderowania oraz zaawansowane funkcje manipulacji plikami PDF, co ułatwia tworzenie systemów zarządzania dokumentami na poziomie produkcyjnym.

Jak zainstalować bibliotekę PDF w projekcie ASP.NET?

Przed wdrożeniem funkcji wyświetlania plików PDF upewnij się, że w projekcie ASP.NET zainstalowano IronPDF. Otwórz konsolę menedżera pakietów w Visual Studio i uruchom jedno z poniższych poleceń w zależności od preferowanych narzędzi:

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

Można również zainstalować IronPDF za pomocą interfejsu użytkownika menedżera pakietów NuGet, wyszukując IronPdf w zakładce Przeglądaj projektu. Po instalacji należy ustawić klucz licencyjny podczas uruchamiania aplikacji:

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

Bezpłatna licencja próbna zapewnia pełny dostęp do wszystkich funkcji podczas okresu testowego. W przypadku wdrożeń produkcyjnych zapoznaj się z dostępnymi poziomami licencji, aby znaleźć opcję dostosowaną do skali Twojego projektu.

Jaka struktura bazy danych jest wymagana?

Struktura tabeli bazy danych wymaga kolumny varbinary(max) do przechowywania plików PDF jako danych binarnych. Tabela powinna zawierać pola metadanych, takie jak nazwa pliku, data przesłania i rozmiar pliku, aby ułatwić zarządzanie dokumentami. Poniższy kod SQL tworzy tabelę odpowiednią dla tego scenariusza:

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

Skonfiguruj ciąg połączenia w pliku web.config, aby nawiązać połączenie z bazą danych. Implementacja przeglądarki plików PDF będzie wykorzystywać to połączenie do pobierania przesłanych plików z bazy danych i płynnego wyświetlania treści PDF.

Jakich przestrzeni nazw wymaga to rozwiązanie?

Rozwiązanie wykorzystuje standardowe przestrzenie nazw ADO.NET wraz z przestrzenią nazw IronPDF. Nie potrzebujesz żadnego zewnętrznego ORM — bezpośrednie podejście ADO.NET ogranicza zależności do minimum i zapewnia pełną kontrolę nad wykonywaniem zapytań. Upewnij się, że ciąg połączenia wskazuje instancję serwera SQL, na której znajduje się tabela przechowywania plików PDF.

Jak utworzyć tabelę bazy danych dla plików PDF?

Zacznij od utworzenia tabeli bazy danych zaprojektowanej specjalnie do przechowywania dokumentów PDF. Struktura tabeli powinna uwzględniać zarówno dane binarne, jak i niezbędne metadane do zarządzania dokumentami PDF:

CREATE TABLE PdfDocuments (
    Id INT PRIMARY KEY IDENTITY(1,1),
    FileName NVARCHAR(255) NOT NULL,
    FileData VARBINARY(MAX) NOT NULL,
    ContentType NVARCHAR(100) DEFAULT 'application/pdf',
    FileSize INT,
    UploadDate DATETIME DEFAULT GETDATE(),
    CreatedBy NVARCHAR(100),
    LastModified DATETIME,
    DocumentVersion INT DEFAULT 1
);

Ta tabela przechowuje każdy plik PDF jako tablicę bajtów w kolumnie FileData. Typ danych varbinary(max) może pomieścić pliki o rozmiarze do 2 GB, co jest wystarczające dla większości dokumentów PDF. Pole FileName zachowuje oryginalną nazwę pliku do celów wyświetlania i pobierania.

Jak można poprawić wydajność bazy danych w zakresie wyszukiwania plików PDF?

Rozważ dodanie indeksów do często wyszukiwanych kolumn, aby uzyskać lepszą wydajność podczas pobierania dokumentów PDF. Poniższy kod SQL tworzy indeksy w kolumnach, które najprawdopodobniej pojawią się w klauzulach WHERE i ORDER BY:

CREATE INDEX IX_PdfDocuments_UploadDate
ON PdfDocuments(UploadDate DESC);

CREATE INDEX IX_PdfDocuments_FileName
ON PdfDocuments(FileName);

Taka struktura zapewnia wydajne przechowywanie i pobieranie przesłanych plików, zachowując jednocześnie elastyczność w zakresie dodawania dodatkowych pól metadanych w razie potrzeby. W przypadku bardzo dużych plików PDF należy rozważyć, czy przechowywanie w bazie danych jest odpowiednim rozwiązaniem dla danej architektury, czy też lepszym rozwiązaniem w przypadku dużych skal byłoby podejście hybrydowe — przechowywanie plików na dysku lub w pamięci obiektowej, a w bazie danych pozostawianie jedynie metadanych.

Porównanie strategii przechowywania plików PDF
Strategia Najlepsze dla Zalety Uwagi
Baza danych (VARBINARY) Pliki o małej i średniej wielkości, wysoki poziom bezpieczeństwa Spójność transakcyjna, scentralizowane tworzenie kopii zapasowych Może szybko zwiększyć rozmiar bazy danych
System plików Duże pliki, wysoka przepustowość Szybki wczyt i zapis plików, niskie obciążenie bazy danych Wymaga oddzielnej strategii tworzenia kopii zapasowych
Pamięć obiektowa (Azure Blob/S3) Wdrożenia w chmurze, nieograniczona skala Ekonomiczne, o wysokiej dostępności Dodatkowa zależność SDK

Jak przesłać pliki PDF do bazy danych?

Zaimplementuj funkcję przesyłania plików przy użyciu kontrolki FileUpload platformy ASP.NET. Dodaj ten kod HTML do swojej strony .aspx w elemencie formularza z odpowiednią walidacją:

<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

Przykładowy wynik interfejsu użytkownika

Interfejs aplikacji internetowej ASP.NET przedstawiający formularz przesyłania plików PDF z przyciskami

Jak radzisz sobie z zdarzeniami związanymi z przesyłaniem plików?

Przycisk przesyłania uruchamia procedurę obsługi zdarzeń po stronie serwera. Oto pełna implementacja funkcji przesyłania, która konwertuje przesłane pliki na tablicę bajtów i zapisuje je z odpowiednią obsługą błędów:

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

Ten kod sprawdza typ pliku przed przesłaniem, zapewniając, że w bazie danych przechowywane są wyłącznie prawidłowe pliki PDF. Konwersja tablicy bajtów odbywa się automatycznie za pośrednictwem właściwości FileBytes. Dodatkowa weryfikacja obejmuje sprawdzenie integralności pliku PDF oraz limitów rozmiaru pliku. Użycie IronPDF do otwarcia tablicy bajtów przed zapisaniem potwierdza, że plik jest autentycznym, możliwym do przetworzenia dokumentem PDF — a nie tylko plikiem z zmienionym rozszerzeniem.

Interfejs użytkownika z przesłanymi plikami

Interfejs aplikacji internetowej ASP.NET pokazujący funkcję przesyłania plików PDF z formularzem przesyłania plików oraz tabelą zawierającą listę przesłanych dokumentów PDF z przyciskami przeglądania i pobierania, umożliwiającymi pełne zarządzanie dokumentami

Jak pobierać i wyświetlać pliki PDF z bazy danych?

IronPDF doskonale radzi sobie z renderowaniem dokumentów PDF pobranych z bazy danych. Biblioteka oferuje wiele opcji wyświetlania treści PDF w przeglądarkach z zaawansowanymi możliwościami renderowania. Najpierw pobierz dane binarne z tabeli bazy danych, a następnie przekaż je do IronPDF w celu przetworzenia, zanim zostaną przesłane z powrotem do klienta:

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

Metoda ViewPdfDocument przesyła dokument z powrotem do klienta z zastosowaniem odpowiednich ustawień bezpieczeństwa. Dyspozycja treści inline nakazuje przeglądarce wyświetlenie pliku PDF zamiast wyświetlania monitu o pobranie. Możesz dostosować ustawienia zabezpieczeń, takie jak uprawnienia do drukowania i ograniczenia kopiowania i wklejania, aby spełnić wymagania polityki dotyczącej dokumentów.

Jak radzisz sobie z parametrami renderowania plików PDF?

Parametry polecenia SQL mają kluczowe znaczenie dla bezpiecznego pobrania konkretnego pliku PDF na podstawie jego klucza głównego. Zapytania parametryzowane zapobiegają atakom typu SQL injection i zapewniają prawidłowe powiązanie danych. Po pobraniu danych binarnych IronPDF ładuje je z MemoryStream, zapewniając pełny dostęp do obiektu dokumentu w celu dalszej obróbki przed wysłaniem go do przeglądarki.

Wyświetlanie przesłanego pliku PDF

Interfejs przeglądarki plików PDF wyświetlający dokument zatytułowany

Jakie zaawansowane funkcje można dodać do plików PDF przed wyświetleniem?

Możliwości IronPDF w zakresie obróbki plików PDF wykraczają poza zwykłe wyświetlanie. Przed renderowaniem można modyfikować dokument PDF, dodając znaki wodne, nagłówki i stopki oraz podpisy cyfrowe:

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

Wyświetlanie pliku PDF ze znakiem wodnym

Przeglądarka plików PDF wyświetlająca dokument zatytułowany

Znak wodny jest szczególnie przydatny podczas wyświetlania dokumentów, które użytkownicy powinni przeglądać, ale nie powielać dosłownie. Można również wyodrębnić tekst z pliku PDF przed wyświetleniem w celu utworzenia indeksów wyszukiwania lub przekonwertować określone strony na obrazy w celu wygenerowania miniatur.

Dlaczego to podejście sprawdza się w aplikacjach produkcyjnych?

Połączenie ADO.NET z IronPDF zapewnia prosty wzorzec, który można skalować od małych narzędzi wewnętrznych po korporacyjne systemy zarządzania dokumentami. Podejście jest całkowicie po stronie serwera — nie jest wymagana żadna biblioteka renderowania PDF po stronie klienta, a wbudowana przeglądarka PDF w przeglądarce obsługuje wyświetlanie po zwróceniu prawidłowego typu MIME.

Główne zalety tego wzorca to:

  • Walidacja w momencie przesyłania: IronPDF otwiera plik, zanim trafi on do bazy danych, natychmiast odrzucając pliki uszkodzone lub niebędące plikami PDF.
  • Kontrola bezpieczeństwa w czasie wyświetlania: uprawnienia, takie jak drukowanie i kopiowanie-wklejanie, są egzekwowane przez IronPDF, zanim bajty dotrą do przeglądarki.
  • Minimalna ilość kodu po stronie klienta: przeglądarka obsługuje renderowanie natywnie, co zmniejsza złożoność kodu JavaScript.
  • Elastyczne przetwarzanie wstępne: Możesz konwertować ciągi HTML na PDF, łączyć dokumenty za pomocą operacji scalania i dzielenia lub dodawać niestandardowe znaki wodne przed strumieniowaniem — wszystko w ramach tej samej metody po stronie serwera.

Jak radzisz sobie z integracją przeglądarek i opcjami pobierania?

Aby zapewnić lepszą integrację z siecią, należy używać JavaScript do otwierania dokumentów w nowej karcie zamiast zastępowania bieżącej strony. Dzięki temu użytkownicy mają lepsze wrażenia podczas przeglądania listy dokumentów:

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

Ścieżka pobierania opiera się na tej samej logice pobierania danych z bazy, ale jako dyspozycję treści wykorzystuje attachment zamiast inline. To zmusza przeglądarkę do zapisania pliku zamiast jego wyświetlenia. Obie ścieżki korzystają z tego samego pomocnika GetPdfFromDatabase, dzięki czemu kod dostępu do danych jest zgodny z zasadą DRY.

W przypadku przepływów pracy opartych na formularzach warto zapoznać się z funkcjami wypełniania formularzy PDF w IronPDF — można wstępnie wypełnić pola formularza przed wyświetleniem lub pobraniem dokumentu, co jest przydatne w scenariuszach generowania faktur i zarządzania umowami.

Jakie są kwestie związane z bezpieczeństwem w przypadku udostępniania plików PDF?

Zawsze sprawdzaj, czy użytkownik składający żądanie ma uprawnienia dostępu do żądanego identyfikatora dokumentu przed wysłaniem danych. Prosty identyfikator całkowitoliczbowy w ciągu zapytania jest łatwy do wyliczenia — bez kontroli autoryzacji każdy uwierzytelniony użytkownik mógłby wyświetlić dowolny dokument, odgadując identyfikatory.

Najlepsze praktyki obejmują:

  • Zapisz kolumnę CreatedBy lub OwnerId i zweryfikuj ją względem aktualnej tożsamości użytkownika przed wysłaniem zapytania do FileData.
  • Należy używać identyfikatorów GUID zamiast kolejnych liczb całkowitych jako identyfikatorów dokumentów, aby uniemożliwić ich wyliczenie.
  • Zastosuj ochronę hasłem plików PDF podczas przesyłania w przypadku dokumentów o wysokim stopniu poufności, tak aby sam plik był chroniony nawet w przypadku uzyskania do niego dostępu poza aplikacją.
  • Rejestruj wszystkie zdarzenia wyświetlania i pobierania na potrzeby ścieżek audytu.

Jeśli chodzi o zewnętrzne źródła dotyczące wzorców bezpieczeństwa ASP.NET, autorytatywnymi wskazówkami są: OWASP ASP.NET Security Cheat Sheet oraz wytyczne Microsoftu dotyczące bezpiecznego kodowania dla ASP.NET. Wpis dotyczący IronPdf w galerii NuGet zawiera również historię wersji i zależności.

Jak rozpocząć korzystanie z PDF Database Display?

Aby wdrożyć to rozwiązanie we własnym projekcie:

  1. Zainstaluj IronPDF za pomocą NuGet (Install-Package IronPdf lub dotnet add package IronPdf).
  2. Utwórz tabelę PdfDocuments, korzystając z powyższego schematu SQL.
  3. Dodaj procedurę obsługi przesyłania do kodu źródłowego pliku .aspx.
  4. Dodaj procedury obsługi wyświetlania i pobierania, które przesyłają bajty za pośrednictwem IronPDF.
  5. Podłącz GridView za pomocą poleceń wiersza wskazujących na procedury obsługi.

Możesz zapoznać się z pełnym zestawem funkcji IronPDF, aby odkryć dodatkowe możliwości, takie jak konwersja HTML do PDF oraz łączenie i dzielenie plików PDF, które naturalnie wpisują się w procesy zarządzania dokumentami. Rozpocznij bezpłatny okres próbny, aby przetestować pełną wersję API przed zakupem licencji.

Często Zadawane Pytania

Na czym polega główny cel wyświetlania plików PDF z bazy danych w ASP.NET?

Głównym celem jest zapewnienie programistom skutecznych metod wyświetlania plików PDF bezpośrednio z bazy danych w aplikacji internetowej ASP.NET, co poprawi funkcjonalność i komfort użytkowania projektu.

W jaki sposób IronPDF może pomóc w wyświetlaniu plików PDF z bazy danych w ASP.NET?

IronPDF może uprościć ten proces, dostarczając solidne biblioteki, które pozwalają programistom na płynne renderowanie plików PDF z baz danych, zapewniając płynną integrację z aplikacjami ASP.NET.

Jakie są zalety korzystania z IronPDF do wyświetlania plików PDF w ASP.NET?

Korzystanie z IronPDF oferuje takie zalety, jak łatwa integracja, wysokiej jakości renderowanie oraz obsługa różnych funkcji PDF, co może znacznie poprawić użyteczność i wydajność aplikacji ASP.NET.

Czy IronPDF może efektywnie obsługiwać duże pliki PDF z bazy danych?

Tak, IronPDF został zaprojektowany do wydajnej obsługi dużych plików PDF, zapewniając szybkie ładowanie i renderowanie, co ma kluczowe znaczenie dla utrzymania wydajności aplikacji.

Czy można dostosować wyświetlanie plików PDF za pomocą IronPDF w ASP.NET?

Oczywiście, IronPDF oferuje różne opcje dostosowywania, pozwalające programistom dostosować wyświetlanie plików PDF do ich konkretnych wymagań w środowisku ASP.NET.

Jakie formaty plików IronPDF może konwertować do formatu PDF w aplikacjach ASP.NET?

IronPDF obsługuje konwersję różnych formatów plików, takich jak HTML, obrazy i inne, do formatu PDF, co może być szczególnie przydatne przy generowaniu dynamicznej treści w aplikacjach ASP.NET.

Czy IronPDF obsługuje bezpieczne przetwarzanie plików PDF w aplikacjach ASP.NET?

Tak, IronPDF obsługuje bezpieczną obsługę plików PDF, w tym szyfrowanie i ochronę hasłem, co pomaga w zabezpieczaniu poufnych informacji w aplikacjach ASP.NET.

Czy IronPDF można zintegrować z innymi produktami Iron Software w celu zwiększenia funkcjonalności?

Tak, IronPDF można zintegrować z innymi produktami Iron Software, takimi jak IronOCR i IronBarcode, aby zapewnić kompleksowe rozwiązania do zarządzania dokumentami i ich przetwarzania w aplikacjach ASP.NET.

Curtis Chau
Curtis Chau
  Czat z zespołem inżynierów teraz
Autor tekstów technicznych

Curtis Chau posiada tytuł licencjata z informatyki (Uniwersytet Carleton) i specjalizuje się w front-endowym rozwoju, z ekspertką w Node.js, TypeScript, JavaScript i React. Pasjonuje się tworzeniem intuicyjnych i estetycznie przyjemnych interfejsów użytkownika, Curtis cieszy się pracą z nowoczesnymi frameworkami i tworzeniem dobrze zorganizowanych, atrakcyjnych wizualnie podrę...

Czytaj więcej

Powiązane artykuły

30-dniowy okres próbny → Pełna wersja produktu. Bez ograniczeń. Bez karty. Bezpłatna próba

Zespol wsparcia Iron

Jestesmy online 24 godziny, 5 dni w tygodniu.
Czat
Email
Zadzwon do mnie