Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. IronPDF nutzen
  4. Abrufen von PDF-Dateien aus der Datenbank Apr .NET
IRONPDF NUTZEN

Wie man PDF-Dateien aus einer Datenbank in ASP.NET mit C# abruft

Curtis Chau
Curtis Chau
Aktualisiert:

Das Abrufen einer PDF-Datei aus einer Datenbank in ASP.NET mit C# erfordert drei Schritte: Abfrage der Datenbanktabelle nach der binären BLOB-Spalte, Laden der Bytes in ein PdfDocument-Objekt mit IronPDF und Rückgabe der Bytes an den Browser über eine FileContentResult- oder File()-Antwort. IronPDF kümmert sich um das Rendern, das Wasserzeichen und die Sicherheitsfunktionen, sodass Sie sich auf die Datenzugriffslogik konzentrieren können.

Wie installiert man IronPDF für ASP.NET?

Bevor Sie Code zum Abrufen von PDFs schreiben, fügen Sie IronPDF über den NuGet -Paketmanager zu Ihrem Projekt hinzu:

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

Nach der Installation müssen Sie Ihren Lizenzschlüssel in Program.cs oder appsettings.json eingeben, bevor Sie eine beliebige IronPDF Methode aufrufen:

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

IronPDF unterstützt .NET 10 , .NET 8, .NET 6 und .NET Framework 4.6.2+. Es funktioniert unter Windows, Linux und macOS, ohne dass zusätzliche Abhängigkeiten oder die Installation eines Headless-Browsers erforderlich sind. Eine kostenlose Testlizenz steht zur Verfügung.

Wie richtet man die SQL Server-Datenbanktabelle ein?

Am häufigsten werden PDF-Dateien als Binärdaten in einer SQL Server VARBINARY(MAX) Spalte gespeichert. Dadurch bleiben das Dokument und seine Metadaten in einer einzigen Tabelle zusammen, die Datensicherung wird vereinfacht und die Verwaltung von Dateisystempfaden vermieden.

Verwenden Sie das folgende SQL-Skript, um die Speichertabelle zu erstellen:

// SQL Server table definition (run this in SSMS or via EF migrations)
// CREATE TABLE PdfDocuments (
//     Id INT IDENTITY(1,1) PRIMARY KEY,
//     FileName NVARCHAR(255) NOT NULL,
//     FileContent VARBINARY(MAX) NOT NULL,
//     UploadedAt DATETIME2 DEFAULT GETUTCDATE()
// );
// SQL Server table definition (run this in SSMS or via EF migrations)
// CREATE TABLE PdfDocuments (
//     Id INT IDENTITY(1,1) PRIMARY KEY,
//     FileName NVARCHAR(255) NOT NULL,
//     FileContent VARBINARY(MAX) NOT NULL,
//     UploadedAt DATETIME2 DEFAULT GETUTCDATE()
// );
$vbLabelText   $csharpLabel

Sobald die Tabelle existiert, konfigurieren Sie die Verbindungszeichenfolge in appsettings.json:

// appsettings.json snippet (not C# -- shown as reference)
// "ConnectionStrings": {
//   "DefaultConnection": "Server=localhost;Database=PdfStorage;Integrated Security=True;"
// }
// appsettings.json snippet (not C# -- shown as reference)
// "ConnectionStrings": {
//   "DefaultConnection": "Server=localhost;Database=PdfStorage;Integrated Security=True;"
// }
' appsettings.json snippet (not VB.NET -- shown as reference)
' "ConnectionStrings": {
'   "DefaultConnection": "Server=localhost;Database=PdfStorage;Integrated Security=True;"
' }
$vbLabelText   $csharpLabel

Registrieren Sie die Verbindungszeichenfolge über Dependency Injection in Program.cs:

using Microsoft.Extensions.DependencyInjection;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();
builder.Services.AddSingleton<IConfiguration>(builder.Configuration);

IronPdf.License.LicenseKey = builder.Configuration["IronPdf:LicenseKey"];

var app = builder.Build();
app.MapControllers();
app.Run();
using Microsoft.Extensions.DependencyInjection;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();
builder.Services.AddSingleton<IConfiguration>(builder.Configuration);

IronPdf.License.LicenseKey = builder.Configuration["IronPdf:LicenseKey"];

var app = builder.Build();
app.MapControllers();
app.Run();
Imports Microsoft.Extensions.DependencyInjection

Dim builder = WebApplication.CreateBuilder(args)
builder.Services.AddControllers()
builder.Services.AddSingleton(Of IConfiguration)(builder.Configuration)

IronPdf.License.LicenseKey = builder.Configuration("IronPdf:LicenseKey")

Dim app = builder.Build()
app.MapControllers()
app.Run()
$vbLabelText   $csharpLabel

Wie ruft man in ASP.NET Core eine PDF-Datei von einem SQL Server ab?

Das Abrufmuster umfasst drei Schritte: eine Verbindung öffnen, eine parametrisierte SELECT-Abfrage ausführen und die Binärspalte in ein byte[] einlesen. IronPDF lädt dieses Array dann in ein PdfDocument Objekt zur optionalen Weiterverarbeitung, bevor es an den Client gestreamt wird.

Erstellung des API-Controllers

Erstellen Sie einen Controller, der GET-Endpunkte sowohl für die Inline-Anzeige als auch für den Dateidownload bereitstellt:

using IronPdf;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Data.SqlClient;

[ApiController]
[Route("api/[controller]")]
public class PdfController : ControllerBase
{
    private readonly string _connectionString;

    public PdfController(IConfiguration configuration)
    {
        _connectionString = configuration.GetConnectionString("DefaultConnection")
            ?? throw new InvalidOperationException("Connection string not found.");
    }

    [HttpGet("{id}")]
    public async Task<IActionResult> GetPdf(int id)
    {
        byte[] pdfBytes = await RetrievePdfBytesAsync(id);
        if (pdfBytes is null || pdfBytes.Length == 0)
            return NotFound("PDF document not found.");

        // Load into IronPDF for validation or optional modification
        using var pdfDocument = new PdfDocument(pdfBytes);

        // Inline display -- browser opens PDF viewer
        Response.Headers.Append("Content-Disposition", "inline; filename=\"document.pdf\"");
        return File(pdfDocument.BinaryData, "application/pdf");
    }

    private async Task<byte[]> RetrievePdfBytesAsync(int documentId)
    {
        await using var connection = new SqlConnection(_connectionString);
        await connection.OpenAsync();

        const string query = "SELECT FileContent FROM PdfDocuments WHERE Id = @Id";
        await using var command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@Id", documentId);

        var result = await command.ExecuteScalarAsync();
        return result as byte[] ?? Array.Empty<byte>();
    }
}
using IronPdf;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Data.SqlClient;

[ApiController]
[Route("api/[controller]")]
public class PdfController : ControllerBase
{
    private readonly string _connectionString;

    public PdfController(IConfiguration configuration)
    {
        _connectionString = configuration.GetConnectionString("DefaultConnection")
            ?? throw new InvalidOperationException("Connection string not found.");
    }

    [HttpGet("{id}")]
    public async Task<IActionResult> GetPdf(int id)
    {
        byte[] pdfBytes = await RetrievePdfBytesAsync(id);
        if (pdfBytes is null || pdfBytes.Length == 0)
            return NotFound("PDF document not found.");

        // Load into IronPDF for validation or optional modification
        using var pdfDocument = new PdfDocument(pdfBytes);

        // Inline display -- browser opens PDF viewer
        Response.Headers.Append("Content-Disposition", "inline; filename=\"document.pdf\"");
        return File(pdfDocument.BinaryData, "application/pdf");
    }

    private async Task<byte[]> RetrievePdfBytesAsync(int documentId)
    {
        await using var connection = new SqlConnection(_connectionString);
        await connection.OpenAsync();

        const string query = "SELECT FileContent FROM PdfDocuments WHERE Id = @Id";
        await using var command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@Id", documentId);

        var result = await command.ExecuteScalarAsync();
        return result as byte[] ?? Array.Empty<byte>();
    }
}
Imports IronPdf
Imports Microsoft.AspNetCore.Mvc
Imports Microsoft.Data.SqlClient

<ApiController>
<Route("api/[controller]")>
Public Class PdfController
    Inherits ControllerBase

    Private ReadOnly _connectionString As String

    Public Sub New(configuration As IConfiguration)
        _connectionString = configuration.GetConnectionString("DefaultConnection")
        If _connectionString Is Nothing Then
            Throw New InvalidOperationException("Connection string not found.")
        End If
    End Sub

    <HttpGet("{id}")>
    Public Async Function GetPdf(id As Integer) As Task(Of IActionResult)
        Dim pdfBytes As Byte() = Await RetrievePdfBytesAsync(id)
        If pdfBytes Is Nothing OrElse pdfBytes.Length = 0 Then
            Return NotFound("PDF document not found.")
        End If

        ' Load into IronPDF for validation or optional modification
        Using pdfDocument As New PdfDocument(pdfBytes)
            ' Inline display -- browser opens PDF viewer
            Response.Headers.Append("Content-Disposition", "inline; filename=""document.pdf""")
            Return File(pdfDocument.BinaryData, "application/pdf")
        End Using
    End Function

    Private Async Function RetrievePdfBytesAsync(documentId As Integer) As Task(Of Byte())
        Await Using connection As New SqlConnection(_connectionString)
            Await connection.OpenAsync()

            Const query As String = "SELECT FileContent FROM PdfDocuments WHERE Id = @Id"
            Await Using command As New SqlCommand(query, connection)
                command.Parameters.AddWithValue("@Id", documentId)

                Dim result = Await command.ExecuteScalarAsync()
                Return If(TryCast(result, Byte()), Array.Empty(Of Byte)())
            End Using
        End Using
    End Function
End Class
$vbLabelText   $csharpLabel

Dieser Controller verwendet parametrisierte Abfragen, um SQL-Injection zu verhindern und await using, um SqlConnection und SqlCommand korrekt zu entsorgen. Die Klasse PdfDocument validiert das Byte-Array und stellt die Eigenschaft BinaryData für das Streaming zur Verfügung.

Eine benannte Datei zum Herunterladen zurückgeben

Wenn Benutzer das Dokument speichern und nicht direkt anzeigen müssen, setzen Sie den Header Content-Disposition auf attachment und übergeben Sie den ursprünglichen Dateinamen:

[HttpGet("download/{id}")]
public async Task<IActionResult> DownloadPdf(int id)
{
    await using var connection = new SqlConnection(_connectionString);
    await connection.OpenAsync();

    const string query = "SELECT FileName, FileContent FROM PdfDocuments WHERE Id = @Id";
    await using var command = new SqlCommand(query, connection);
    command.Parameters.AddWithValue("@Id", documentId);

    await using var reader = await command.ExecuteReaderAsync();
    if (!await reader.ReadAsync())
        return NotFound("Document not found.");

    var fileName = reader.GetString(reader.GetOrdinal("FileName"));
    var pdfBytes = (byte[])reader["FileContent"];

    using var pdfDocument = new PdfDocument(pdfBytes);
    return File(pdfDocument.BinaryData, "application/pdf", fileName);
}
[HttpGet("download/{id}")]
public async Task<IActionResult> DownloadPdf(int id)
{
    await using var connection = new SqlConnection(_connectionString);
    await connection.OpenAsync();

    const string query = "SELECT FileName, FileContent FROM PdfDocuments WHERE Id = @Id";
    await using var command = new SqlCommand(query, connection);
    command.Parameters.AddWithValue("@Id", documentId);

    await using var reader = await command.ExecuteReaderAsync();
    if (!await reader.ReadAsync())
        return NotFound("Document not found.");

    var fileName = reader.GetString(reader.GetOrdinal("FileName"));
    var pdfBytes = (byte[])reader["FileContent"];

    using var pdfDocument = new PdfDocument(pdfBytes);
    return File(pdfDocument.BinaryData, "application/pdf", fileName);
}
Imports System.Data.SqlClient
Imports Microsoft.AspNetCore.Mvc

<HttpGet("download/{id}")>
Public Async Function DownloadPdf(id As Integer) As Task(Of IActionResult)
    Await Using connection As New SqlConnection(_connectionString)
        Await connection.OpenAsync()

        Const query As String = "SELECT FileName, FileContent FROM PdfDocuments WHERE Id = @Id"
        Await Using command As New SqlCommand(query, connection)
            command.Parameters.AddWithValue("@Id", id)

            Await Using reader As SqlDataReader = Await command.ExecuteReaderAsync()
                If Not Await reader.ReadAsync() Then
                    Return NotFound("Document not found.")
                End If

                Dim fileName As String = reader.GetString(reader.GetOrdinal("FileName"))
                Dim pdfBytes As Byte() = CType(reader("FileContent"), Byte())

                Using pdfDocument As New PdfDocument(pdfBytes)
                    Return File(pdfDocument.BinaryData, "application/pdf", fileName)
                End Using
            End Using
        End Using
    End Using
End Function
$vbLabelText   $csharpLabel

Wenn fileName als drittes Argument an File() übergeben wird, wird der Header Content-Disposition automatisch auf attachment gesetzt. ASP.NET Core sorgt für die korrekte Maskierung von Dateinamen, die Leerzeichen enthalten.

Wie fügt man einem abgerufenen PDF ein Wasserzeichen hinzu?

Eine der praktischsten Nachbearbeitungsmaßnahmen ist das Aufbringen eines Wasserzeichens auf jede Seite, bevor das Dokument zugestellt wird. Dies ist nützlich für vertrauliche Berichte, Dokumententwürfe oder jede Datei, die eine sichtbare Sicherheitskennzeichnung benötigt.

Anwenden eines HTML-Wasserzeichens mit IronPDF

Die Watermark-API von IronPDF akzeptiert beliebige HTML-Zeichenketten, was bedeutet, dass Sie den Wasserzeichentext mithilfe von Inline-CSS gestalten können. Stellen Sie die Deckkraft so niedrig ein, dass der darunterliegende Inhalt lesbar bleibt:

[HttpGet("watermarked/{id}")]
public async Task<IActionResult> GetWatermarkedPdf(int id)
{
    byte[] pdfBytes = await RetrievePdfBytesAsync(id);
    if (pdfBytes is null || pdfBytes.Length == 0)
        return NotFound("PDF document not found.");

    using var pdfDocument = new PdfDocument(pdfBytes);

    // HTML watermark applied to every page
    string watermarkHtml = "<h2 style='color:red; opacity:0.4; font-family:Arial;'>CONFIDENTIAL</h2>";
    pdfDocument.ApplyWatermark(
        watermarkHtml,
        rotation: 30,
        verticalAlignment: VerticalAlignment.Middle,
        horizontalAlignment: HorizontalAlignment.Center
    );

    return File(pdfDocument.BinaryData, "application/pdf");
}
[HttpGet("watermarked/{id}")]
public async Task<IActionResult> GetWatermarkedPdf(int id)
{
    byte[] pdfBytes = await RetrievePdfBytesAsync(id);
    if (pdfBytes is null || pdfBytes.Length == 0)
        return NotFound("PDF document not found.");

    using var pdfDocument = new PdfDocument(pdfBytes);

    // HTML watermark applied to every page
    string watermarkHtml = "<h2 style='color:red; opacity:0.4; font-family:Arial;'>CONFIDENTIAL</h2>";
    pdfDocument.ApplyWatermark(
        watermarkHtml,
        rotation: 30,
        verticalAlignment: VerticalAlignment.Middle,
        horizontalAlignment: HorizontalAlignment.Center
    );

    return File(pdfDocument.BinaryData, "application/pdf");
}
Imports Microsoft.AspNetCore.Mvc

<HttpGet("watermarked/{id}")>
Public Async Function GetWatermarkedPdf(id As Integer) As Task(Of IActionResult)
    Dim pdfBytes As Byte() = Await RetrievePdfBytesAsync(id)
    If pdfBytes Is Nothing OrElse pdfBytes.Length = 0 Then
        Return NotFound("PDF document not found.")
    End If

    Using pdfDocument As New PdfDocument(pdfBytes)
        ' HTML watermark applied to every page
        Dim watermarkHtml As String = "<h2 style='color:red; opacity:0.4; font-family:Arial;'>CONFIDENTIAL</h2>"
        pdfDocument.ApplyWatermark(
            watermarkHtml,
            rotation:=30,
            verticalAlignment:=VerticalAlignment.Middle,
            horizontalAlignment:=HorizontalAlignment.Center
        )

        Return File(pdfDocument.BinaryData, "application/pdf")
    End Using
End Function
$vbLabelText   $csharpLabel

Die Methode ApplyWatermark akzeptiert Standard-HTML und CSS, sodass Sie die volle Kontrolle über Schriftart, Farbe, Deckkraft und Position haben. Das Wasserzeichen wird automatisch auf alle Seiten des Dokuments angewendet. Weitere Funktionen zur PDF-Bearbeitung , wie das Einfügen von Stempeln in Bilder, das Hinzufügen von Kopf- und Fußzeilen oder das Zusammenführen mehrerer Dokumente, finden Sie in der IronPDF -Dokumentation.

Wie speichert man hochgeladene PDFs wieder in SQL Server?

Für den vollständigen Roundtrip wird ein Upload-Endpunkt benötigt, der eingehende Formulardateien liest und in die Datenbank schreibt. Dies bildet zusammen mit den oben genannten Abruf-Endpunkten ein vollständiges Dokumentenmanagementsystem:

[HttpPost("upload")]
public async Task<IActionResult> UploadPdf(IFormFile file)
{
    if (file is null || file.Length == 0)
        return BadRequest("No file uploaded.");

    if (!file.ContentType.Equals("application/pdf", StringComparison.OrdinalIgnoreCase))
        return BadRequest("Only PDF files are accepted.");

    using var memoryStream = new MemoryStream();
    await file.CopyToAsync(memoryStream);
    byte[] pdfBytes = memoryStream.ToArray();

    // Validate using IronPDF before storage
    using var pdfDocument = new PdfDocument(pdfBytes);

    await using var connection = new SqlConnection(_connectionString);
    await connection.OpenAsync();

    const string insertQuery = @"
        INSERT INTO PdfDocuments (FileName, FileContent)
        VALUES (@FileName, @FileContent);
        SELECT SCOPE_IDENTITY();";

    await using var command = new SqlCommand(insertQuery, connection);
    command.Parameters.AddWithValue("@FileName", file.FileName);
    command.Parameters.AddWithValue("@FileContent", pdfDocument.BinaryData);

    var newId = Convert.ToInt32(await command.ExecuteScalarAsync());
    return Ok(new { id = newId, fileName = file.FileName });
}
[HttpPost("upload")]
public async Task<IActionResult> UploadPdf(IFormFile file)
{
    if (file is null || file.Length == 0)
        return BadRequest("No file uploaded.");

    if (!file.ContentType.Equals("application/pdf", StringComparison.OrdinalIgnoreCase))
        return BadRequest("Only PDF files are accepted.");

    using var memoryStream = new MemoryStream();
    await file.CopyToAsync(memoryStream);
    byte[] pdfBytes = memoryStream.ToArray();

    // Validate using IronPDF before storage
    using var pdfDocument = new PdfDocument(pdfBytes);

    await using var connection = new SqlConnection(_connectionString);
    await connection.OpenAsync();

    const string insertQuery = @"
        INSERT INTO PdfDocuments (FileName, FileContent)
        VALUES (@FileName, @FileContent);
        SELECT SCOPE_IDENTITY();";

    await using var command = new SqlCommand(insertQuery, connection);
    command.Parameters.AddWithValue("@FileName", file.FileName);
    command.Parameters.AddWithValue("@FileContent", pdfDocument.BinaryData);

    var newId = Convert.ToInt32(await command.ExecuteScalarAsync());
    return Ok(new { id = newId, fileName = file.FileName });
}
Imports System
Imports System.IO
Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Http
Imports Microsoft.AspNetCore.Mvc
Imports System.Data.SqlClient
Imports IronPdf

<HttpPost("upload")>
Public Async Function UploadPdf(file As IFormFile) As Task(Of IActionResult)
    If file Is Nothing OrElse file.Length = 0 Then
        Return BadRequest("No file uploaded.")
    End If

    If Not file.ContentType.Equals("application/pdf", StringComparison.OrdinalIgnoreCase) Then
        Return BadRequest("Only PDF files are accepted.")
    End If

    Using memoryStream As New MemoryStream()
        Await file.CopyToAsync(memoryStream)
        Dim pdfBytes As Byte() = memoryStream.ToArray()

        ' Validate using IronPDF before storage
        Using pdfDocument As New PdfDocument(pdfBytes)

            Await Using connection As New SqlConnection(_connectionString)
                Await connection.OpenAsync()

                Const insertQuery As String = "
                    INSERT INTO PdfDocuments (FileName, FileContent)
                    VALUES (@FileName, @FileContent);
                    SELECT SCOPE_IDENTITY();"

                Await Using command As New SqlCommand(insertQuery, connection)
                    command.Parameters.AddWithValue("@FileName", file.FileName)
                    command.Parameters.AddWithValue("@FileContent", pdfDocument.BinaryData)

                    Dim newId As Integer = Convert.ToInt32(Await command.ExecuteScalarAsync())
                    Return Ok(New With {.id = newId, .fileName = file.FileName})
                End Using
            End Using
        End Using
    End Using
End Function
$vbLabelText   $csharpLabel

Die Verwendung von PdfDocument zur Validierung vor der Speicherung stellt sicher, dass nur lesbare, wohlgeformte PDF-Dateien in die Datenbank gelangen. Wenn das Byte-Array beschädigt oder abgeschnitten ist, löst IronPDF eine Ausnahme aus, die Sie abfangen und als 400 Bad Request Antwort zurückgeben können.

Welche Tabellen und Spaltentypen sind für die PDF-Speicherung am wichtigsten?

Das verwendete Schema beeinflusst die Abfrageleistung und die Speichereffizienz. Die folgende Tabelle zeigt die empfohlene Spaltenkonfiguration für SQL Server:

Empfohlenes SQL-Server-Schema für die Speicherung von PDF-BLOBs
Spalte Datentyp Zweck
Id INT IDENTITY Primärschlüssel, automatische Inkrementierung
FileName NVARCHAR(255) Originaler Dateiname für Download-Header
FileContent VARBINARY(MAX) Rohdaten im PDF-Format (BLOB)
ContentType NVARCHAR(100) MIME-Typ, z. B. application/pdf
FileSizeBytes BIGINT Gespeicherte Größe für die Quotenverwaltung
UploadedAt DATETIME2 UTC-Zeitstempel für die Prüfung
UploadedBy NVARCHAR(100) Benutzeridentität für die Zugriffskontrolle

Für große Systeme, in denen SQL Server File Streaming benötigt wird, dokumentiert Microsoft die FILESTREAM-Funktion als Alternative, die große BLOBs im Dateisystem speichert und gleichzeitig über T-SQL abfragbar bleibt. Für die meisten ASP.NET Anwendungen, die Dokumente bis zu einigen hundert Megabyte bereitstellen, funktioniert die In-Row-Speicherung jedoch gut und vereinfacht die Bereitstellung.

Wie gehen Sie mit Fehlern um und optimieren die Leistung?

Für einen zuverlässigen PDF-Abruf im Produktivbetrieb ist eine Fehlerbehandlung auf jeder Ebene erforderlich – Datenbank, IronPDF und HTTP-Antwort. Die folgende Tabelle fasst die wichtigsten Vorgehensweisen zusammen:

Fehlerbehandlung und Leistungsmuster beim PDF-Abruf
Sorge Empfehlung Grund
Anschlussentsorgung `await using` -Anweisungen Verhindert die Erschöpfung des Verbindungspools
PDF-Dokumentenentsorgung `using` -Anweisungen Gibt nicht verwalteten Speicher umgehend frei
SQL-Injection Nur parametrisierte Abfragen Verhindert, dass böswillige Eingaben Abfragen verändern.
Dateitypvalidierung MIME-Typ und Magic Bytes prüfen Blockiert Uploads von Nicht-PDF-Dateien vor der Speicherung
Verarbeitung großer Dateien Stream-Antwort mit `FileStreamResult` Vermeidet das Laden der gesamten Datei in den Serverspeicher.
Caching Verwenden Sie `IMemoryCache` oder `IDistributedCache` Reduziert wiederholte Datenbankabfragen
Asynchrone Operationen `async` / `await` durchgehend Hält Threads während Festplatten- und Netzwerkzugriffen frei

Für die Verwaltung von Verbindungszeichenfolgen speichern Sie den Wert in appsettings.json und kodieren Sie ihn niemals fest in den Quelldateien. Verwenden Sie während der lokalen Entwicklung die in ASP.NET Core integrierte Geheimnisverwaltung und im Produktionsbetrieb Azure Key Vault oder AWS Secrets Manager. Speichern Sie niemals Verbindungszeichenfolgen oder Lizenzschlüssel in der Quellcodeverwaltung.

Beim Ausliefern großer PDF-Dateien sollten Sie erwägen, ein FileStreamResult mit einem MemoryStream als Backup zurückzugeben, anstatt das gesamte Byte-Array in den Speicher zu laden. Für sehr große Dokumente – über 100 MB – ermöglicht die SQL Server FILESTREAM API das Streaming in Blöcken direkt aus dem Dateisystem.

Zwischenspeicherung häufig aufgerufener Dokumente

Wenn bestimmte PDF-Dateien wiederholt angefordert werden - zum Beispiel ein Dokument mit Allgemeinen Geschäftsbedingungen oder ein Produktkatalog - vermeidet das Zwischenspeichern des Byte-Arrays in IMemoryCache wiederholte Datenbankzugriffe. Registrieren Sie IMemoryCache in Program.cs mit builder.Services.AddMemoryCache(), injizieren Sie es dann in den Controller und überprüfen Sie den Cache, bevor Sie die Datenbank abfragen. Legen Sie ein absolutes Ablaufdatum fest, das der erwarteten Aktualisierungshäufigkeit der Dokumente entspricht. Wenn ein Dokument aktualisiert wird, wird der zwischengespeicherte Eintrag anhand des Schlüssels entfernt, damit die nächste Anfrage die neue Version abruft.

Für verteilte Szenarien - wie z. B. eine Load-Balancing-Bereitstellung mit mehreren Serverinstanzen - ersetzen Sie IMemoryCache durch IDistributedCache, unterstützt durch Redis oder SQL Server. Die Abstraktionen des verteilten Caches von ASP.NET Core sorgen dafür, dass der Controller-Code nahezu identisch bleibt; Es ändert sich lediglich die Registrierung in Program.cs.

Wie implementiert man die PDF-Abfrage plattformübergreifend mit IronPDF?

IronPDF läuft unter Linux, Windows und macOS, ohne dass eine separate Chromium-Installation oder Konfigurationsänderungen erforderlich sind. Das gleiche NuGet Paket ist für alle Plattformen geeignet, sodass Ihr PDF-Controller unabhängig von der verwendeten Plattform identisch funktioniert:

  • Windows Server mit IIS
  • Ubuntu-Container auf Docker oder Kubernetes
  • Azure App Service (Linux oder Windows)
  • AWS Elastic Beanstalk

Bereitstellung auf Docker und Linux

Für Docker-Bereitstellungen fügen Sie die IronPDF Abhängigkeiten zu Ihrer Dockerfile hinzu. Die IronPDF Linux-Dokumentation enthält die exakten apt-Pakete, die für Debian- und Alpine-Basisimages benötigt werden. Ein typisches mehrstufiges Dockerfile installiert die Betriebssystemabhängigkeiten in der Laufzeit-Image-Phase und kopiert anschließend die veröffentlichte ASP.NET Anwendung darüber. Bei Verwendung von Azure beschreibt der Azure-Bereitstellungsleitfaden die App Service-Konfiguration, einschließlich der Speicher- und CPU-Einstellungen, die das PDF-Rendering in großem Umfang unterstützen.

Da IronPDF eine eigene, auf Chromium basierende Rendering-Engine mitbringt, ist die Installation eines separaten Browsers auf dem Server nicht erforderlich. Dies vereinfacht die Einrichtung von Linux-Containern erheblich im Vergleich zu Lösungen, die einen systemweiten Browser erfordern. Das IronPDF Team testet jede neue Version anhand der gängigsten Linux-Basis-Images, sodass Sie darauf vertrauen können, dass ein Alpine- oder Debian-Container sofort funktioniert.

Verwendung von Entity Framework Core anstelle von ADO .NET

IronPDF integriert sich auch mit Entity Framework Core als Alternative zu reinem ADO .NET. Wenn Ihr Projekt bereits EF Core verwendet, können Sie die Spalte FileContent einer Eigenschaft byte[] einer Modellklasse zuordnen und die Abfragegenerierung von EF übernehmen lassen. Dieser Ansatz reduziert den Boilerplate-Code erheblich und erleichtert das Hinzufügen von Filter-, Paginierungs- und Prüffunktionen über den LINQ-Provider von EF.

Der Kompromiss besteht darin, dass EF Core den gesamten BLOB als Teil des Entitätsgraphen in den Speicher lädt. Bei sehr großen PDF-Dateien empfiehlt sich die Verwendung der Methode FromSql von ADO .NET oder EF Core mit einer Projektion, die nur die Byte-Array-Spalte und nicht die gesamte Entität auswählt.

Was sind Ihre nächsten Schritte?

Das Abrufen von PDF-Dateien aus einer SQL Server-Datenbank in ASP.NET Core mit C# und IronPDF folgt einem klaren Muster: Die BLOB-Spalte wird mit einem parametrisierten SELECT abgefragt, die Bytes werden in einen PdfDocument geladen und die Binärdaten werden mit dem korrekten Content-Disposition-Header zurückgegeben. IronPDF bietet die Möglichkeit, Dokumente zu validieren, mit einem Wasserzeichen zu versehen, zusammenzuführen oder zu sichern, bevor sie Ihren Server verlassen.

Um die Dokumentenverwaltungsfunktionen von IronPDF noch besser kennenzulernen, sollten Sie folgende Ressourcen nutzen:

Starten Sie mit einer kostenlosen IronPDF -Testlizenz, um alle Funktionen uneingeschränkt zu testen. Die Testversion erzeugt Ausgaben mit Wasserzeichen; Das Wasserzeichen lässt sich durch Anwenden eines kostenpflichtigen Lizenzschlüssels entfernen. Die vollständige API-Referenzdokumentation und Codebeispiele für jede in diesem Artikel verwendete Methode sind auf der IronPDF -Website verfügbar.

Wenn Ihr Projekt bereits Entity Framework Core verwendet, zeigt Ihnen der IronPDF Leitfaden zur EF-Core-Integration, wie Sie rohes .NET durch Entitätsmodelle ersetzen und dabei die bestehende IronPDF -Verarbeitungspipeline beibehalten. Für Teams, die mit .NET 10 und den neuesten ASP.NET Core -Funktionen arbeiten, funktionieren die hier beschriebenen Muster ohne Änderungen – IronPDF unterstützt alle aktiven .NET LTS- und STS-Versionen.

Auf der IronPDF -Preisseite finden Sie die passende Lizenzstufe für Ihre Anwendung. Eine einzelne Entwicklerlizenz deckt die lokale Entwicklung und das Testen ab; Weiterverteilungslizenzen sind für SaaS-Produkte und lokale Installationen mit mehreren Servern erhältlich.

Häufig gestellte Fragen

Was ist IronPDF?

IronPDF ist eine .NET-Bibliothek, mit der Entwickler in C#-Anwendungen PDF-Dateien erstellen, bearbeiten und Inhalte daraus extrahieren können.

Wie kann ich mit ASP.NET eine PDF-Datei aus einer Datenbank abrufen?

Um eine PDF-Datei aus einer Datenbank in ASP.NET abzurufen, können Sie C#-Code verwenden, um die Datenbank abzufragen und die PDF-Daten in ein Byte-Array zu lesen. Dieses Byte-Array kann dann mit IronPDF verwendet werden, um die PDF-Datei je nach Bedarf zu rendern oder zu manipulieren.

Warum sollte ich IronPDF für die Verarbeitung von PDFs in meiner ASP.NET-Anwendung verwenden?

IronPDF bietet eine breite Palette an Funktionen zur Verarbeitung von PDFs, einschließlich PDF-Erstellung, Konvertierung aus HTML und Manipulation. Es integriert sich mit ASP.NET und bietet eine benutzerfreundliche API für die Arbeit mit PDFs.

Was sind die Voraussetzungen für die Verwendung von IronPDF in ASP.NET?

Um IronPDF in ASP.NET zu verwenden, müssen Sie eine .NET-Entwicklungsumgebung wie Visual Studio einrichten und die IronPDF-Bibliothek über den NuGet-Paketmanager in Ihr Projekt aufnehmen.

Kann IronPDF zur Bearbeitung vorhandener PDF-Dateien verwendet werden?

Ja, IronPDF kann zur Bearbeitung bestehender PDF-Dateien verwendet werden. Es ermöglicht Änderungen wie das Hinzufügen von Text oder Bildern, das Zusammenführen von Dokumenten und mehr.

Ist es möglich, HTML mit IronPDF in PDF zu konvertieren?

Ja, IronPDF kann HTML-Inhalte direkt in das PDF-Format konvertieren, so dass es einfach ist, PDFs aus Webseiten oder anderen HTML-Inhalten zu erzeugen.

Wie verwende ich die PDF-Sicherheitsfunktionen von IronPDF?

IronPDF unterstützt verschiedene Sicherheitsfunktionen für PDFs, darunter Passwortschutz und das Festlegen von Berechtigungen, um den Zugriff auf Dokumente und deren Bearbeitung zu kontrollieren.

Welche Arten von Datenbanken sind mit IronPDF für den PDF-Abruf kompatibel?

IronPDF kann mit jeder Datenbank arbeiten, die binäre Daten speichern kann, wie SQL Server, MySQL oder PostgreSQL, um PDF-Dateien abzurufen und zu bearbeiten.

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