使用Blazor WASM实现可取消的多文件带校验并发分片上传

奢爱巢精品女装

前言

上传大文件时，原始HTTP文件上传功能可能会影响使用体验，此时使用分片上传功能可以有效避免原始上传的弊端。由于分片上传不是HTTP标准的一部分，所以只能自行开发相互配合的服务端和客户端。文件分片上传在许多情况时都拥有很多好处，除非已知需要上传的文件一定非常小。分片上传可以对上传的文件进行快速分片校验，避免大文件上传时长时间等待校验，当然完整校验可以在秒传时使用，有这种需求的情况就只能老实等待校验了。
Blazr WASM提供了在 .NET环境中使用浏览器功能的能力，充分利用C#和 .NET能够大幅简化分片上传功能的开发。本次示例使用HTTP标准上传作为分片上传的底层基础，并提供分片校验功能保障上传数据的完整性。
新书宣传

有关新书的更多介绍欢迎查看《C#与.NET6 开发从入门到实践》上市，作者亲自来打广告了！

正文

本示例的Blazor代码位于默认ASP.NET Core托管的Blazor WASM应用模板的Index页面。
在Shared项目添加公共数据模型

1. /// <summary>
2. /// 文件分片上传输入模型
3. /// </summary>
4. public class FileChunkUploadInput
5. {
6.     /// <summary>
7.     /// 上传任务代码
8.     /// </summary>
9.     public string? UploadTaskCode { get; set; }
11.     /// <summary>
12.     /// 上传请求类型
13.     /// </summary>
14.     public string UploadType { get; set; } = null!;
16.     /// <summary>
17.     /// 文件名
18.     /// </summary>
19.     public string FileName { get; set; } = null!;
21.     /// <summary>
22.     /// 文件大小
23.     /// </summary>
24.     public long? FileSize { get; set; }
26.     /// <summary>
27.     /// 支持的Hash算法，优选算法请靠前
28.     /// </summary>
29.     public List<string>? AllowedHashAlgorithm { get; set; }
31.     /// <summary>
32.     /// 使用的Hash算法
33.     /// </summary>
34.     public string? HashAlgorithm { get; set; }
36.     /// <summary>
37.     /// Hash值
38.     /// </summary>
39.     public string? HashValue { get; set; }
41.     /// <summary>
42.     /// 文件分片数量
43.     /// </summary>
44.     public int FileChunkCount { get; set; }
46.     /// <summary>
47.     /// 文件片段大小
48.     /// </summary>
49.     public int? FileChunkSize { get; set; }
51.     /// <summary>
52.     /// 文件片段偏移量（相对于整个文件）
53.     /// </summary>
54.     public long? FileChunkOffset { get; set; }
56.     /// <summary>
57.     /// 文件片段索引
58.     /// </summary>
59.     public int? FileChunkIndex { get; set; }
61.     /// <summary>
62.     /// 取消上传的原因
63.     /// </summary>
64.     public string? CancelReason { get; set; }
65. }
67. /// <summary>
68. /// 文件分片上传开始结果
69. /// </summary>
70. public class FileChunkUploadStartReault
71. {
72.     /// <summary>
73.     /// 上传任务代码
74.     /// </summary>
75.     public string UploadTaskCode { get; set; } = null!;
77.     /// <summary>
78.     /// 选中的Hash算法
79.     /// </summary>
80.     public string SelectedHashAlgorithm { get; set; } = null!;
81. }
83. /// <summary>
84. /// Hash助手
85. /// </summary>
86. public static class HashHelper
87. {
88.     /// <summary>
89.     /// 把Hash的字节数组转换为16进制字符串表示
90.     /// </summary>
91.     /// <param name="bytes">原始Hash值</param>
92.     /// <returns>Hash值的16进制文本表示（大写）</returns>
93.     public static string ToHexString(this byte[] bytes)
94.     {
95.         StringBuilder sb = new(bytes.Length * 2);
96.         foreach (var @byte in bytes)
97.         {
98.             sb.Append(@byte.ToString("X2"));
99.         }
100.         return sb.ToString();
101.     }
102. }

复制代码

服务端控制器

1. [ApiController]
2. [Route("[controller]")]
3. public class UploadController : ControllerBase
4. {
5.     /// <summary>
6.     /// 支持的Hash算法，优选算法请靠前
7.     /// </summary>
8.     private static string[] supportedHashAlgorithm = new[] { "MD5", "SHA1", "SHA256" };
10.     /// <summary>
11.     /// 文件写入锁的线程安全字典，每个上传任务对应一把锁
12.     /// </summary>
13.     private static readonly ConcurrentDictionary<string, AsyncLock> fileWriteLockerDict = new();
15.     private readonly ILogger<UploadController> _logger;
16.     private readonly IWebHostEnvironment _env;
18.     public UploadController(ILogger<UploadController> logger, IWebHostEnvironment env)
19.     {
20.         _logger = logger;
21.         _env = env;
22.     }
24.     /// <summary>
25.     /// 分片上传动作
26.     /// </summary>
27.     /// <param name="input">上传表单</param>
28.     /// <param name="fileChunkData">文件片段数据</param>
29.     /// <param name="requestAborted">请求取消令牌</param>
30.     /// <returns>片段上传结果</returns>
31.     [HttpPost, RequestSizeLimit(1024 * 1024 * 11)]
32.     [ProducesResponseType(StatusCodes.Status200OK)]
33.     [ProducesResponseType(StatusCodes.Status400BadRequest)]
34.     [ProducesDefaultResponseType]
35.     public async Task<IActionResult> Upload(
36.         [FromForm]FileChunkUploadInput input,
37.         [FromForm]IFormFile? fileChunkData,
38.         CancellationToken requestAborted)
39.     {
40.         switch (input.UploadType)
41.         {
42.             // 请求开始一个新的上传任务，协商上传参数
43.             case "startUpload":
44.                 {
45.                     //var trustedFileNameForDisplay =
46.                     //    WebUtility.HtmlEncode(fileChunkData?.FileName ?? input.FileName);
48.                     // 选择双方都支持的优选Hash算法
49.                     var selectedHashAlgorithm = supportedHashAlgorithm
50.                         .Intersect(input.AllowedHashAlgorithm ?? Enumerable.Empty<string>())
51.                         .FirstOrDefault();
53.                     // 验证必要的表单数据
54.                     if (selectedHashAlgorithm is null or "")
55.                     {
56.                         ModelState.AddModelError<FileChunkUploadInput>(x => x.AllowedHashAlgorithm, "can not select hash algorithm");
57.                     }
59.                     if (input.FileSize is null)
60.                     {
61.                         ModelState.AddModelError<FileChunkUploadInput>(x => x.FileSize, "must have value for start、upload and complete");
62.                     }
64.                     if (ModelState.ErrorCount > 0)
65.                     {
66.                         return ValidationProblem(ModelState);
67.                     }
69.                     // 使用随机文件名提高安全性，并把文件名作为任务代码使用
70.                     var trustedFileNameForFileStorage = Path.GetRandomFileName();
72.                     var savePath = Path.Combine(
73.                         _env.ContentRootPath,
74.                         _env.EnvironmentName,
75.                         "unsafe_uploads",
76.                         trustedFileNameForFileStorage);
78.                     var savePathWithFile = Path.Combine(
79.                         savePath,
80.                         $"{input.FileName}.tmp");
82.                     if (!Directory.Exists(savePath))
83.                     {
84.                         Directory.CreateDirectory(savePath);
85.                     }
87.                     // 根据表单创建对应大小的文件
88.                     await using (var fs = new FileStream(savePathWithFile, FileMode.Create))
89.                     {
90.                         fs.SetLength(input.FileSize!.Value);
91.                         await fs.FlushAsync();
92.                     }
94.                     // 设置锁
95.                     fileWriteLockerDict.TryAdd(trustedFileNameForFileStorage, new());
97.                     // 返回协商结果
98.                     return Ok(new FileChunkUploadStartReault
99.                     {
100.                         UploadTaskCode = trustedFileNameForFileStorage,
101.                         SelectedHashAlgorithm = selectedHashAlgorithm!
102.                     });
103.                 }
105.             // 上传文件片段
106.             case "uploadChunk":
107.                 // 验证表单
108.                 if (!fileWriteLockerDict.TryGetValue(input.UploadTaskCode!, out var _))
109.                 {
110.                     ModelState.AddModelError<FileChunkUploadInput>(x => x.UploadTaskCode, $"file upload task with code {input.UploadTaskCode} is not exists");
111.                     return ValidationProblem(ModelState);
112.                 }
114.                 // 使用内存池缓冲数据，注意使用using释放内存
115.                 using (var pooledMemory = MemoryPool<byte>.Shared.Rent((int)fileChunkData!.Length))
116.                 {
117.                     // 使用切片语法获取精准大小的内存缓冲区装载上传的数据
118.                     var buffer = pooledMemory.Memory[..(int)fileChunkData!.Length];
119.                     var readBytes = await fileChunkData.OpenReadStream().ReadAsync(buffer, requestAborted);
120.                     var readBuffer = buffer[..readBytes];
122.                     Debug.Assert(readBytes == fileChunkData!.Length);
124.                     // 校验Hash
125.                     var hash = input.HashAlgorithm switch
126.                     {
127.                         "SHA1" => SHA1.HashData(readBuffer.Span),
128.                         "SHA256" => SHA256.HashData(readBuffer.Span),
129.                         "MD5" => MD5.HashData(readBuffer.Span),
130.                         _ => Array.Empty<byte>()
131.                     };
133.                     if (hash.ToHexString() != input.HashValue)
134.                     {
135.                         ModelState.AddModelError<FileChunkUploadInput>(x => x.HashValue, "hash does not match");
136.                         return ValidationProblem(ModelState);
137.                     }
139.                     var savePath = Path.Combine(
140.                         _env.ContentRootPath,
141.                         _env.EnvironmentName,
142.                         "unsafe_uploads",
143.                         input.UploadTaskCode!);
145.                     var savePathWithFile = Path.Combine(
146.                         savePath,
147.                         $"{input.FileName}.tmp");
149.                     // 使用锁写入数据，文件流不支持写共享，必须串行化
150.                     if(fileWriteLockerDict.TryGetValue(input.UploadTaskCode!, out var locker))
151.                     {
152.                         using (await locker.LockAsync())
153.                         {
154.                             await using (var fs = new FileStream(savePathWithFile, FileMode.Open, FileAccess.Write))
155.                             {
156.                                 // 定位文件流
157.                                 fs.Seek(input.FileChunkOffset!.Value, SeekOrigin.Begin);
159.                                 await fs.WriteAsync(readBuffer, requestAborted);
160.                                 await fs.FlushAsync();
161.                             }
162.                         }
163.                     }
164.                 }
166.                 return Ok();
168.             // 取消上传
169.             case "cancelUpload":
170.                 // 验证表单
171.                 if (!fileWriteLockerDict.TryGetValue(input.UploadTaskCode!, out var _))
172.                 {
173.                     ModelState.AddModelError<FileChunkUploadInput>(x => x.UploadTaskCode, $"file upload task with code {input.UploadTaskCode} is not exists");
174.                     return ValidationProblem(ModelState);
175.                 }
177.                 {
178.                     var deletePath = Path.Combine(
179.                         _env.ContentRootPath,
180.                         _env.EnvironmentName,
181.                         "unsafe_uploads",
182.                         input.UploadTaskCode!);
184.                     // 删除文件，清除锁
185.                     if (fileWriteLockerDict.TryGetValue(input.UploadTaskCode!, out var locker))
186.                     {
187.                         using (await locker.LockAsync())
188.                         {
189.                             if (Directory.Exists(deletePath))
190.                             {
191.                                 var dir = new DirectoryInfo(deletePath);
192.                                 dir.Delete(true);
193.                             }
195.                             fileWriteLockerDict.TryRemove(input.UploadTaskCode!, out _);
196.                         }
197.                     }
198.                 }
200.                 return Ok();
202.             // 完成上传
203.             case "completeUpload":
204.                 // 验证表单
205.                 if (!fileWriteLockerDict.TryGetValue(input.UploadTaskCode!, out var _))
206.                 {
207.                     ModelState.AddModelError<FileChunkUploadInput>(x => x.UploadTaskCode, $"file upload task with code {input.UploadTaskCode} is not exists");
208.                     return ValidationProblem(ModelState);
209.                 }
211.                 {
212.                     var savePath = Path.Combine(
213.                         _env.ContentRootPath,
214.                         _env.EnvironmentName,
215.                         "unsafe_uploads",
216.                         input.UploadTaskCode!);
218.                     // 去除文件的临时扩展名，清除锁
219.                     var savePathWithFile = Path.Combine(savePath, $"{input.FileName}.tmp");
221.                     var fi = new FileInfo(savePathWithFile);
222.                     fi.MoveTo(Path.Combine(savePath, input.FileName));
224.                     fileWriteLockerDict.TryRemove(input.UploadTaskCode!, out _);
225.                 }
227.                 return Ok();
228.             default:
229.                 return BadRequest();
230.         }
231.     }
232. }

复制代码

服务端使用三段式上传模式，开始上传，上传数据，完成（取消）上传。开始上传负责协商Hash算法和分配任务代码；上传数据负责具体的传输，并通过表单提供附加信息方便服务端操作。完成上传负责善后和资源清理。其中文件写入的异步锁使用Nito.AsyncEx代替不支持在异步中使用的lock语句。
页面代码（Index.razor）,在结尾追加

1. <p>支持随时取消的多文件并行分片上传，示例同时上传2个文件，每个文件同时上传2个分片，合计同时上传4个分片</p>
2. <InputFile OnChange="UploadFile" multiple></InputFile>
3. <button @onclick="async (MouseEventArgs e) => uploadCancelSource?.Cancel()">取消上传</button>
5. @code{
6.     [Inject] private HttpClient _http { get; init; } = null!;
7.     [Inject] private ILogger<Index> _logger { get; init; } = null!;
9.     private CancellationTokenSource? uploadCancelSource;
11.     /// <summary>
12.     /// 上传文件
13.     /// </summary>
14.     /// <param name="args">上传文件的事件参数</param>
15.     /// <returns></returns>
16.     private async Task UploadFile(InputFileChangeEventArgs args)
17.     {
18.         // 设置文件并发选项
19.         var parallelCts = new CancellationTokenSource();
20.         uploadCancelSource = parallelCts;
21.         var parallelOption = new ParallelOptions
22.         {
23.             MaxDegreeOfParallelism = 2,
24.             CancellationToken = parallelCts.Token
25.         };
27.         // 并发上传所有文件
28.         await Parallel.ForEachAsync(
29.             args.GetMultipleFiles(int.MaxValue),
30.             parallelOption,
31.             async (file, cancellation) =>
32.             {
33.                 // 这里的取消令牌是并发方法创建的，和并发选项里的令牌不是一个
34.                 if (cancellation.IsCancellationRequested)
35.                 {
36.                     parallelCts.Cancel();
37.                     return;
38.                 }
40.                 // 使用链接令牌确保外部取消能传递到内部
41.                 var chunkUploadResult = await UploadChunkedFile(
42.                     file,
43.                     CancellationTokenSource.CreateLinkedTokenSource(
44.                         parallelCts.Token,
45.                         cancellation
46.                     ).Token
47.                 );
49.                 // 如果上传不成功则取消后续上传
50.                 if (chunkUploadResult != FileUploadResult.Success)
51.                 {
52.                     parallelCts.Cancel();
53.                     return;
54.                 }
55.             }
56.         );
57.     }
59.     /// <summary>
60.     /// 分片上传文件
61.     /// </summary>
62.     /// <param name="file">要上传的文件</param>
63.     /// <param name="cancellation">取消令牌</param>
64.     /// <returns>上传结果</returns>
65.     private async Task<FileUploadResult> UploadChunkedFile(IBrowserFile file, CancellationToken cancellation = default)
66.     {
67.         if (cancellation.IsCancellationRequested) return FileUploadResult.Canceled;
69.         _logger.LogInformation("开始上传文件：{0}", file.Name);
71.         // 计算分片大小，文件小于10MB分片1MB，大于100MB分片10MB，在其间则使用不超过10片时的所需大小
72.         var coefficient = file.Size switch
73.         {
74.             <= 1024 * 1024 * 10 => 1,
75.             > 1024 * 1024 * 10 and <= 1024 * 1024 *100 => (int)Math.Ceiling(file.Size / (1024.0 * 1024) / 10),
76.             _ => 10
77.         };
79.         // 初始化分片参数，准备字符串格式的数据供表单使用
80.         var bufferSize = 1024 * 1024 * coefficient; // MB
81.         var stringBufferSize = bufferSize.ToString();
82.         var chunkCount = (int)Math.Ceiling(file.Size / (double)bufferSize);
83.         var stringChunkCount = chunkCount.ToString();
84.         var stringFileSize = file.Size.ToString();
86.         // 发起分片上传，协商Hash算法，获取任务代码
87.         var uploadStartContent = new List<KeyValuePair<string, string>>
88.         {
89.             new("uploadType", "startUpload"),
90.             new("fileName", file.Name),
91.             new("fileSize", stringFileSize),
92.             new("allowedHashAlgorithm", "SHA1"),
93.             new("allowedHashAlgorithm", "SHA256"),
94.             new("fileChunkCount", stringChunkCount),
95.             new("fileChunkSize", stringBufferSize),
96.         };
98.         var uploadStartForm = new FormUrlEncodedContent(uploadStartContent);
100.         HttpResponseMessage? uploadStartResponse = null;
101.         try
102.         {
103.             uploadStartResponse = await _http.PostAsync("/upload", uploadStartForm, cancellation);
104.         }
105.         catch(TaskCanceledException e)
106.         {
107.             _logger.LogWarning(e, "外部取消上传，已停止文件：{0} 的上传", file.Name);
108.             return FileUploadResult.Canceled;
109.         }
110.         catch(Exception e)
111.         {
112.             _logger.LogError(e, "文件：{0} 的上传参数协商失败", file.Name);
113.             return FileUploadResult.Fail;
114.         }
116.         // 如果服务器响应失败，结束上传
117.         if (uploadStartResponse?.IsSuccessStatusCode is null or false)
118.         {
119.             _logger.LogError("文件：{0} 的上传参数协商失败", file.Name);
120.             return FileUploadResult.Fail;
121.         }
123.         // 解析协商的参数
124.         var uploadStartReault = await uploadStartResponse.Content.ReadFromJsonAsync<FileChunkUploadStartReault>();
125.         var uploadTaskCode = uploadStartReault!.UploadTaskCode;
126.         var selectedHashAlgorithm = uploadStartReault!.SelectedHashAlgorithm;
128.         _logger.LogInformation("文件：{0} 的上传参数协商成功", file.Name);
130.         // 设置分片并发选项
131.         var parallelOption = new ParallelOptions
132.         {
133.             MaxDegreeOfParallelism = 2,
134.         };
136.         var fileUploadCancelSource = new CancellationTokenSource();
137.         var sliceEnumeratorCancelSource = CancellationTokenSource
138.             .CreateLinkedTokenSource(
139.                 cancellation,
140.                 fileUploadCancelSource.Token
141.             );
142.         // 各个分片的上传结果
143.         var sliceUploadResults = new FileUploadResult?[chunkCount];
144.         // 并发上传各个分片，并发循环本身不能用并发选项的取消令牌取消，可能会导致内存泄漏，应该通过切片循环的取消使并发循环因没有可用元素自然结束
145.         await Parallel.ForEachAsync(
146.             SliceFileAsync(
147.                 file,
148.                 bufferSize,
149.                 sliceEnumeratorCancelSource.Token
150.             ),
151.             parallelOption,
152.             async (fileSlice, sliceUploadCancel) =>
153.             {
154.                 // 解构参数
155.                 var (memory, sliceIndex, readBytes, fileOffset) = fileSlice;
157.                 // 使用using确保结束后把租用的内存归还给内存池
158.                 using (memory)
159.                 {
160.                     var stringSliceIndex = sliceIndex.ToString();
162.                     // 主动取消上传，发送取消请求，通知服务端清理资源
163.                     if (sliceUploadCancel.IsCancellationRequested)
164.                     {
165.                         _logger.LogWarning("外部取消上传，已停止文件：{0} 的上传", file.Name);
167.                         fileUploadCancelSource.Cancel();
168.                         sliceUploadResults[sliceIndex] = FileUploadResult.Canceled;
170.                         var uploadCancelContent = new Dictionary<string, string>()
171.                         {
172.                             {"uploadType", "cancelUpload"},
173.                             {"uploadTaskCode", uploadTaskCode!},
174.                             {"fileName", file.Name},
175.                             {"hashAlgorithm", selectedHashAlgorithm},
176.                             {"fileChunkCount", stringChunkCount},
177.                             {"fileChunkIndex", stringSliceIndex},
178.                             {"cancelReason", "调用方要求取消上传。"},
179.                         };
180.                         var uploadCancelForm = new FormUrlEncodedContent(uploadCancelContent);
181.                         var uploadCancelResponse = await _http.PostAsync("/upload", uploadCancelForm);
183.                         return;
184.                     }
186.                     // 当前上传分片索引应当小于预计的分片数
187.                     Debug.Assert(sliceIndex < chunkCount);
189.                     // 获取准确大小的缓冲区，从内存池租用时得到的容量可能大于申请的大小，使用C#的新集合切片语法
190.                     var readBuffer = memory.Memory[..readBytes];
192.                     var sw = Stopwatch.StartNew();
193.                     // 根据协商的算法计算Hash，wasm环境不支持MD5和全部非对称加密算法
194.                     var hash = selectedHashAlgorithm switch
195.                     {
196.                         "SHA1" => SHA1.HashData(readBuffer.Span),
197.                         "SHA256" => SHA256.HashData(readBuffer.Span),
198.                         _ => Array.Empty<byte>()
199.                     };
200.                     sw.Stop();
202.                     _logger.LogInformation("文件：{0} 的片段 {1}({2} Bytes) 计算Hash用时 {3}", file.Name, sliceIndex, readBytes, sw.Elapsed);
204.                     var stringReadBytes = readBytes.ToString();
205.                     var stringFileOffset = fileOffset.ToString();
207.                     // 上传当前分片
208.                     MultipartFormDataContent uploadFileForm = new();
209.                     uploadFileForm.Add(new StringContent(uploadTaskCode!), "uploadTaskCode");
210.                     uploadFileForm.Add(new StringContent("uploadChunk"), "uploadType");
211.                     uploadFileForm.Add(new StringContent(file.Name), "fileName");
212.                     uploadFileForm.Add(new StringContent(stringFileSize), "fileSize");
213.                     uploadFileForm.Add(new StringContent(selectedHashAlgorithm!), "hashAlgorithm");
214.                     uploadFileForm.Add(new StringContent(hash.ToHexString()), "hashValue");
215.                     uploadFileForm.Add(new StringContent(stringChunkCount), "fileChunkCount");
216.                     uploadFileForm.Add(new StringContent(stringReadBytes), "fileChunkSize");
217.                     uploadFileForm.Add(new StringContent(stringFileOffset), "fileChunkOffset");
218.                     uploadFileForm.Add(new StringContent(stringSliceIndex), "fileChunkIndex");
220.                     // 如果是未知的文件类型，设置为普通二进制流的MIME类型
221.                     var fileChunk = new ReadOnlyMemoryContent(readBuffer);
222.                     fileChunk.Headers.ContentType = new MediaTypeHeaderValue(string.IsNullOrEmpty(file.ContentType) ? "application/octet-stream" : file.ContentType);
223.                     uploadFileForm.Add(fileChunk, "fileChunkData", file.Name);
225.                     HttpResponseMessage? uploadResponse = null;
226.                     try
227.                     {
228.                         var uploadTaskCancel = CancellationTokenSource
229.                             .CreateLinkedTokenSource(
230.                                 sliceUploadCancel,
231.                                 sliceEnumeratorCancelSource.Token
232.                             );
234.                         _logger.LogInformation("文件：{0} 的片段 {1}({2} Bytes) 开始上传", file.Name, sliceIndex, readBytes);
236.                         sw.Restart();
237.                         uploadResponse = await _http.PostAsync("/upload", uploadFileForm, uploadTaskCancel.Token);
238.                     }
239.                     catch (TaskCanceledException e)
240.                     {
241.                         _logger.LogWarning(e, "外部取消上传，已停止文件：{0} 的上传", file.Name);
243.                         fileUploadCancelSource.Cancel();
244.                         sliceUploadResults[sliceIndex] = FileUploadResult.Canceled;
246.                         var uploadCancelContent = new Dictionary<string, string>()
247.                         {
248.                             {"uploadType", "cancelUpload"},
249.                             {"uploadTaskCode", uploadTaskCode!},
250.                             {"fileName", file.Name},
251.                             {"hashAlgorithm", selectedHashAlgorithm},
252.                             {"fileChunkCount", stringChunkCount},
253.                             {"fileChunkIndex", stringSliceIndex},
254.                             {"cancelReason", "调用方要求取消上传。"},
255.                         };
256.                         var uploadCancelForm = new FormUrlEncodedContent(uploadCancelContent);
257.                         var uploadCancelResponse = await _http.PostAsync("/upload", uploadCancelForm);
259.                         return;
260.                     }
261.                     catch (Exception e)
262.                     {
263.                         _logger.LogError(e, "上传发生错误，已停止文件：{0} 的上传", file.Name);
265.                         fileUploadCancelSource.Cancel();
266.                         sliceUploadResults[sliceIndex] = FileUploadResult.Fail;
268.                         var uploadCancelContent = new Dictionary<string, string>()
269.                         {
270.                             {"uploadType", "cancelUpload"},
271.                             {"uploadTaskCode", uploadTaskCode!},
272.                             {"fileName", file.Name},
273.                             {"hashAlgorithm", selectedHashAlgorithm},
274.                             {"fileChunkCount", stringChunkCount},
275.                             {"fileChunkSize", stringReadBytes},
276.                             {"fileChunkOffset", stringFileOffset},
277.                             {"fileChunkIndex", stringSliceIndex},
278.                             {"cancelReason", "上传过程中发生错误。"},
279.                         };
280.                         var uploadCancelForm = new FormUrlEncodedContent(uploadCancelContent);
281.                         var uploadCancelResponse = await _http.PostAsync("/upload", uploadCancelForm);
283.                         return;
284.                     }
285.                     finally
286.                     {
287.                         sw.Stop();
288.                     }
290.                     // 上传发生错误，发送取消请求，通知服务端清理资源
291.                     if (uploadResponse?.IsSuccessStatusCode is null or false)
292.                     {
293.                         _logger.LogError("上传发生错误，已停止文件：{0} 的上传", file.Name);
295.                         fileUploadCancelSource.Cancel();
296.                         sliceUploadResults[sliceIndex] = FileUploadResult.Fail;
298.                         var uploadCancelContent = new Dictionary<string, string>()
299.                         {
300.                             {"uploadType", "cancelUpload"},
301.                             {"uploadTaskCode", uploadTaskCode!},
302.                             {"fileName", file.Name},
303.                             {"hashAlgorithm", selectedHashAlgorithm},
304.                             {"fileChunkCount", stringChunkCount},
305.                             {"fileChunkSize", stringReadBytes},
306.                             {"fileChunkOffset", stringFileOffset},
307.                             {"fileChunkIndex", stringSliceIndex},
308.                             {"cancelReason", "上传过程中发生错误。"},
309.                         };
310.                         var uploadCancelForm = new FormUrlEncodedContent(uploadCancelContent);
311.                         var uploadCancelResponse = await _http.PostAsync("/upload", uploadCancelForm);
313.                         return;
314.                     }
316.                     _logger.LogInformation("文件：{0} 的片段 {1}({2} Bytes) 上传成功，用时 {3}", file.Name, sliceIndex, readBytes, sw.Elapsed);
318.                     sliceUploadResults[sliceIndex] = FileUploadResult.Success;
319.                 }
320.             }
321.         );
323.         // 如果所有分片都上传成功，则发送完成请求完成上传
324.         if (sliceUploadResults.All(success => success is FileUploadResult.Success))
325.         {
326.             var uploadCompleteContent = new Dictionary<string, string>()
327.             {
328.                 {"uploadType", "completeUpload"},
329.                 {"uploadTaskCode", uploadTaskCode!},
330.                 {"fileName", file.Name},
331.                 {"fileSize", stringFileSize},
332.                 {"hashAlgorithm", selectedHashAlgorithm},
333.                 {"fileChunkCount", stringChunkCount},
334.                 {"fileChunkSize", stringBufferSize},
335.             };
336.             var uploadCompleteForm = new FormUrlEncodedContent(uploadCompleteContent);
337.             var uploadCompleteResponse = await _http.PostAsync("/upload", uploadCompleteForm);
339.             if (uploadCompleteResponse.IsSuccessStatusCode)
340.             {
341.                 _logger.LogInformation("文件：{0} 上传成功，共 {1} 个片段", file.Name, chunkCount);
342.                 return FileUploadResult.Success;
343.             }
344.             else
345.             {
346.                 _logger.LogError("上传发生错误，已停止文件：{0} 的上传", file.Name);
348.                 var uploadCancelContent = new Dictionary<string, string>()
349.                 {
350.                     {"uploadType", "cancelUpload"},
351.                     {"uploadTaskCode", uploadTaskCode!},
352.                     {"fileName", file.Name},
353.                     {"hashAlgorithm", selectedHashAlgorithm},
354.                     {"fileChunkCount", stringChunkCount},
355.                     {"cancelReason", "上传过程中发生错误。"},
356.                 };
357.                 var uploadCancelForm = new FormUrlEncodedContent(uploadCancelContent);
358.                 var uploadCancelResponse = await _http.PostAsync("/upload", uploadCancelForm);
360.                 return FileUploadResult.Fail;
361.             }
362.         }
363.         else if (sliceUploadResults.Any(success => success is FileUploadResult.Fail))
364.         {
365.             return FileUploadResult.Fail;
366.         }
367.         else
368.         {
369.             return FileUploadResult.Canceled;
370.         }
371.     }
373.     /// <summary>
374.     /// 异步切分要上传的文件
375.     /// <br/>如果想中途结束切分，不要在调用此方法的foreach块中使用break，请使用取消令牌，否则会出现内存泄漏
376.     /// </summary>
377.     /// <param name="file">要分片的文件</param>
378.     /// <param name="sliceSize">分片大小</param>
379.     /// <param name="cancellation">取消令牌</param>
380.     /// <returns>已切分的文件片段数据，用完切记释放其中的内存缓冲</returns>
381.     private static async IAsyncEnumerable<(IMemoryOwner<byte> memory, int sliceIndex, int readBytes, long fileOffset)> SliceFileAsync(
382.         IBrowserFile file,
383.         int sliceSize,
384.         [EnumeratorCancellation] CancellationToken cancellation = default)
385.     {
386.         if (cancellation.IsCancellationRequested) yield break;
388.         int fileSliceIndex;
389.         long fileOffset;
390.         IMemoryOwner<byte> memory;
391.         await using var fileStream = file.OpenReadStream(long.MaxValue);
393.         for (fileSliceIndex = 0, fileOffset = 0, memory = MemoryPool<byte>.Shared.Rent(sliceSize);
394.             (await fileStream.ReadAsync(memory.Memory[..sliceSize], cancellation)) is int readBytes and > 0;
395.             fileSliceIndex++, fileOffset += readBytes, memory = MemoryPool<byte>.Shared.Rent(sliceSize)
396.         )
397.         {
398.             if(cancellation.IsCancellationRequested)
399.             {
400.                 // 如果取消切分，缓冲不会返回到外部，只能在内部释放
401.                 memory.Dispose();
402.                 yield break;
403.             }
404.             yield return (memory, fileSliceIndex, readBytes, fileOffset);
405.         }
406.         // 切分结束后会多出一个没用的缓冲，只能在内部释放
407.         memory.Dispose();
408.     }
410.     /// <summary>
411.     /// 上传结果
412.     /// </summary>
413.     public enum FileUploadResult
414.     {
415.         /// <summary>
416.         /// 失败
417.         /// </summary>
418.         Fail = -2,
420.         /// <summary>
421.         /// 取消
422.         /// </summary>
423.         Canceled = -1,
425.         /// <summary>
426.         /// 没有结果，未知结果
427.         /// </summary>
428.         None = 0,
430.         /// <summary>
431.         /// 成功
432.         /// </summary>
433.         Success = 1
434.     }
435. }

复制代码

示例使用Parallel.ForEachAsync方法并行启动多个文件和每个文件的多个片段的上传，并发量由方法的参数控制。UploadChunkedFile方法负责单个文件的上传，其中的IBrowserFile类型是.NET 6新增的文件选择框选中项的包装，可以使用其中的OpenReadStream方法流式读取文件数据，确保大文件上传不会在内存中缓冲所有数据导致内存占用问题。
UploadChunkedFile方法内部使用自适应分片大小算法，规则为片段最小1MB，最大10MB，尽可能平均分为10份。得出片段大小后向服务端请求开始上传文件，服务端成功返回后开始文件切分、校验和上传。
SliceFileAsync负责切分文件并流式返回每个片段，切分方法是惰性的，所以不用担心占用大量内存，但是这个方法只能使用取消令牌中断切分，如果在调用该方法的await foreach块中使用break中断会产生内存泄漏。切分完成后会返回包含片段数据的内存缓冲和其他附加信息。OpenReadStream需要使用参数控制允许读取的最大字节数（默认512KB），因为这里是分片上传，直接设置为long.MaxValue即可。for循环头使用逗号表达式定义多个循环操作，使循环体的代码清晰简洁。
UploadChunkedFile方法使用Parallel.ForEachAsync并行启动多个片段的校验和上传，WASM中不支持MD5和所有非对称加密算法，需要注意。完成文件的并行上传或发生错误后会检查所有片段的上传情况，如果所有片段都上传成功，就发送完成上传请求通知服务端收尾善后，否则删除临时文件。
结语

这应该是一个比较清晰易懂的分片上传示例。示例使用Blazor 和C#以非常流畅的异步代码实现了并发分片上传。但是本示例依然有许多可优化的点，例如实现断点续传，服务端如果没有收到结束请求时的兜底处理等，这些就留给朋友们思考了。
又是很久没有写文章了，一直没有找到什么好选题，难得找到一个，经过将近1周的研究开发终于搞定了。
QQ群

读者交流QQ群：540719365

欢迎读者和广大朋友一起交流，如发现本书错误也欢迎通过博客园、QQ群等方式告知我。
本文地址：https://www.cnblogs.com/coredx/p/17746162.html

来源:https://www.cnblogs.com/coredx/archive/2023/10/07/17746162.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！