All 15 File Uploads & Streaming Large Files questions
More in File Uploads & Streaming Large Files
How do you accept a file upload in an ASP.NET Core controller action using IFormFile? What HTTP status code and response should be returned when an upload fails validation (wrong type, too large, missing file)? Why is buffering an entire large file upload in memory (via IFormFile) problematic, and how does streaming avoid this issue? How do you configure and enforce a maximum request/file upload size in ASP.NET Core, and what's the default limit? How do you validate an uploaded file's actual content type (not just its client-supplied extension or Content-Type header) to prevent malicious file uploads? How do you accept and process multiple files uploaded in a single request? How do you configure IIS or a reverse proxy like nginx to allow large file uploads, given they may impose their own separate size limits beyond Kestrel's? What is the difference between temporary file storage (during processing) and permanent storage for uploaded files, and why should uploads generally not be saved directly to their final destination? How would you implement true streaming file upload using MultipartReader to avoid ASP.NET Core's default buffering behavior entirely? How would you implement resumable/chunked file uploads to support very large files over unreliable network connections?
Advertisement
ASP.NET Core › File Uploads & Streaming Large Files

How do you stream a large file back to the client as a download response without loading the entire file into memory first?

Intermediate

Answer

Returning a FileStreamResult (via File(stream, contentType) or Results.Stream() in minimal APIs) with an open stream lets ASP.NET Core copy bytes from the stream directly to the response body incrementally as they're read, rather than requiring the entire file's bytes to be loaded into a byte array in memory before the response can begin sending.
[HttpGet("download/{id}")]
public async Task<IActionResult> Download(int id) {
    var stream = await _storageService.OpenReadStreamAsync(id);
    return File(stream, "application/octet-stream", "report.pdf");
}

// Minimal API equivalent
app.MapGet("/download/{id}", async (int id, IStorageService storage) => {
    var stream = await storage.OpenReadStreamAsync(id);
    return Results.Stream(stream, "application/octet-stream", "report.pdf");
});
Real-world example A reporting API serving multi-hundred-megabyte generated PDF reports streams them directly from blob storage to the client response, keeping server memory usage constant regardless of file size instead of loading each report fully into a byte array first.

Common follow-ups: What's the difference between FileStreamResult and FileContentResult in terms of memory usage?;How does this interact with range requests for resumable downloads?

Diagnostics & Performance;Content Negotiation & Output Formatters
All 15 File Uploads & Streaming Large Files questions