How to Efficiently Download Large Files in ASP.NET

1. Using FileStreamResult for Efficient File Streaming

The FileStreamResult streams the file without loading it entirely into memory, which is perfect for large files. It only reads the file in chunks and sends it to the client.

public ActionResult DownloadLargeFile()
{
    string filePath = Server.MapPath("~/Files/LargeFile.zip"); // Adjust file path
    string fileName = "LargeFile.zip";

    if (!System.IO.File.Exists(filePath))
    {
        return HttpNotFound("File not found.");
    }

    var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read);
    return File(stream, "application/octet-stream", fileName);
}

Efficient memory usage: The file is streamed rather than loaded into memory.

Suitable for large files, such as those over 1GB.

2. Stream File in Chunks Using Response.Write

Instead of loading the entire file into memory, you can stream it in smaller chunks. This method uses Response.OutputStream to send chunks of the file (e.g., 1MB at a time).

public void StreamLargeFile()
{
    string filePath = Server.MapPath("~/Files/LargeFile.zip");

    if (!System.IO.File.Exists(filePath))
    {
        Response.StatusCode = 404;
        Response.End();
        return;
    }

    Response.Clear();
    Response.ContentType = "application/octet-stream";
    Response.AddHeader("Content-Disposition", "attachment; filename=LargeFile.zip");

    const int bufferSize = 1024 * 1024; // 1MB chunks
    byte[] buffer = new byte[bufferSize];

    using (FileStream fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read))
    {
        int bytesRead;
        while ((bytesRead = fileStream.Read(buffer, 0, buffer.Length)) > 0)
        {
            Response.OutputStream.Write(buffer, 0, bytesRead);
            Response.Flush(); // Immediately send the chunk to the client
        }
    }

    Response.End();
}

Sends data in smaller chunks to avoid excessive memory consumption.

Response.Flush() ensures the data is sent to the client immediately, preventing timeouts.

3. Asynchronous Streaming for Better Performance (Recommended for Web API)

Using asynchronous methods for file streaming in MVC or Web API allows you to avoid blocking threads while handling large files.

public async Task<IActionResult> DownloadLargeFileAsync()
{
    string filePath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", "Files", "LargeFile.zip");

    if (!System.IO.File.Exists(filePath))
    {
        return NotFound("File not found.");
    }

    var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read, bufferSize: 4096, useAsync: true);
    return File(stream, "application/octet-stream", "LargeFile.zip");
}

Prevents blocking the server threads, allowing the system to handle multiple requests concurrently.

The useAsync: true option improves I/O operations by making them non-blocking.

4. Modify web.config for Large File Support

By default, ASP.NET and IIS may have limits on the file size that can be uploaded or downloaded. You can modify the web.config file to allow larger file downloads.

<system.webServer>
    <security>
        <requestFiltering>
            <requestLimits maxAllowedContentLength="2147483648" /> <!-- 2GB -->
        </requestFiltering>
    </security>
</system.webServer>

This increases the maximum allowed file size for uploads and downloads. The default limit in IIS is 30MB, but you can raise it to accommodate larger files.

5. Set Proper Content-Disposition Header for File Downloads

If the filename contains special characters, you may encounter issues when downloading files, especially in browsers like Chrome and Edge. The Content-Disposition header ensures that the file is downloaded rather than displayed inline.

public ActionResult DownloadLargeFile()
{
    string filePath = Server.MapPath("~/Files/LargeFile.zip");
    string fileName = "Large File.zip";

    var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read);
    var cd = new System.Net.Mime.ContentDisposition
    {
        FileName = fileName,
        Inline = false // Forces download
    };
    Response.Headers.Add("Content-Disposition", cd.ToString());

    return File(stream, "application/octet-stream");
}

Ensures that the file is properly downloaded, even if it contains spaces or special characters in the filename.

6. Optimize IIS for Large Files

If you're hosting your ASP.NET application on IIS, you can increase timeout settings and other limits to support large file downloads.

Run these commands to modify the IIS configuration:

appcmd set config /section:serverRuntime /uploadReadAheadSize:10485760
appcmd set config /section:system.webServer/serverRuntime /maxRequestEntityAllowed:2147483648

Increases the request size and read-ahead limits to support larger file downloads without causing timeouts.

By combining these methods, you can efficiently handle large file downloads in ASP.NET, ensuring minimal memory usage, preventing server timeouts, and providing a smooth user experience. The best approach depends on the specific scenario, such as whether you're working with MVC or Web API, but all of these techniques aim to stream files efficiently while keeping your application scalable and responsive.