如何在ASP.NET Core中使用C#上傳和下載PDF文件

dotnet new mvc -n PdfManager --framework net10.0
cd PdfManager
dotnet add package IronPdf
dotnet add package Microsoft.EntityFrameworkCore.Sqlite
dotnet add package Microsoft.EntityFrameworkCore.Design

public class PdfFileModel
{
    public int Id { get; set; }
    public string FileName { get; set; } = string.Empty;
    public string ContentType { get; set; } = "application/pdf";
    public byte[] FileData { get; set; } = Array.Empty<byte>();
    public DateTime UploadedDate { get; set; } = DateTime.UtcNow;
}

Public Class PdfFileModel
    Public Property Id As Integer
    Public Property FileName As String = String.Empty
    Public Property ContentType As String = "application/pdf"
    Public Property FileData As Byte() = Array.Empty(Of Byte)()
    Public Property UploadedDate As DateTime = DateTime.UtcNow
End Class

using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;

public class PdfController : Controller
{
    private readonly ApplicationDbContext _context;

    public PdfController(ApplicationDbContext context)
    {
        _context = context;
    }

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

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

        using var stream = new MemoryStream();
        await file.CopyToAsync(stream);

        var pdfFile = new PdfFileModel
        {
            FileName = Path.GetFileName(file.FileName),
            ContentType = file.ContentType,
            FileData = stream.ToArray(),
            UploadedDate = DateTime.UtcNow
        };

        _context.PdfFiles.Add(pdfFile);
        await _context.SaveChangesAsync();

        return RedirectToAction(nameof(Index));
    }

    public async Task<IActionResult> Index()
    {
        var files = await _context.PdfFiles
            .Select(f => new { f.Id, f.FileName, f.UploadedDate })
            .ToListAsync();
        return View(files);
    }
}

Imports Microsoft.AspNetCore.Mvc
Imports Microsoft.EntityFrameworkCore
Imports System.IO
Imports System.Threading.Tasks

Public Class PdfController
    Inherits Controller

    Private ReadOnly _context As ApplicationDbContext

    Public Sub New(context As ApplicationDbContext)
        _context = context
    End Sub

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

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

        Using stream As New MemoryStream()
            Await file.CopyToAsync(stream)

            Dim pdfFile As New PdfFileModel With {
                .FileName = Path.GetFileName(file.FileName),
                .ContentType = file.ContentType,
                .FileData = stream.ToArray(),
                .UploadedDate = DateTime.UtcNow
            }

            _context.PdfFiles.Add(pdfFile)
            Await _context.SaveChangesAsync()
        End Using

        Return RedirectToAction(NameOf(Index))
    End Function

    Public Async Function Index() As Task(Of IActionResult)
        Dim files = Await _context.PdfFiles _
            .Select(Function(f) New With {f.Id, f.FileName, f.UploadedDate}) _
            .ToListAsync()
        Return View(files)
    End Function
End Class

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

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

    // Load the uploaded file into IronPDF
    var pdf = new IronPdf.PdfDocument(originalBytes);

    // Apply an HTML watermark centered on every page
    pdf.ApplyWatermark(
        "<h2 style='color:red;opacity:0.4'>CONFIDENTIAL</h2>",
        rotation: 45,
        opacity: 60,
        verticalAlignment: IronPdf.Editing.VerticalAlignment.Middle,
        horizontalAlignment: IronPdf.Editing.HorizontalAlignment.Center
    );

    var pdfFile = new PdfFileModel
    {
        FileName = Path.GetFileName(file.FileName),
        ContentType = "application/pdf",
        FileData = pdf.BinaryData,
        UploadedDate = DateTime.UtcNow
    };

    _context.PdfFiles.Add(pdfFile);
    await _context.SaveChangesAsync();

    return RedirectToAction(nameof(Index));
}

Imports System.IO
Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc

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

    Using stream As New MemoryStream()
        Await file.CopyToAsync(stream)
        Dim originalBytes As Byte() = stream.ToArray()

        ' Load the uploaded file into IronPDF
        Dim pdf = New IronPdf.PdfDocument(originalBytes)

        ' Apply an HTML watermark centered on every page
        pdf.ApplyWatermark(
            "<h2 style='color:red;opacity:0.4'>CONFIDENTIAL</h2>",
            rotation:=45,
            opacity:=60,
            verticalAlignment:=IronPdf.Editing.VerticalAlignment.Middle,
            horizontalAlignment:=IronPdf.Editing.HorizontalAlignment.Center
        )

        Dim pdfFile As New PdfFileModel With {
            .FileName = Path.GetFileName(file.FileName),
            .ContentType = "application/pdf",
            .FileData = pdf.BinaryData,
            .UploadedDate = DateTime.UtcNow
        }

        _context.PdfFiles.Add(pdfFile)
        Await _context.SaveChangesAsync()

        Return RedirectToAction(NameOf(Index))
    End Using
End Function

public async Task<IActionResult> Download(int id)
{
    var pdfFile = await _context.PdfFiles.FindAsync(id);

    if (pdfFile is null)
        return NotFound();

    return File(pdfFile.FileData, pdfFile.ContentType, pdfFile.FileName);
}

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

Public Async Function Download(id As Integer) As Task(Of IActionResult)
    Dim pdfFile = Await _context.PdfFiles.FindAsync(id)

    If pdfFile Is Nothing Then
        Return NotFound()
    End If

    Return File(pdfFile.FileData, pdfFile.ContentType, pdfFile.FileName)
End Function

public IActionResult GenerateInvoice(int orderId)
{
    // Build HTML content from your data model
    string html = $@"
        <html>
        <body style='font-family: Arial, sans-serif; padding: 40px;'>
            <h1>Invoice #{orderId}</h1>
            <p>Generated: {DateTime.UtcNow:yyyy-MM-dd HH:mm} UTC</p>
            <table border='1' cellpadding='8'>
                <tr><th>Item</th><th>Qty</th><th>Price</th></tr>
                <tr><td>IronPDF License</td><td>1</td><td>$749</td></tr>
            </table>
        </body>
        </html>";

    var renderer = new IronPdf.ChromePdfRenderer();
    using var pdf = renderer.RenderHtmlAsPdf(html);

    return File(pdf.BinaryData, "application/pdf", $"invoice-{orderId}.pdf");
}

Imports System
Imports Microsoft.AspNetCore.Mvc
Imports IronPdf

Public Class InvoiceController
    Inherits Controller

    Public Function GenerateInvoice(orderId As Integer) As IActionResult
        ' Build HTML content from your data model
        Dim html As String = $"
            <html>
            <body style='font-family: Arial, sans-serif; padding: 40px;'>
                <h1>Invoice #{orderId}</h1>
                <p>Generated: {DateTime.UtcNow:yyyy-MM-dd HH:mm} UTC</p>
                <table border='1' cellpadding='8'>
                    <tr><th>Item</th><th>Qty</th><th>Price</th></tr>
                    <tr><td>IronPDF License</td><td>1</td><td>$749</td></tr>
                </table>
            </body>
            </html>"

        Dim renderer As New ChromePdfRenderer()
        Using pdf = renderer.RenderHtmlAsPdf(html)
            Return File(pdf.BinaryData, "application/pdf", $"invoice-{orderId}.pdf")
        End Using
    End Function
End Class

public async Task<IActionResult> MergeAll()
{
    var allFiles = await _context.PdfFiles.ToListAsync();

    if (allFiles.Count < 2)
        return BadRequest("At least two files are required for merging.");

    var documents = allFiles
        .Select(f => new IronPdf.PdfDocument(f.FileData))
        .ToList();

    using var merged = IronPdf.PdfDocument.Merge(documents);

    return File(merged.BinaryData, "application/pdf", "merged.pdf");
}

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

Public Async Function MergeAll() As Task(Of IActionResult)
    Dim allFiles = Await _context.PdfFiles.ToListAsync()

    If allFiles.Count < 2 Then
        Return BadRequest("At least two files are required for merging.")
    End If

    Dim documents = allFiles _
        .Select(Function(f) New IronPdf.PdfDocument(f.FileData)) _
        .ToList()

    Using merged = IronPdf.PdfDocument.Merge(documents)
        Return File(merged.BinaryData, "application/pdf", "merged.pdf")
    End Using
End Function