/// <summary> /// Delete temporary uploaded file data from temporary folder. /// </summary> public void DeleteTemporaryData() { var dirInfo = new DirectoryInfo(AjaxFileUpload.BuildTempFolder(this._fileId)); if (dirInfo.Exists) { dirInfo.Delete(true); } }
private static bool ProcessStream(HttpContext context, HttpPostedFile httpPostedFile, string fileId, string fileName, bool chunked, bool isFirstChunk) { Stream destination = null; var states = new AjaxFileUploadStates(context, fileId); // Prepare temporary folder, we use file id as a folder name. var tempFolder = AjaxFileUpload.BuildTempFolder(fileId); if (!Directory.Exists(tempFolder)) { Directory.CreateDirectory(tempFolder); } // Build temporary file path. var tmpFilePath = Path.Combine(tempFolder, fileName); if (!chunked || isFirstChunk) { // Create new file, if this is a first chunk or file is not chunked. destination = new FileStream(tmpFilePath, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite); } else { // Append data to existing teporary file for next chunks destination = new FileStream(tmpFilePath, FileMode.Append, FileAccess.Write, FileShare.ReadWrite); } var totalLength = httpPostedFile.ContentLength; var bufferSize = totalLength < ChunkSize ? totalLength : ChunkSize; var bytesWritten = 0; // Write uploaded data per chunk, so we can abort it anytime in a middle of process while (bytesWritten < totalLength) { var bytesToWrite = bytesWritten + bufferSize > totalLength ? totalLength - bytesWritten : bufferSize; var buffer = new byte[bytesToWrite]; httpPostedFile.InputStream.Read(buffer, 0, bytesToWrite); destination.Write(buffer, 0, bytesToWrite); bytesWritten += bytesToWrite; if (states.Abort) { destination.Dispose(); return(false); } } destination.Close(); destination.Dispose(); return(true); }
/// <summary> /// Process uploaded stream from Http request. /// </summary> /// <param name="context">Current HttpContext</param> /// <param name="source">Source stream</param> /// <param name="fileId">File Id</param> /// <param name="fileName">File Name</param> /// <param name="chunked">Determine uploading are processed by several chunks.</param> /// <param name="isFirstChunk">Is this stream for first chunk.</param> /// <returns></returns> public static bool ProcessStream(HttpContext context, Stream source, string fileId, string fileName, bool chunked, bool isFirstChunk, bool usePoll) { FileHeaderInfo headerInfo = null; Stream destination = null; var states = new AjaxFileUploadStates(context, fileId); using (var tmpStream = new MemoryStream()) { var totalBytesRead = 0; var done = false; var fileLength = 0; while (true) { if (states.Abort) { return(false); } // read per chunk var chunkSize = usePoll ? ChunkSizeForPolling : ChunkSize; if (chunkSize > source.Length) { chunkSize = (int)source.Length; if (usePoll) { states.FileLength = chunkSize; } } var chunk = new byte[chunkSize]; var index = 0; while (index < chunk.Length) { var bytesRead = source.Read(chunk, index, chunk.Length - index); if (bytesRead == 0) { break; } if (usePoll) { states.Uploaded += bytesRead; } index += bytesRead; } totalBytesRead += index; // Byte is not empty nor reach end of file if (index != 0) { // Keep seeking header info until it's found if (headerInfo == null) { // Append every first byte into temporary memory stream tmpStream.Write(chunk, 0, index); // Load it all into byte array, and try parse it so we can get header info var firstBytes = tmpStream.ToArray(); // Find header info from first bytes. headerInfo = MultipartFormDataParser.ParseHeaderInfo(firstBytes, Encoding.UTF8); // If it's found, then start writing to file. if (headerInfo != null) { // Calculate total file length. fileLength = ((int)(source.Length - headerInfo.BoundaryDelimiterLength) - headerInfo.StartIndex); if (usePoll) { states.FileLength = fileLength; } // Only write file data, so not all bytes are written. var lengthToWrite = totalBytesRead - headerInfo.StartIndex; if (lengthToWrite > fileLength) { lengthToWrite = fileLength; done = true; } // Get first chunk of file data. var firstChunk = new byte[lengthToWrite]; Buffer.BlockCopy(firstBytes, headerInfo.StartIndex, firstChunk, 0, lengthToWrite); // Prepare temporary folder, we use file id as a folder name. var tempFolder = AjaxFileUpload.BuildTempFolder(fileId); if (!Directory.Exists(tempFolder)) { Directory.CreateDirectory(tempFolder); } // Build temporary file path. var tmpFilePath = Path.Combine(tempFolder, fileName); if (!chunked || isFirstChunk) { // Create new file, if this is a first chunk or file is not chunked. destination = new FileStream(tmpFilePath, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite); } else { // Append data to existing teporary file for next chunks destination = new FileStream(tmpFilePath, FileMode.Append, FileAccess.Write, FileShare.ReadWrite); } // Writing it now. destination.Write(firstChunk, 0, lengthToWrite); } } else { var length = index; // Reach in the end of stream, remove last boundary if (destination.Length + index > fileLength) { length -= headerInfo.BoundaryDelimiterLength; done = true; } destination.Write(chunk, 0, length); } } // There is no byte to read anymore, upload is finished. if (done || index != chunk.Length) { if (destination != null) { destination.Close(); destination.Dispose(); } break; } } } return(true); }
/// <summary> /// Get contents of uploaded file in stream. /// </summary> /// <returns></returns> public Stream GetStreamContents() { var dir = AjaxFileUpload.BuildTempFolder(this._fileId); return(File.OpenRead(Path.Combine(dir, this._fileName))); }