Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. IronPDF nutzen
  4. Hochladen Herunterladen von PDF-Dateien Asp .NET
IRONPDF NUTZEN

Wie man PDF-Dateien in ASP.NET Core mit C# hochlädt und herunterlädt

Curtis Chau
Curtis Chau
Aktualisiert:

Das Hoch- und Herunterladen von PDF-Dateien in ASP.NET Core erfordert die Verarbeitung von Binärdaten, die Verwaltung von Controller-Aktionen und -- optional - die serverseitige Verarbeitung der Dokumente vor der Speicherung oder Zustellung. Mit IronPDF können Sie über die einfache Dateispeicherung hinausgehen, indem Sie Wasserzeichen hinzufügen, PDFs aus HTML generieren und die verarbeiteten Dokumente an die Benutzer zurückgeben – alles innerhalb Ihrer bestehenden MVC-Pipeline. Diese Anleitung führt Sie Schritt für Schritt durch die Erstellung eines vollständigen Upload-Download-Workflows in C# mit .NET 10.

Wie installiert man IronPDF in einem ASP.NET Core -Projekt?

Bevor Sie eine Upload- oder Download-Logik schreiben, fügen Sie IronPDF mithilfe des NuGet -Paketmanagers oder der .NET Befehlszeilenschnittstelle zu Ihrem Projekt hinzu. Verwenden Sie Install-Package IronPdf in der Paketverwaltungskonsole, oder führen Sie die unten aufgeführten CLI-Befehle aus, um ein neues MVC-Projekt zu erstellen und alle erforderlichen Pakete auf einmal hinzuzufügen.

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

Nach der Installation bietet IronPDF Zugriff auf ChromePdfRenderer zum Erzeugen von PDFs aus HTML, PdfDocument zum Laden und Bearbeiten vorhandener Dateien und eine Reihe von Bearbeitungswerkzeugen wie Wasserzeichen, Stempel und digitale Signaturen. Auf der vollständigen NuGet-Paketseite von IronPDF finden Sie die Versionshistorie und Hinweise zur Kompatibilität.

Einrichten des Projekts

Fügen Sie eine Speicherpfadkonstante zu Program.cs hinzu und registrieren Sie Ihren ApplicationDbContext mit dem Dependency Injection Container. Ihre Projektstruktur wird einen Controllers/PdfController.cs, einen Models/PdfFileModel.cs und einen Data/ApplicationDbContext.cs enthalten, bevor Sie eine PDF-spezifische Logik schreiben.

Wie erstellt man ein Datenbankmodell für die PDF-Speicherung?

Grundlage jedes PDF-Upload-Systems ist eine Modellklasse, die einer Datenbanktabelle zugeordnet ist. Der folgende C#-Datensatz erfasst die wichtigsten Felder – Dateiname, Inhaltstyp, die rohen Binärdaten und einen Upload-Zeitstempel.

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 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
$vbLabelText   $csharpLabel

FileData speichert das PDF als binäres großes Objekt (BLOB). Durch diesen Ansatz bleiben die Dokumente in der Datenbank in sich abgeschlossen, was die Datensicherung vereinfacht und Abfragen unkomplizierter macht. Bei hohem Datenaufkommen oder großen Dateien empfiehlt es sich, nur den Dateipfad in der Datenbank zu speichern und die Binärdatei in einem Cloud-Speicher wie Azure Blob Storage oder Amazon S3 zu speichern.

Konfigurieren von Entity Framework Core

Registrieren Sie das Modell bei EF Core, indem Sie eine DbSet<PdfFileModel> Eigenschaft zu Ihrem ApplicationDbContext hinzufügen:

using Microsoft.EntityFrameworkCore;

public class ApplicationDbContext : DbContext
{
    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
        : base(options) { }

    public DbSet<PdfFileModel> PdfFiles { get; set; }
}
using Microsoft.EntityFrameworkCore;

public class ApplicationDbContext : DbContext
{
    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
        : base(options) { }

    public DbSet<PdfFileModel> PdfFiles { get; set; }
}
Imports Microsoft.EntityFrameworkCore

Public Class ApplicationDbContext
    Inherits DbContext

    Public Sub New(options As DbContextOptions(Of ApplicationDbContext))
        MyBase.New(options)
    End Sub

    Public Property PdfFiles As DbSet(Of PdfFileModel)
End Class
$vbLabelText   $csharpLabel

Führen Sie dotnet ef migrations add InitialCreate gefolgt von dotnet ef database update aus, um das Schema zu erstellen. Entity Framework Core ordnet byte[] automatisch einer varbinary(max)-Spalte in SQL Server oder einer BLOB-Spalte in SQLite zu - es ist kein manuelles SQL erforderlich.

Wie lädt man PDF-Dateien in einen ASP.NET Core -Controller hoch?

Die Controller-Aktion, die Uploads verarbeitet, erhält einen IFormFile Parameter von einem HTML-Formular mit enctype="multipart/form-data". Die Aktion liest den Stream in ein MemoryStream, konvertiert ihn in ein Byte-Array und persistiert das Ergebnis durch Entity Framework Core.

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);
    }
}
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
$vbLabelText   $csharpLabel

Überprüfung der hochgeladenen Dateien

Vor der Verarbeitung muss stets der Inhaltstyp überprüft werden. Die Überprüfung von file.ContentType verhindert, dass Benutzer versehentlich Nicht-PDF-Inhalte hochladen. Zur genaueren Überprüfung lesen Sie die ersten vier Bytes des Datenstroms und überprüfen Sie die magische PDF-Zahl (%PDF). Sie sollten auch eine maximale Dateigröße durchsetzen - typischerweise 10 MB für allgemeine Dokumenten-Workflows - indem Sie file.Length vor dem Kopieren des Streams überprüfen.

Das HTML-Formular, das diese Aktion auslöst, benötigt zwei Attribute: method="post" und enctype="multipart/form-data". Ohne Angabe des Kodierungstyps senden Browser den Dateinamen als Klartext anstatt des Binärinhalts. Fügen Sie ein <input type="file" name="file" accept=".pdf" /> Element und einen Submit-Button innerhalb des Form-Tags ein, der auf /Pdf/Upload zeigt.

How to Upload and Download PDF Files in ASP .NET C# with IronPDF: Bild 1 - UI zeigt die hochgeladene PDF-Datei

Wie fügt man einem hochgeladenen PDF vor dem Speichern ein Wasserzeichen hinzu?

Die serverseitige Verarbeitung von Dateien vor der Speicherung ist eine der praktischsten Anwendungen für die Wasserzeichenfunktionen von IronPDF . Sie können jedes eingehende Dokument mit einem "VERTRAULICH"-Etikett, einem Firmenlogo oder einem "ENTWURF"-Hinweis versehen, bevor die Bytes überhaupt die Datenbank erreichen.

[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));
}
[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
$vbLabelText   $csharpLabel

Optionen zur Konfiguration des Wasserzeichens

Die ApplyWatermark-Methode von IronPDF akzeptiert eine HTML-Zeichenkette, was bedeutet, dass Ihr Wasserzeichen jedes gültige HTML und Inline-CSS enthalten kann - Farbverläufe, benutzerdefinierte Schriftarten, gedrehten Text oder sogar eingebettete SVG-Symbole. Der Parameter rotation dreht das Wasserzeichen über die Seitendiagonale, während opacity die Transparenz von 0 (unsichtbar) bis 100 (völlig undurchsichtig) steuert.

Neben Wasserzeichen bietet das gleiche PdfDocument-Objekt Methoden für Kopf- und Fußzeilen hinzufügen, Bilder stempeln und Bearbeiten bestehender Formularfelder. Sie können mehrere Verarbeitungsschritte verketten, bevor Sie pdf.BinaryData aufrufen, um das endgültige Byte-Array abzurufen.

How to Upload and Download PDF Files in ASP .NET C# with IronPDF: Bild 2 - PDF mit Wasserzeichen versehen und dann in der Datenbank gespeichert

Wie lädt man in der Datenbank gespeicherte PDF-Dateien herunter?

Um eine gespeicherte PDF-Datei an den Browser zurückzugeben, rufen Sie den Datensatz anhand der ID ab und geben einen FileResult zurück. Die ASP.NET Core File-Hilfsmethode setzt den korrekten Content-Type-Header und löst den Download-Dialog des Browsers mit dem ursprünglichen Dateinamen aus.

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);
}
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
$vbLabelText   $csharpLabel

Anzeigen einer Downloadliste in der Ansicht

Die Aktion Index ruft alle gespeicherten Dateidatensätze ab und übergibt sie an eine Razor-Ansicht. Eine einfache HTML-Tabelle zeigt für jeden Datensatz den Dateinamen, das Upload-Datum und einen Download-Anker an.

<table class="content__data-table" data-content-table>
    <caption>Uploaded PDF Files</caption>
    <thead>
        <tr>
            <th>File Name</th>
            <th>Uploaded</th>
            <th>Action</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var item in Model)
        {
            <tr>
                <td>@item.FileName</td>
                <td>@item.UploadedDate.ToString("yyyy-MM-dd HH:mm")</td>
                <td><a href="/Pdf/Download/@item.Id">Download</a></td>
            </tr>
        }
    </tbody>
</table>
<table class="content__data-table" data-content-table>
    <caption>Uploaded PDF Files</caption>
    <thead>
        <tr>
            <th>File Name</th>
            <th>Uploaded</th>
            <th>Action</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var item in Model)
        {
            <tr>
                <td>@item.FileName</td>
                <td>@item.UploadedDate.ToString("yyyy-MM-dd HH:mm")</td>
                <td><a href="/Pdf/Download/@item.Id">Download</a></td>
            </tr>
        }
    </tbody>
</table>
$vbLabelText   $csharpLabel

Die Überladung return File(bytes, contentType, fileName) setzt sowohl Content-Type: application/pdf als auch Content-Disposition: attachment; Dateiname=&quot;...&quot; Header. Wenn Sie möchten, dass der Browser die PDF-Datei inline öffnet, anstatt einen Download anzufordern, verwenden Sie return File(bytes, contentType) ohne das dritte Argument - dadurch entfällt die Anweisung Content-Disposition: attachment.

How to Upload and Download PDF Files in ASP .NET C# with IronPDF: Bild 3 - Liste der gespeicherten PDF-Dateien

Dateisystemspeicher als Alternative

Bei großen Installationen führt das Speichern von rohen Binärdaten in der Datenbank zu größeren Zeilengrößen und kann Abfragen verlangsamen. Eine Alternative besteht darin, die Datei in ein Verzeichnis auf der Festplatte oder bei einem Cloud-Anbieter zu schreiben und nur den relativen Pfad in der Datenbank zu speichern. Ersetzen Sie FileData byte[] durch FilePath string, schreiben Sie System.IO.File.WriteAllBytesAsync(path, bytes) beim Upload und lesen Sie System.IO.File.ReadAllBytesAsync(path) beim Download. Beide Pfade laufen auf denselben return File(...)-Aufruf im Controller zu.

Wie generiert man PDF-Dokumente auf Abruf und stellt sie zum Download bereit?

Sie sind nicht auf die Bereitstellung vorab gespeicherter Dateien beschränkt. Mit der HTML-zu-PDF-Konvertierung von IronPDF können Sie Dokumente dynamisch aus Daten zum Zeitpunkt der Anfrage generieren – nützlich für Rechnungen, Berichte, Zertifikate und Datenexporte.

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");
}
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
$vbLabelText   $csharpLabel

Rendering-Optionen für On-Demand-PDFs

ChromePdfRenderer erzeugt eine pixelgenaue Ausgabe mit der gleichen Chromium-Rendering-Engine, die auch in Google Chrome zum Einsatz kommt. Das bedeutet, dass jegliches CSS, das Sie in einem Browser anzeigen können – Flexbox-Layouts, Raster, benutzerdefinierte Schriftarten, SVG-Diagramme – im generierten PDF korrekt gerendert wird. Sie können Papiergröße, Ränder und Ausrichtung über die Eigenschaft RenderingOptions einstellen, bevor Sie RenderHtmlAsPdf aufrufen.

Für komplexere Dokumente übergeben Sie bitte eine vollständige URL an RenderUrlAsPdf anstelle eines HTML-Strings. IronPDF lädt die Seite in einem Headless-Browser, führt JavaScript aus, wendet Stile an und konvertiert das vollständig gerenderte DOM in PDF. Im Leitfaden zur HTML-zu-PDF-Konvertierung finden Sie alle Rendering-Optionen, einschließlich benutzerdefinierter Kopf- und Fußzeilen sowie Seitennummerierungs-Tokens.

How to Upload and Download PDF Files in ASP .NET C# with IronPDF: Bild 4 - Generiertes Beispiel-PDF

Wie führt man mehrere PDF-Dateien in ASP.NET Core zusammen?

Über die Bearbeitung einzelner Dateien hinaus kann es erforderlich sein, mehrere hochgeladene Dokumente zu einem einzigen Dokument zusammenzufassen. IronPDFs PDF-Zusammenführungsfunktion akzeptiert eine Liste von PdfDocument-Objekten und gibt eine einzelne zusammengeführte Datei zurück.

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");
}
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
$vbLabelText   $csharpLabel

Seiten aus einer PDF-Datei extrahieren

Für den umgekehrten Vorgang - das Extrahieren einer Teilmenge von Seiten - wird CopyPages verwendet. Laden Sie einen PdfDocument aus den gespeicherten Bytes, rufen Sie source.CopyPages(startIndex, endIndex) mit null-basierten Seitenindizes auf, und geben Sie den resultierenden PdfDocument.BinaryData als FileResult zurück. Dieses Muster eignet sich für Seitenansichtsvorschauen, das Aufteilen von mehrteiligen Berichten oder das Extrahieren einer Titelseite zur Erstellung von Miniaturansichten. Sie können die zusammengeführte oder aufgeteilte Ausgabe auch mit digitalen Signaturen versehen, bevor Sie sie den Benutzern bereitstellen.

Wie handhabt man das Hochladen großer Dateien auf sichere Weise?

Große PDF-Dateien erfordern zusätzliche Konfigurationen auf der ASP.NET Core Middleware-Ebene. Standardmäßig ist die maximale Größe des Anfragetextes auf etwa 28 MB festgelegt. Um sie zu erhöhen, rufen Sie builder.Services.Configure<FormOptions> auf, um MultipartBodyLengthLimit und builder.WebHost.ConfigureKestrel auf Limits.MaxRequestBodySize zu setzen -- beide auf die gewünschte Byteanzahl, wie 50 * 1024 * 1024 für 50 MB -- in Program.cs vor builder.Build().

Abgesehen von den Größenbeschränkungen sollten Sie diese Sicherheitspraktiken auf jeden Upload-Endpunkt anwenden: Validieren Sie den Header des Inhaltstyps, prüfen Sie die ersten Bytes des Datenstroms auf die magische Zahl %PDF, scannen Sie mit der IronPDF-API zur Dokumentenprüfung nach eingebetteten Skripten und speichern Sie verarbeitete Dateien außerhalb des Web-Root, damit sie nie direkt als statische Inhalte bereitgestellt werden. Die Sicherheitsdokumentation von ASP.NET Core umfasst zusätzliche Härtungstechniken, darunter die Validierung von Antifälschungstoken und die Integration von Virenscans.

Streaming großer Dateien zur Vermeidung von Speicherengpässen

Wenn Dateien größer als 10 MB sind, kann das Lesen des gesamten Datenstroms in einen MemoryStream vor der Verarbeitung den Speicherverbrauch erheblich steigern. Verwenden Sie IronPdf.PdfDocument.FromStream, um nach Möglichkeit direkt aus dem Anforderungsstrom zu laden, oder schreiben Sie in einen temporären Dateipfad und laden Sie von der Festplatte:

string tempPath = Path.GetTempFileName();
await using (var fs = System.IO.File.Create(tempPath))
{
    await file.CopyToAsync(fs);
}

using var pdf = new IronPdf.PdfDocument(tempPath);
// process...
System.IO.File.Delete(tempPath);
string tempPath = Path.GetTempFileName();
await using (var fs = System.IO.File.Create(tempPath))
{
    await file.CopyToAsync(fs);
}

using var pdf = new IronPdf.PdfDocument(tempPath);
// process...
System.IO.File.Delete(tempPath);
Imports System.IO
Imports IronPdf

Dim tempPath As String = Path.GetTempFileName()

Using fs As FileStream = System.IO.File.Create(tempPath)
    Await file.CopyToAsync(fs)
End Using

Using pdf As PdfDocument = New IronPdf.PdfDocument(tempPath)
    ' process...
End Using

System.IO.File.Delete(tempPath)
$vbLabelText   $csharpLabel

Dieses Muster hält die Heap-Speicherbelegung gering und eignet sich gut für Hintergrundverarbeitungswarteschlangen, bei denen Dateien asynchron verarbeitet werden, nachdem die HTTP-Antwort bereits gesendet wurde. Weitere Muster für die asynchrone Verarbeitung finden Sie in der IronPDF -Dokumentation .

Was sind Ihre nächsten Schritte?

Sie verfügen nun über eine vollständige Grundlage für das Hochladen, Verarbeiten, Speichern und Herunterladen von PDF-Dateien in einer ASP.NET Core MVC-Anwendung, die auf IronPDF basiert. Berücksichtigen Sie von hier aus die folgenden Anweisungen, um den Arbeitsablauf zu erweitern.

Erweitern Sie die Verarbeitungsmöglichkeiten. IronPDF unterstützt das Ausfüllen und Lesen von PDF-Formularfeldern , das Extrahieren von Text und Bildern mit der PDF-Textextraktions-API sowie das Konvertieren von PDF-Seiten in Bilder für Miniaturansichten. Alle diese Funktionen sind in das oben gezeigte Controller-Muster integriert.

Fügen Sie digitale Signaturen hinzu. Signieren Sie jedes generierte oder hochgeladene Dokument vor dem Speichern mit einer digitalen Signatur unter Verwendung eines X.509-Zertifikats. Signierte PDFs enthalten manipulationssichere Metadaten, die viele Compliance-Anforderungen erfüllen.

Scale storage to the cloud. Ersetzen Sie die lokale byte[] Datenbankspalte durch eine Azure Blob Storage oder Amazon S3 Referenz. Laden Sie die verarbeiteten Bytes nach dem Hinzufügen eines Wasserzeichens in den Cloud-Speicher hoch und speichern Sie nur die URI in der Datenbank – dies reduziert die Größe der Datenbankzeilen drastisch und ermöglicht die CDN-Auslieferung.

Starten Sie eine kostenlose Testphase. Besuchen Sie die IronPDF Testlizenzseite, um einen 30-Tage-Testschlüssel mit vollem Funktionsumfang zu erhalten. Sie können auch die vollständige Funktionsübersicht von IronPDF durchstöbern, um den vollen Umfang der in Ihrer .NET Anwendung verfügbaren PDF-Funktionen zu verstehen, oder die Seite zu Preisen und Lizenzen konsultieren, wenn Sie für die Produktionsbereitstellung bereit sind.

Häufig gestellte Fragen

Wie kann ich PDF-Dateien in eine ASP.NET Core MVC-Anwendung hochladen?

Um PDF-Dateien in eine ASP.NET Core MVC-Anwendung hochzuladen, können Sie die IFormFile-Schnittstelle verwenden, um Dateidaten aus einem Formular zu erfassen und sie dann vor dem Speichern serverseitig zu verarbeiten, möglicherweise mit Hilfe von IronPDF zur weiteren PDF-Bearbeitung.

Wie kann ich PDF-Dateien in ASP.NET am besten herunterladen?

Der beste Weg, PDF-Dateien in ASP.NET herunterzuladen, ist die Verwendung der FileResult-Aktion in Ihrem Controller. IronPDF kann bei der serverseitigen Generierung und Modifizierung von PDFs helfen, um sicherzustellen, dass sie zum Download bereit sind.

Kann ich mit ASP.NET PDF-Dateien in einer Datenbank speichern?

Ja, Sie können PDF-Dateien mit ASP.NET in einer Datenbank speichern, indem Sie die Datei in ein Byte-Array konvertieren und als Binary Large Object (BLOB) speichern. IronPDF kann bei der Verarbeitung der PDF-Datei vor der Speicherung helfen.

Wie hilft IronPDF bei der Erstellung von Wasserzeichen in PDFs in ASP.NET?

IronPDF bietet Funktionen zum einfachen Hinzufügen von Text- oder Bild-Wasserzeichen zu PDFs, die in Ihre ASP.NET-Anwendung integriert werden können, um Dokumente vor dem Herunterladen oder Speichern zu ändern.

Was sind die Vorteile der Verwendung von EF Core für die PDF-Speicherung?

EF Core ermöglicht ein effizientes objektrelationales Mapping, das die strukturierte und skalierbare Verwaltung der Speicherung und des Abrufs von PDF-Dateien in Ihrer ASP.NET-Anwendung erleichtert.

Ist es möglich, PDF-Inhalte in ASP.NET-Anwendungen zu bearbeiten?

Ja, mit IronPDF können Sie PDF-Inhalte manipulieren, einschließlich der Bearbeitung von Text, Bildern und Metadaten, was für die Anpassung von Dokumenten nützlich sein kann, bevor sie den Benutzern zur Verfügung gestellt werden.

Wie kann ich Datei-Uploads in ASP.NET sicher handhaben?

Um Datei-Uploads in ASP.NET sicher zu handhaben, sollten Sie die Dateitypen validieren, die Dateigrößen begrenzen und die Dateien an sicheren Orten speichern. Die Verwendung von Bibliotheken wie IronPDF kann auch dazu beitragen, die Integrität der PDF-Dateien selbst zu gewährleisten.

Was sind die häufigsten Herausforderungen bei der Arbeit mit PDFs in Webanwendungen?

Zu den häufigsten Herausforderungen gehören die Sicherstellung der Dateikompatibilität, die Verwaltung großer Dateigrößen und die Wahrung der Dokumentintegrität. IronPDF hilft, diese Herausforderungen zu meistern, indem es robuste Werkzeuge für die Erstellung und Bearbeitung von PDF-Dateien bereitstellt.

Kann ich in ASP.NET verschiedene Dateitypen in PDF konvertieren?

Ja, IronPDF ermöglicht es Ihnen, verschiedene Dateitypen wie HTML- oder Bilddateien nahtlos in Ihrer ASP.NET-Anwendung in PDFs zu konvertieren.

Welche Rolle spielt der Model-View-Controller (MVC) bei der Verarbeitung von PDFs in ASP.NET?

Das MVC-Muster hilft bei der Organisation des Codes für den Umgang mit PDFs, indem es die Datenverarbeitung (Model), die Benutzeroberfläche (View) und die Anwendungslogik (Controller) voneinander trennt und so die Verwaltung und Erweiterung von PDF-Funktionen erleichtert.

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