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.
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 Paket-Manager-Konsole oder führen Sie die untenstehenden 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.DesignNach der Installation stellt IronPDF Zugriff auf ChromePdfRenderer zum Generieren von PDFs aus HTML, PdfDocument zum Laden und Bearbeiten bestehender Dateien sowie auf eine Reihe von Bearbeitungstools wie Wasserzeichen, Stempel und digitale Signaturen bereit. Auf der vollständigen NuGet-Paketseite von IronPDF finden Sie die Versionshistorie und Hinweise zur Kompatibilität.
Fügen Sie eine Speicherpfadkonstante zu Program.cs hinzu und registrieren Sie Ihre ApplicationDbContext mit dem Dependency Injection Container. Ihre Projektstruktur wird ein Controllers/PdfController.cs, ein Models/PdfFileModel.cs und ein Data/ApplicationDbContext.cs enthalten, bevor Sie jegliche PDF-spezifische Logik schreiben.
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 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 ClassFileData 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.
Registrieren Sie das Modell mit 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; }
}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 ClassFühren Sie dotnet ef migrations add InitialCreate gefolgt von dotnet ef database update aus, um das Schema zu erstellen. Entity Framework Core mappt byte[] automatisch auf eine varbinary(max) Spalte in SQL Server oder eine BLOB Spalte in SQLite - kein manuelles SQL erforderlich.
Die Controller-Aktion, die Uploads verarbeitet, erhält einen IFormFile-Parameter von einem HTML-Formular unter Verwendung von enctype="multipart/form-data". Die Aktion liest den Stream in einen MemoryStream, konvertiert ihn in ein Byte-Array und speichert das Ergebnis über 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);
}
}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 ClassVor der Verarbeitung muss stets der Inhaltstyp überprüft werden. Das Überprüfen von file.ContentType schützt vor dem versehentlichen Hochladen von Nicht-PDF-Inhalten durch Benutzer. Für eine stärkere Validierung lesen Sie die ersten vier Bytes des Streams und überprüfen Sie die PDF-Magic-Number (%PDF). Sie sollten auch eine maximale Dateigröße durchsetzen - typischerweise 10 MB für allgemeine Dokumentenworkflows - indem Sie file.Length überprüfen, bevor Sie den Stream kopieren.
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 Senden-Knopf innerhalb des Formular-Tags hinzu, der auf /Pdf/Upload zeigt.
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));
}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 FunctionDie ApplyWatermark-Methode von IronPDF akzeptiert einen HTML-String, was bedeutet, dass Ihr Wasserzeichen jedes gültige HTML und Inline-CSS enthalten kann - Farbverläufe, benutzerdefinierte Schriftarten, gedrehter Text oder sogar eingebettete SVG-Symbole. Der rotation-Parameter dreht das Wasserzeichen über die Seitendiagonale, während opacity die Transparenz von 0 (unsichtbar) bis 100 (vollständig undurchsichtig) steuert.
Über Wasserzeichen hinaus bietet dasselbe PdfDocument-Objekt Methoden zum Hinzufügen von Kopf- und Fußzeilen, Stempeln von Bildern und Bearbeiten vorhandener Formularfelder. Sie können mehrere Verarbeitungsschritte verketten, bevor Sie pdf.BinaryData aufrufen, um das endgültige Byte-Array abzurufen.
Um ein gespeichertes PDF zurück an den Browser zu senden, rufen Sie den Datensatz nach ID ab und geben Sie einen FileResult zurück. Die ASP.NET Core File-Hilfsmethode setzt den korrekten Content-Type-Header und löst das Download-Dialogfeld 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);
}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 FunctionDie Index-Aktion ruft alle gespeicherten Datei-Datensätze ab und reicht sie an eine Razor-Ansicht weiter. 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>netDie return File(bytes, contentType, fileName)-Überladung setzt sowohl Content-Type: application/pdf als auch Content-Disposition: attachment; Dateiname="..." Header. Wenn Sie möchten, dass der Browser das PDF inline öffnet, anstatt einen Download aufzufordern, verwenden Sie return File(bytes, contentType) ohne das dritte Argument - dies lässt die Content-Disposition: attachment-Anweisung weg.
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) während des Uploads und lesen Sie System.IO.File.ReadAllBytesAsync(path) beim Download. Beide Pfade führen zu demselben return File(...)-Aufruf im Controller.
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>$999</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");
}ChromePdfRenderer erzeugt Pixel-genaue Ausgaben unter Verwendung desselben Chromium-Rendering-Engines, das auch Google Chrome antreibt. 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 Papierformat, Ränder und Ausrichtung über die RenderingOptions-Eigenschaft festlegen, bevor Sie RenderHtmlAsPdf aufrufen.
Für komplexere Dokumente übergeben Sie eine vollständige URL an RenderUrlAsPdf anstatt 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.
Über die Bearbeitung einzelner Dateien hinaus kann es erforderlich sein, mehrere hochgeladene Dokumente zu einem einzigen Dokument zusammenzufassen. Die PDF-Zusammenführungsfunktion von IronPDF akzeptiert eine Liste von PdfDocument-Objekten und gibt eine einzige 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");
}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 FunctionDer umgekehrte Vorgang - das Extrahieren eines Teilabschnitts von Seiten - verwendet CopyPages. Laden Sie einen PdfDocument aus den gespeicherten Bytes, rufen Sie source.CopyPages(startIndex, endIndex) mit nullbasierten 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.
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 es zu erhöhen, rufen Sie builder.Services.Configure<FormOptions> auf, um MultipartBodyLengthLimit und builder.WebHost.ConfigureKestrel aufzurufen, um Limits.MaxRequestBodySize festzulegen - beide auf Ihre gewünschte Byte-Anzahl, wie 50 * 1024 * 1024 für 50 MB - in Program.cs vor builder.Build().
Über Größenbeschränkungen hinaus wenden Sie diese Sicherheitspraktiken auf jeden Upload-Endpunkt an: Validieren Sie den Content-Typ-Header, untersuchen Sie die ersten Bytes des Streams auf die %PDF-Magic-Number, scannen Sie nach eingebetteten Skripten mit der Dokumenteninspektions-API von IronPDF und speichern Sie verarbeitete Dateien außerhalb des Webroots, sodass sie nie direkt als statischer Inhalt bereitgestellt werden. Die Sicherheitsdokumentation von ASP.NET Core umfasst zusätzliche Härtungstechniken, darunter die Validierung von Antifälschungstoken und die Integration von Virenscans.
Wenn Dateien 10 MB überschreiten, kann das Einlesen des gesamten Streams in einen MemoryStream vor der Verarbeitung die Speichernutzung signifikant erhöhen. Verwenden Sie IronPdf.PdfDocument.FromStream, um direkt aus dem Anforderungsstream zu laden, wo möglich, 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);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)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 .
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.
Speichern Sie in der Cloud. Ersetzen Sie die lokale byte[]-Datenbankspalte durch ein 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.
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 Handbücher.
IronPDF ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Wenn Ihr PDF wie HTML aussehen soll, schnell.
