ASP.NET如何实现断点续传？| 文件上传技术详解

ASP.NET中断点续传的原理与实现方法分享

断点续传的核心原理在于利用HTTP协议规范中的Range和Content-Range头部字段，允许客户端指定需要下载文件的特定字节范围，服务端据此返回对应片段而非整个文件，并在传输中断后能从中断点继续请求剩余部分。

加载中

大文件分片上传、秒传以及断点续传功能流程以及代码分享

散装java

3.6万8332

原视频地址

核心原理剖析

1. HTTP协议基础支持

   • Range 请求头： 客户端发起请求时，通过Range: bytes=start-end格式告知服务器需要获取的文件字节范围（Range: bytes=1024-2047）。
   • Content-Range 响应头： 服务器在响应中包含此头部，明确告知客户端当前返回的数据块在整个文件中的位置以及文件总大小（Content-Range: bytes 1024-2047/8192）。
   • 206 Partial Content 状态码： 服务器成功处理了部分范围请求时返回此状态码，区别于完整文件请求的200 OK。
   • ETag / Last-Modified： 用于验证在断点续传过程中，客户端请求续传的文件版本与服务端当前文件版本是否一致，防止文件更新导致的数据错乱，客户端在续传请求中通常会带上之前响应中的ETag值（通过If-Match或If-Range）或Last-Modified时间（通过If-Unmodified-Since或If-Range）。

2. 文件分块与状态管理

   • 客户端需要记录已成功下载的文件片段信息（通常存储在本地临时文件或数据库中）。
   • 当传输中断（网络故障、用户暂停等）后重新发起请求时，客户端根据已下载的字节位置，计算并设置新的Range请求头（Range: bytes=2048- 表示从第2048字节开始直到文件末尾）。
   • 服务端根据Range头定位文件指针，读取并返回指定范围的字节流。

ASP.NET服务端实现详解

1. 处理Range请求

   

   public async Task<IActionResult> DownloadFile(string fileName)
   {
       var filePath = Path.Combine(_hostingEnvironment.WebRootPath, "uploads", fileName);
       if (!System.IO.File.Exists(filePath)) return NotFound();
       var fileInfo = new FileInfo(filePath);
       var fileLength = fileInfo.Length;
       var etag = GenerateETag(fileInfo); // 根据文件内容或元数据生成唯一ETag
       Response.Headers["ETag"] = etag;
       Response.Headers["Accept-Ranges"] = "bytes";
       // 1. 检查客户端是否发送了Range请求头
       var rangeHeader = Request.Headers["Range"].ToString();
       if (!string.IsNullOrEmpty(rangeHeader) && rangeHeader.StartsWith("bytes="))
       {
           // 2. 解析Range头，获取请求的字节范围
           var ranges = rangeHeader.Replace("bytes=", "").Split('-');
           long start = 0, end = fileLength - 1;
           if (long.TryParse(ranges[0], out long tempStart)) start = tempStart;
           if (ranges.Length > 1 && long.TryParse(ranges[1], out long tempEnd)) end = tempEnd;
           // 3. 验证范围有效性
           if (start > end || start >= fileLength || end >= fileLength)
           {
               Response.StatusCode = 416; // Range Not Satisfiable
               Response.Headers["Content-Range"] = $"bytes /{fileLength}";
               return new EmptyResult();
           }
           // 4. 处理If-Range / ETag / Last-Modified 验证 (确保文件未修改)
           var ifRangeHeader = Request.Headers["If-Range"].ToString();
           if (!string.IsNullOrEmpty(ifRangeHeader) && ifRangeHeader != etag) // 简化示例：仅比较ETag
           {
               // 文件已修改，应返回整个文件 (200 OK)
               return ServeFullFile(filePath, fileLength);
           }
           // 5. 设置206状态码和Content-Range头
           Response.StatusCode = 206;
           Response.Headers["Content-Range"] = $"bytes {start}-{end}/{fileLength}";
           var contentLength = end - start + 1;
           Response.Headers["Content-Length"] = contentLength.ToString();
           // 6. 读取并返回指定范围的字节流
           var buffer = new byte[81920];
           using (var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read))
           {
               stream.Seek(start, SeekOrigin.Begin);
               var bytesRemaining = contentLength;
               Response.ContentType = "application/octet-stream";
               while (bytesRemaining > 0)
               {
                   var bytesRead = await stream.ReadAsync(buffer, 0, (int)Math.Min(buffer.Length, bytesRemaining));
                   if (bytesRead == 0) break;
                   await Response.Body.WriteAsync(buffer, 0, bytesRead);
                   bytesRemaining -= bytesRead;
               }
           }
           return new EmptyResult();
       }
       else
       {
           // 7. 处理完整文件请求 (无Range头)
           return ServeFullFile(filePath, fileLength);
       }
   }
   private IActionResult ServeFullFile(string filePath, long fileLength)
   {
       Response.Headers["Content-Length"] = fileLength.ToString();
       return PhysicalFile(filePath, "application/octet-stream");
   }

2. 关键点与优化

   • 高效读取大文件： 使用FileStream并配合Seek定位，采用缓冲区循环读取发送，避免一次性加载大文件到内存，使用异步读写(ReadAsync, WriteAsync)提高并发能力。
   • 并发与文件锁： 使用FileShare.Read模式打开文件，允许其他进程/线程读取但不允许写入，确保文件在传输过程中不被修改（如果业务允许修改，则需更复杂的版本控制或锁机制）。
   • ETag生成策略： 确保ETag能准确反映文件内容变化，常用方法包括计算文件内容的哈希值（如MD5、SHA1），或结合文件长度和最后修改时间戳生成。
   • 验证请求头： 严谨处理If-Range, If-Match, If-Unmodified-Since等条件请求头，确保断点续传的数据一致性。
   • Content-Disposition： 设置Content-Disposition: attachment; filename="..."头确保浏览器触发下载而非直接打开。

客户端实现要点

1. 原生JavaScript (Fetch API / XHR)

   async function downloadFileWithResume(url, fileName) {
       let startByte = 0;
       // 尝试从本地存储获取已下载的字节数和临时文件引用
       const savedProgress = localStorage.getItem(fileName + '_progress');
       if (savedProgress) {
           const { position, tempUrl } = JSON.parse(savedProgress);
           startByte = position;
       }
       const headers = new Headers();
       if (startByte > 0) {
           headers.append('Range', `bytes=${startByte}-`);
       }
       try {
           const response = await fetch(url, { headers });
           if (response.status === 206) { // 部分内容
               const contentRange = response.headers.get('Content-Range');
               const totalBytes = parseInt(contentRange.split('/')[1]); // 提取总文件大小
               const reader = response.body.getReader();
               let receivedBytes = startByte;
               // 获取之前创建的临时文件Blob URL或创建新的
               let tempBlob = savedProgress ? await fetch(tempUrl).then(r => r.blob()) : null;
               let tempParts = tempBlob ? [tempBlob] : [];
               while (true) {
                   const { done, value } = await reader.read();
                   if (done) break;
                   receivedBytes += value.length;
                   tempParts.push(value);
                   // 实时保存进度到localStorage (包括新接收的片段和临时文件引用)
                   const newTempBlob = new Blob(tempParts, { type: 'application/octet-stream' });
                   const newTempUrl = URL.createObjectURL(newTempBlob);
                   localStorage.setItem(fileName + '_progress', JSON.stringify({
                       position: receivedBytes,
                       tempUrl: newTempUrl
                   }));
                   // 释放旧的临时URL (如果有)
                   if (savedProgress) URL.revokeObjectURL(savedProgress.tempUrl);
               }
               // 下载完成：创建最终Blob并触发下载，清理临时数据
               const finalBlob = new Blob(tempParts);
               const a = document.createElement('a');
               a.href = URL.createObjectURL(finalBlob);
               a.download = fileName;
               a.click();
               URL.revokeObjectURL(a.href);
               localStorage.removeItem(fileName + '_progress');
               // 释放所有临时URL
               URL.revokeObjectURL(newTempUrl);
           } else if (response.status === 200) {
               // 处理完整文件下载...
           }
       } catch (error) {
           console.error('Download error:', error);
           // 处理错误，保留状态以便续传
       }
   }

2. 专业前端库

   • Resumable.js： 提供文件分块、暂停/恢复、并发上传/下载、文件验证等功能，API强大。
   • Uppy： 功能全面的文件上传库，包含可恢复上传的@uppy/tus插件（基于TUS协议）。
   • tus-js-client： 直接实现TUS协议的客户端库，非常适合需要标准断点续传协议的场景。

进阶考虑与最佳实践

1. 分块传输与并行下载： 将大文件分割成多个小块，客户端使用多个并发连接同时下载不同块，显著提升大文件下载速度，需要服务端支持多Range请求（较少浏览器支持）或在客户端逻辑中合并多个独立范围请求的结果。
2. TUS协议： 一个基于HTTP的开放协议，为可恢复文件上传和下载提供标准化方案，它定义了创建上传、查询偏移量、传输数据块等核心操作，解决了原生HTTP断点续传的一些局限性（如状态管理、并发控制标准化），ASP.NET可通过集成tusdotnet等库实现TUS协议支持。
3. 服务端存储优化： 对于海量文件或高并发场景，考虑使用分布式文件存储（如Azure Blob Storage, Amazon S3, MinIO）或专用文件服务器，这些服务通常原生支持高效的断点续传和分块操作。
4. 安全性：
   • 文件验证： 服务端务必对请求的文件名进行严格校验（防止路径遍历攻击），检查用户权限。
   • 范围验证： 严格校验Range头值的有效性，防止恶意请求导致资源耗尽。
   • 传输加密： 始终使用HTTPS。
5. 客户端体验优化：
   • 实时进度显示： 精确计算并显示下载进度百分比和速度。
   • 暂停/恢复功能： 提供用户界面控制。
   • 断网/错误处理： 优雅处理网络中断和服务器错误，自动或提示用户重试/续传。
   • 本地存储管理： 合理管理本地存储的临时数据，提供清理机制。

ASP.NET 实现断点续传的核心在于精确利用 HTTP Range/Content-Range 机制，服务端需正确处理部分内容请求、验证文件一致性、高效安全地返回指定字节流；客户端需管理下载状态、构造续传请求并处理分片数据的拼接，通过结合 ETag 验证、高效流处理、并发控制及前端状态管理，开发者能构建出稳定高效的大文件传输解决方案，对于追求标准化和丰富功能的场景，采用 TUS 协议是更优的选择。

您在实际项目中是如何应用断点续传的？是否遇到过带宽波动导致续传失败的情况？欢迎在评论区分享您的解决方案或遇到的挑战！