在ASP.NET MVC中实现大文件异步上传(2)

HttpWorkerRequest有VIP访问传入的请求，通常它是由ASP.NET本身支持工作的，但我们绑架了请求，然后欺骗剩下的请求，让它们误以为前面的请求已经全部得到处理，为了做到这一点，我们需要上面例子中未出现的UploadProcessor类，这个类的职责是物理读取来自浏览器的每个数据块，然后将其保存到磁盘上，因为上传的内容被分解成多个部分，UploadProcessor类需要找出内容头，然后拼接成带状数据输出，这一可以在一个上传中同时上传多个文件。

internal class UploadProcessor 　　{ 　　private byte[] _buffer; 　　private byte[] _boundaryBytes; 　　private byte[] _endHeaderBytes; 　　private byte[] _endFileBytes; 　　private byte[] _lineBreakBytes; 　　private const string _lineBreak = "/r/n"; 　　private readonly Regex _filename = 　　new Regex(@"Content-Disposition:/s*form-data/s*;/s*name/s*=/s*""file""/s*;/s*filename/s*=/s*""(.*)""", 　　RegexOptions.IgnoreCase | RegexOptions.Compiled); 　　private readonly HttpWorkerRequest _workerRequest; 　　public UploadProcessor(HttpWorkerRequest workerRequest) 　　{ 　　_workerRequest = workerRequest; 　　} 　　public void StreamToDisk(IServiceProvider provider, Encoding encoding, string rootPath) 　　{ 　　var buffer = new byte[8192]; 　　if (!_workerRequest.HasEntityBody()) 　　{ 　　return; 　　} 　　var total = _workerRequest.GetTotalEntityBodyLength(); 　　var preloaded = _workerRequest.GetPreloadedEntityBodyLength(); 　　var loaded = preloaded; 　　SetByteMarkers(_workerRequest, encoding); 　　var body = _workerRequest.GetPreloadedEntityBody(); 　　if (body == null) // IE normally does not preload 　　{ 　　body = new byte[8192]; 　　preloaded = _workerRequest.ReadEntityBody(body, body.Length); 　　loaded = preloaded; 　　} 　　var text = encoding.GetString(body); 　　var fileName = _filename.Matches(text)[0].Groups[1].Value; 　　fileName = Path.GetFileName(fileName); // IE captures full user path; chop it 　　var path = Path.Combine(rootPath, fileName); 　　var files = new List {fileName}; 　　var stream = new FileStream(path, FileMode.Create); 　　if (preloaded > 0) 　　{ 　　stream = ProcessHeaders(body, stream, encoding, preloaded, files, rootPath); 　　} 　　// Used to force further processing (i.e. redirects) to avoid buffering the files again 　　var workerRequest = new StaticWorkerRequest(_workerRequest, body); 　　var field = HttpContext.Current.Request.GetType().GetField("_wr", BindingFlags.NonPublic | BindingFlags.Instance); 　　field.SetValue(HttpContext.Current.Request, workerRequest); 　　if (!_workerRequest.IsEntireEntityBodyIsPreloaded()) 　　{ 　　var received = preloaded; 　　while (total - received >= loaded && _workerRequest.IsClientConnected()) 　　{ 　　loaded = _workerRequest.ReadEntityBody(buffer, buffer.Length); 　　stream = ProcessHeaders(buffer, stream, encoding, loaded, files, rootPath); 　　received += loaded; 　　} 　　var remaining = total - received; 　　buffer = new byte[remaining]; 　　loaded = _workerRequest.ReadEntityBody(buffer, remaining); 　　stream = ProcessHeaders(buffer, stream, encoding, loaded, files, rootPath); 　　} 　　stream.Flush(); 　　stream.Close(); 　　stream.Dispose(); 　　} 　　private void SetByteMarkers(HttpWorkerRequest workerRequest, Encoding encoding) 　　{ 　　var contentType = workerRequest.GetKnownRequestHeader(HttpWorkerRequest.HeaderContentType); 　　var bufferIndex = contentType.IndexOf("boundary=") + "boundary=".Length; 　　var boundary = String.Concat("--", contentType.Substring(bufferIndex)); 　　_boundaryBytes = encoding.GetBytes(string.Concat(boundary, _lineBreak)); 　　_endHeaderBytes = encoding.GetBytes(string.Concat(_lineBreak, _lineBreak)); 　　_endFileBytes = encoding.GetBytes(string.Concat(_lineBreak, boundary, "--", _lineBreak)); 　　_lineBreakBytes = encoding.GetBytes(string.Concat(_lineBreak + boundary + _lineBreak)); 　　} 　　private FileStream ProcessHeaders(byte[] buffer, FileStream stream, Encoding encoding, int count, ICollection files, string rootPath) 　　{ 　　buffer = AppendBuffer(buffer, count); 　　var startIndex = IndexOf(buffer, _boundaryBytes, 0); 　　if (startIndex != -1) 　　{ 　　var endFileIndex = IndexOf(buffer, _endFileBytes, 0); 　　if (endFileIndex != -1) 　　{ 　　var precedingBreakIndex = IndexOf(buffer, _lineBreakBytes, 0); 　　if (precedingBreakIndex > -1) 　　{ 　　startIndex = precedingBreakIndex; 　　} 　　endFileIndex += _endFileBytes.Length; 　　var modified = SkipInput(buffer, startIndex, endFileIndex, ref count); 　　stream.Write(modified, 0, count); 　　} 　　else 　　{ 　　var endHeaderIndex = IndexOf(buffer, _endHeaderBytes, 0); 　　if (endHeaderIndex != -1) 　　{ 　　endHeaderIndex += _endHeaderBytes.Length; 　　var text = encoding.GetString(buffer); 　　var match = _filename.Match(text); 　　var fileName = match != null ? match.Groups[1].Value : null; 　　fileName = Path.GetFileName(fileName); // IE captures full user path; chop it 　　if (!string.IsNullOrEmpty(fileName) && !files.Contains(fileName)) 　　{ 　　files.Add(fileName); 　　var filePath = Path.Combine(rootPath, fileName); 　　stream = ProcessNextFile(stream, buffer, count, startIndex, endHeaderIndex, filePath); 　　} 　　else 　　{ 　　var modified = SkipInput(buffer, startIndex, endHeaderIndex, ref count); 　　stream.Write(modified, 0, count); 　　} 　　} 　　else 　　{ 　　_buffer = buffer; 　　} 　　} 　　} 　　else 　　{ 　　stream.Write(buffer, 0, count); 　　} 　　return stream; 　　}

private static FileStream ProcessNextFile(FileStream stream, byte[] buffer, int count, int startIndex, int endIndex, string filePath) 　　{ 　　var fullCount = count; 　　var endOfFile = SkipInput(buffer, startIndex, count, ref count); 　　stream.Write(endOfFile, 0, count); 　　stream.Flush(); 　　stream.Close(); 　　stream.Dispose(); 　　stream = new FileStream(filePath, FileMode.Create); 　　var startOfFile = SkipInput(buffer, 0, endIndex, ref fullCount); 　　stream.Write(startOfFile, 0, fullCount); 　　return stream; 　　} 　　private static int IndexOf(byte[] array, IList value, int startIndex) 　　{ 　　var index = 0; 　　var start = Array.IndexOf(array, value[0], startIndex); 　　if (start == -1) 　　{ 　　return -1; 　　} 　　while ((start + index) < array.Length) 　　{ 　　if (array[start + index] == value[index]) 　　{ 　　index++; 　　if (index == value.Count) 　　{ 　　return start; 　　} 　　} 　　else 　　{ 　　start = Array.IndexOf(array, value[0], start + index); 　　if (start != -1) 　　{ 　　index = 0; 　　} 　　else 　　{ 　　return -1; 　　} 　　} 　　} 　　return -1; 　　} 　　private static byte[] SkipInput(byte[] input, int startIndex, int endIndex, ref int count) 　　{ 　　var range = endIndex - startIndex; 　　var size = count - range; 　　var modified = new byte[size]; 　　var modifiedCount = 0; 　　for (var i = 0; i < input.Length; i++) 　　{ 　　if (i >= startIndex && i < endIndex) 　　{ 　　continue; 　　} 　　if (modifiedCount >= size) 　　{ 　　break; 　　} 　　modified[modifiedCount] = input[i]; 　　modifiedCount++; 　　} 　　input = modified; 　　count = modified.Length; 　　return input; 　　} 　　private byte[] AppendBuffer(byte[] buffer, int count) 　　{ 　　var input = new byte[_buffer == null ? buffer.Length : _buffer.Length + count]; 　　if (_buffer != null) 　　{ 　　Buffer.BlockCopy(_buffer, 0, input, 0, _buffer.Length); 　　} 　　Buffer.BlockCopy(buffer, 0, input, _buffer == null ? 0 : _buffer.Length, count); 　　_buffer = null; 　　return input; 　　} 　　}

　　在处理代码的中间位置，你应该注意到了另一个类StaticWorkerRequest，这个类负责欺骗ASP.NET，在点击提交按钮时，它欺骗ASP.NET，让他认为没有文件上传，这是必需的，因为当上传完毕时，如果我们要重定向到所需的页面时，ASP.NET将会检查到在HTTP实体主体中仍然有数据，然后会尝试缓存整个上传，于是我们兜了一圈又回到了原点，为了避免这种情况，我们必须欺骗HttpWorkerRequest，将它注入到HttpContext中，获得请求开始部分的StaticWorkerRequest，它是唯一有用的数据。

internal class StaticWorkerRequest : HttpWorkerRequest 　　{ 　　readonly HttpWorkerRequest _request; 　　private readonly byte[] _buffer; 　　public StaticWorkerRequest(HttpWorkerRequest request, byte[] buffer) 　　{ 　　_request = request; 　　_buffer = buffer; 　　} 　　public override int ReadEntityBody(byte[] buffer, int size) 　　{ 　　return 0; 　　} 　　public override int ReadEntityBody(byte[] buffer, int offset, int size) 　　{ 　　return 0; 　　} 　　public override byte[] GetPreloadedEntityBody() 　　{ 　　return _buffer; 　　} 　　public override int GetPreloadedEntityBody(byte[] buffer, int offset) 　　{ 　　Buffer.BlockCopy(_buffer, 0, buffer, offset, _buffer.Length); 　　return _buffer.Length; 　　} 　　public override int GetPreloadedEntityBodyLength() 　　{ 　　return _buffer.Length; 　　} 　　public override int GetTotalEntityBodyLength() 　　{ 　　return _buffer.Length; 　　} 　　public override string GetKnownRequestHeader(int index) 　　{ 　　return index == HeaderContentLength 　　? "0" 　　: _request.GetKnownRequestHeader(index); 　　} 　　// All other methods elided, they're just passthrough 　　}

　　使用StaticWorkerRequest建立虚假的声明，现在你可以在ASP.NET MVC中通过直接访问数据流上传大文件，使用这个代码作为开始，你可以很容易地保存过程数据，并使用Ajax调用另一个控制器行为展示其进度，将大文件缓存到一个临时区域，可以实现断点续传，不用再等待ASP.NET进程将整个文件缓存到磁盘上，同样，保存文件时也不用消耗另存为方法那么多的内存了。