Comment récupérer un fichier PDF à partir d'une base de données en ASP.NET à l'aide de C# et d'IronPDF

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

public async Task<IActionResult> RetrievePdfFromDatabase(int documentId, string connectionString)
{
    using var connection = new SqlConnection(connectionString);
    await connection.OpenAsync();
    var query = "SELECT FileName, FileContent FROM PdfDocuments WHERE Id = @Id";
    using var command = new SqlCommand(query, connection);
    command.Parameters.AddWithValue("@Id", documentId);
    using var reader = await command.ExecuteReaderAsync();
    if (reader.Read())
    {
        var fileName = reader["FileName"].ToString();
        var pdfBytes = (byte[])reader["FileContent"];
        var contentType = "application/pdf";
        return new FileContentResult(pdfBytes, contentType)
        {
            FileDownloadName = fileName
        };
    }
    return new NotFoundResult();
}

Imports IronPdf
Imports System.Data.SqlClient
Imports System.IO
Imports Microsoft.AspNetCore.Mvc

Public Async Function RetrievePdfFromDatabase(documentId As Integer, connectionString As String) As Task(Of IActionResult)
    Using connection As New SqlConnection(connectionString)
        Await connection.OpenAsync()
        Dim query As String = "SELECT FileName, FileContent FROM PdfDocuments WHERE Id = @Id"
        Using command As New SqlCommand(query, connection)
            command.Parameters.AddWithValue("@Id", documentId)
            Using reader As SqlDataReader = Await command.ExecuteReaderAsync()
                If reader.Read() Then
                    Dim fileName As String = reader("FileName").ToString()
                    Dim pdfBytes As Byte() = CType(reader("FileContent"), Byte())
                    Dim contentType As String = "application/pdf"
                    Return New FileContentResult(pdfBytes, contentType) With {
                        .FileDownloadName = fileName
                    }
                End If
            End Using
        End Using
    End Using
    Return New NotFoundResult()
End Function

return new FileContentResult(pdfBytes, "application/pdf");

Return New FileContentResult(pdfBytes, "application/pdf")

using IronPdf;
using Microsoft.AspNetCore.Mvc;
using System.Data.SqlClient;
using System;
using System.Threading.Tasks;

[ApiController]
[Route("api/[controller]")]
public class PdfController : ControllerBase
{
    private readonly string _connectionString;
    public PdfController(IConfiguration configuration)
    {
        _connectionString = configuration.GetConnectionString("DefaultConnection");
    }

    [HttpGet("{id}")]
    public async Task<IActionResult> GetPdf(int id)
    {
        try
        {
            // Retrieve PDF documents from database
            byte[] pdfBytes = await RetrievePdfFromDatabase(id);
            if (pdfBytes == null || pdfBytes.Length == 0)
                return NotFound();
            // Load the PDF document using IronPDF for potential modifications
            var pdfDocument = new PdfDocument(pdfBytes);
            // Return file for inline display in browser
            Response.Headers.Add("Content-Disposition", "inline");
            return File(pdfDocument.BinaryData, "application/pdf");
        }
        catch (Exception ex)
        {
            // Handle exception and log error details
            return StatusCode(500, "Error retrieving PDF file");
        }
    }

    private async Task<byte[]> RetrievePdfFromDatabase(int documentId)
    {
        using var connection = new SqlConnection(_connectionString);
        await connection.OpenAsync();
        var query = "SELECT FileContent FROM PdfDocuments WHERE Id = @Id";
        using var command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@Id", documentId);
        var result = await command.ExecuteScalarAsync();
        return result as byte[];
    }
}

Imports IronPdf
Imports Microsoft.AspNetCore.Mvc
Imports System.Data.SqlClient
Imports System
Imports System.Threading.Tasks

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

    Private ReadOnly _connectionString As String

    Public Sub New(configuration As IConfiguration)
        _connectionString = configuration.GetConnectionString("DefaultConnection")
    End Sub

    <HttpGet("{id}")>
    Public Async Function GetPdf(id As Integer) As Task(Of IActionResult)
        Try
            ' Retrieve PDF documents from database
            Dim pdfBytes As Byte() = Await RetrievePdfFromDatabase(id)
            If pdfBytes Is Nothing OrElse pdfBytes.Length = 0 Then
                Return NotFound()
            End If
            ' Load the PDF document using IronPDF for potential modifications
            Dim pdfDocument As New PdfDocument(pdfBytes)
            ' Return file for inline display in browser
            Response.Headers.Add("Content-Disposition", "inline")
            Return File(pdfDocument.BinaryData, "application/pdf")
        Catch ex As Exception
            ' Handle exception and log error details
            Return StatusCode(500, "Error retrieving PDF file")
        End Try
    End Function

    Private Async Function RetrievePdfFromDatabase(documentId As Integer) As Task(Of Byte())
        Using connection As New SqlConnection(_connectionString)
            Await connection.OpenAsync()
            Dim query As String = "SELECT FileContent FROM PdfDocuments WHERE Id = @Id"
            Using command As New SqlCommand(query, connection)
                command.Parameters.AddWithValue("@Id", documentId)
                Dim result = Await command.ExecuteScalarAsync()
                Return TryCast(result, Byte())
            End Using
        End Using
    End Function
End Class

[HttpGet("download/{id}")]
public async Task<IActionResult> DownloadPdf(int id)
{
    // Retrieve stored PDF file from database
    byte[] pdfBytes = await RetrievePdfFromDatabase(id);
    string fileName = await GetFileName(id);
    if (pdfBytes == null || pdfBytes.Length == 0)
        return NotFound("PDF file not found");
    // Load and validate PDF document
    var pdfDocument = new PdfDocument(pdfBytes);
    // Set content disposition for attachment download
    Response.Headers.Append("Content-Disposition", $"attachment; filename={fileName}");
    // Return file for download with default PDF content type
    return File(pdfDocument.BinaryData, "application/pdf", fileName);
}

private async Task<string> GetFileName(int documentId)
{
    using var connection = new SqlConnection(_connectionString);
    await connection.OpenAsync();
    // Query to retrieve PDF file name from database
    var query = "SELECT FileName FROM PdfDocuments WHERE Id = @Id";
    using var command = new SqlCommand(query, connection);
    command.Parameters.AddWithValue("@Id", documentId);
    var result = await command.ExecuteScalarAsync();
    return result as string ?? "document.pdf"; // Default filename if null
}

Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc
Imports System.Data.SqlClient

<HttpGet("download/{id}")>
Public Async Function DownloadPdf(id As Integer) As Task(Of IActionResult)
    ' Retrieve stored PDF file from database
    Dim pdfBytes As Byte() = Await RetrievePdfFromDatabase(id)
    Dim fileName As String = Await GetFileName(id)
    If pdfBytes Is Nothing OrElse pdfBytes.Length = 0 Then
        Return NotFound("PDF file not found")
    End If
    ' Load and validate PDF document
    Dim pdfDocument = New PdfDocument(pdfBytes)
    ' Set content disposition for attachment download
    Response.Headers.Append("Content-Disposition", $"attachment; filename={fileName}")
    ' Return file for download with default PDF content type
    Return File(pdfDocument.BinaryData, "application/pdf", fileName)
End Function

Private Async Function GetFileName(documentId As Integer) As Task(Of String)
    Using connection As New SqlConnection(_connectionString)
        Await connection.OpenAsync()
        ' Query to retrieve PDF file name from database
        Dim query As String = "SELECT FileName FROM PdfDocuments WHERE Id = @Id"
        Using command As New SqlCommand(query, connection)
            command.Parameters.AddWithValue("@Id", documentId)
            Dim result = Await command.ExecuteScalarAsync()
            Return If(TryCast(result, String), "document.pdf") ' Default filename if null
        End Using
    End Using
End Function

[HttpGet("watermarked/{id}")]
public async Task<IActionResult> GetWatermarkedPdf(int id)
{
    // Retrieve PDF file from database table
    byte[] pdfBytes = await RetrievePdfFromDatabase(id);
    if (pdfBytes == null || pdfBytes.Length == 0)
        return NotFound("Cannot retrieve PDF document");
    // Create new PdfDocument from stored byte array
    var pdfDocument = new PdfDocument(pdfBytes);
    // Add watermark to each page of the PDF document
    string watermarkHtml = "<h2 style='color:red; opacity:0.5'>CONFIDENTIAL</h2>";
    pdfDocument.ApplyWatermark(watermarkHtml, 30, VerticalAlignment.Middle, HorizontalAlignment.Center);
    // Write the modified PDF to response
    return File(pdfDocument.BinaryData, "application/pdf");
}

Imports Microsoft.AspNetCore.Mvc

<HttpGet("watermarked/{id}")>
Public Async Function GetWatermarkedPdf(id As Integer) As Task(Of IActionResult)
    ' Retrieve PDF file from database table
    Dim pdfBytes As Byte() = Await RetrievePdfFromDatabase(id)
    If pdfBytes Is Nothing OrElse pdfBytes.Length = 0 Then
        Return NotFound("Cannot retrieve PDF document")
    End If
    ' Create new PdfDocument from stored byte array
    Dim pdfDocument = New PdfDocument(pdfBytes)
    ' Add watermark to each page of the PDF document
    Dim watermarkHtml As String = "<h2 style='color:red; opacity:0.5'>CONFIDENTIAL</h2>"
    pdfDocument.ApplyWatermark(watermarkHtml, 30, VerticalAlignment.Middle, HorizontalAlignment.Center)
    ' Write the modified PDF to response
    Return File(pdfDocument.BinaryData, "application/pdf")
End Function