| public static BuildTempFolder ( string fileId ) : string | ||
| fileId | string | |
| return | string | |
/// <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)));
}