ASP.NET 服务端接收Multipart/form-data文件

在网络编程过程中需要向服务器上传文件。

Multipart/form-data是上传文件的一种方式。

        /// <summary>
        /// 上传工程文件
        /// </summary>
        /// <returns></returns>
         public async Task<HttpResponseMessage> UploadProjectFile()
         {
                 ProjectFile postData = new ProjectFile();
                 IEnumerable<string> stringValues;
                 //获取请求头文件相关参数
                 Request.Headers.TryGetValues("token", out stringValues);
                 postData.token = stringValues.FirstOrDefault();

                 Request.Headers.TryGetValues("uid", out stringValues);
                 postData.uid = int.Parse(stringValues.FirstOrDefault());

                 Request.Headers.TryGetValues("project_id", out stringValues);
                 postData.project_id = int.Parse(stringValues.FirstOrDefault());

                 Request.Headers.TryGetValues("md5", out stringValues);
                 postData.md5 = stringValues.FirstOrDefault();

                 Request.Headers.TryGetValues("file_name", out stringValues);
                 postData.file_name = stringValues.FirstOrDefault();
                //验证Token
                 var result = CheckToken(postData.token);
                 if (!result)
                 {
                     return CreateResponseError(, "请求拒绝");
                 }
                 //获取文件名，这里的文件名必须带扩展名
                 string fileName = postData.file_name;

                 int projectId = postData.project_id;
                 //获取应用程序的当前工作目录
                 string rootPath = HostingEnvironment.MapPath("~/");
                 //通过Path类的Combine方法可以合并路径。获取当前工程文件夹地址
                 string directoryPath = Path.Combine(rootPath, "BgerProject", projectId.ToString());
                 //创建目录时如果目录已存在，则不会重新创建目录，且不会报错。创建目录时会自动创建路径中各级不存在的目录。
                 Directory.CreateDirectory(directoryPath);
                 //获取当前工程文件地址
                 string filePath = Path.Combine(directoryPath, fileName);
                 if (Request.Content.IsMimeMultipartContent())
                 {
                     Dictionary<string, string> dic = new Dictionary<string, string>();
                     var provider = new MultipartFormDataMemoryStreamProvider();

                     await Request.Content.ReadAsMultipartAsync(provider);
                     foreach (var item in provider.FileContents)
                     {
                         //Trace.WriteLine(item.Headers.ContentDisposition.FileName);//获取上传文件实际的文件名
                         //Trace.WriteLine("Server file path: " + item.LocalFileName);//获取上传文件在服务上默认的文件名
                         var stream = await item.ReadAsStreamAsync();
                         if (Path.GetExtension(item.Headers.ContentDisposition.FileName.Replace("\"", "")) == ".mp4")
                         {
                             //通过正则表达式判断是视频还是音频
                             Regex regex = new Regex("voice", RegexOptions.Compiled);
                             Match m = regex.Match(item.Headers.ContentDisposition.Name.ToLower());
                             if (m.Success)
                             {
                                 //音频直接保存处理

                                 //判断是否已存在该音频
                                 if (!File.Exists(filePath))
                                 {
                                     using (StreamWriter sw = new StreamWriter(filePath))
                                     {
                                         stream.CopyTo(sw.BaseStream);
                                         sw.Flush();
                                     }
                                 }
                             }
                             else
                             {
                                 //视频进行压缩处理
                                 //保存原片(如果路径不存在，创建路径)

                                 using (StreamWriter sw = new StreamWriter(filePath))
                                 {
                                     stream.CopyTo(sw.BaseStream);
                                     sw.Flush();
                                 }
                                 //压缩并保存上传的视频
                                 //压缩后的存放路径（如果路径不存在，创建路径）
                                 ////判断是否已存在该视频
                                 //if (!File.Exists(filePath))
                                 //{
                                 //    //压缩保存视频
                                 //    if (!FFMPEGHelper.CreateNewVideo(originalFilePath, filePath))
                                 //    {
                                 //        continue;
                                 //    };
                                 //}
                             }
                         }
                         else
                         {
                             //保存原片(如果路径不存在，创建路径)

                             using (StreamWriter sw = new StreamWriter(filePath))
                             {
                                 stream.CopyTo(sw.BaseStream);
                                 sw.Flush();
                             }
                             //压缩并保存上传的图片
                             //压缩后的存放路径（如果路径不存在，创建路径）

                             ////判断是否已存在该图片
                             //if (!File.Exists(filePath))
                             //{
                             //    var pxLimit = 481;
                             //    //判断是否需要压缩
                             //    System.Drawing.Image iSource = System.Drawing.Image.FromFile(originalFilePath);
                             //    if (iSource.Width <= pxLimit || iSource.Height <= pxLimit)
                             //    {
                             //        //无需压缩
                             //        System.IO.File.Copy(originalFilePath, filePath);
                             //    }
                             //    else
                             //    {
                             //        var min = Math.Min((int)iSource.Width, (int)iSource.Height);
                             //        if (min > pxLimit)
                             //        {
                             //            //缩放倍率
                             //            var rate = (double)pxLimit / min;
                             //            var width = (int)Math.Ceiling(rate * (double)iSource.Width);
                             //            var height = (int)Math.Ceiling(rate * (double)iSource.Height);

                             //            //压缩保存图片
                             //            if (!ImageHelper.GetPicThumbnail(originalFilePath, filePath, height, width, 100))
                             //            {
                             //                continue;
                             //            };
                             //        }
                             //    }
                             //}
                         }
                     }
                     return CreateResponse("请求成功");

                 }
                 return CreateResponseError(,"缺少MIME内容");

         }

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Web;
 using System.Collections.ObjectModel;
 using System.Collections.Specialized;
 using System.IO;
 using System.Net.Http;
 using System.Net.Http.Headers;
 using System.Threading;
 using System.Threading.Tasks;

 namespace BgerServer.Models
 {
     /// <summary>
     /// 与MultipartFormDataStreamProvider对应，但不将文件直接存入指定位置，而是需要自己指定数据流如何保存
     /// </summary>
     public class MultipartFormDataMemoryStreamProvider : MultipartStreamProvider
     {
         private NameValueCollection _formData = new NameValueCollection();
         private Collection<bool> _isFormData = new Collection<bool>();
         /// <summary>
         /// 获取文件对应的HttpContent集合,文件如何读取由实际使用方确定，可以ReadAsByteArrayAsync，也可以ReadAsStreamAsync
         /// </summary>
         public Collection<HttpContent> FileContents
         {
             get
             {
                 if (this._isFormData.Count != this.Contents.Count)//两者总数不一致，认为未执行过必须的Request.Content.ReadAsMultipartAsync(provider)方法
                 {
                     throw new InvalidOperationException("System.Net.Http.HttpContentMultipartExtensions.ReadAsMultipartAsync must be called first!");
                 }
                 return new Collection<HttpContent>(this.Contents.Where((ct, idx) => !this._isFormData[idx]).ToList());
             }
         }
         /// <summary>Gets a <see cref="T:System.Collections.Specialized.NameValueCollection" /> of form data passed as part of the multipart form data.</summary>
         /// <returns>The <see cref="T:System.Collections.Specialized.NameValueCollection" /> of form data.</returns>
         public NameValueCollection FormData
         {
             get
             {
                 return this._formData;
             }
         }
         public override async Task ExecutePostProcessingAsync()
         {
             for (var i = ; i < this.Contents.Count; i++)
             {
                 if (!this._isFormData[i])//非文件
                 {
                     continue;
                 }
                 var formContent = this.Contents[i];
                 ContentDispositionHeaderValue contentDisposition = formContent.Headers.ContentDisposition;
                 string formFieldName = UnquoteToken(contentDisposition.Name) ?? string.Empty;
                 string formFieldValue = await formContent.ReadAsStringAsync();
                 this.FormData.Add(formFieldName, formFieldValue);
             }
         }
         public override Stream GetStream(HttpContent parent, HttpContentHeaders headers)
         {
             if (parent == null)
             {
                 throw new ArgumentNullException("parent");
             }
             if (headers == null)
             {
                 throw new ArgumentNullException("headers");
             }
             ContentDispositionHeaderValue contentDisposition = headers.ContentDisposition;
             if (contentDisposition == null)
             {
                 throw new InvalidOperationException("Content-Disposition is null");
             }
             this._isFormData.Add(string.IsNullOrEmpty(contentDisposition.FileName));
             return new MemoryStream();
         }
         /// <summary>
         /// 复制自 System.Net.Http.FormattingUtilities 下同名方法，因为该类为internal，不能在其它命名空间下被调用
         /// </summary>
         /// <param name="token"></param>
         /// <returns></returns>
         private static string UnquoteToken(string token)
         {
             if (string.IsNullOrWhiteSpace(token))
             {
                 return token;
             }
             if (token.StartsWith("\"", StringComparison.Ordinal) && token.EndsWith("\"", StringComparison.Ordinal) && token.Length > )
             {
                 return token.Substring(, token.Length - );
             }
             return token;
         }
     }
 }