Earlier in this blog I talked about the general idea behind one solution for uploading very large files (I consider very large when they are above 2GB), how the file API is becoming more popular and the possible client side approaches. This time I’ll describe the server side part of the solution. As a quick reminder, the server is responsible for:
- To determine if the request is to be handled by the mechanism, if not, just let it go.
- To determine if the request is an initial packet or a data packet.
- To handle properly each type of packet giving the appropriate response so the client can continue.
This is part of a bit more complex solution, named FreshUplaod, which has the Server component and client components using either JavaScript or Silverlight. The core element is the UploadHelper class, as the name indicates is a helper, it encapsulates the dirty logic regarding the request data reading and processing all stuff.
The methods ProcessInitialPacket and ProcessDataPacket do the actual work, but it’s necessary to know if the request data corresponds to one or another, that’s the job for these other methods IsInitialPacket and IsDataPacket. The actual helper utility is another method, ProcessRequest that acts as a façade to the whole mechanism. An example on how to use it is as follows:
[HttpPost]
public ActionResult Upload(FormCollection collection)
{
var packetSize = 4 * 1024 * 1024; // default to 4 MB
var filePath = Server.MapPath("~/_temp_upload/");
var result = UploadHelper.ProcessRequest(
Request, filePath, packetSize);
if (result != null)
return Json(result);
return Content("");
}
This is using a controller action on ASP.NET MVC 3, where the access to the request is quite easy and the conversion to Json is stress-free too. The key points here are the packet size and the folder where the file is to be stored, the packet size must be exactly the same configured on client side in order to expect a good behavior, I’ve used the 4 MB value because this is the default constraint imposed by ASP.NET and of course this can be tweaked as you want in web.config file.
Now let’s see how to use this element on ASP.NET WebForms, the idea I suggest here is to use a handler whether it was a Generic Handler or ASP.NET Handler, it can be also a WebForm but is not elegant enough solution because the WebForms are chained in a different pipeline and there can be a bit of noise, although it work as well. Here’s the code sample:
public void ProcessRequest(HttpContext context)
{
var packetSize = 4 * 1024 * 1024; // default to 4 MB
var filePath = context.Server.MapPath("~/_temp_upload/");
var result = UploadHelper.ProcessRequest(
context.Request.RequestContext.HttpContext.Request,
filePath, packetSize);
if (result != null)
{
JsonResult(context.Response, result);
}
else
{
context.Response.Write("");
}
}
private void JsonResult(HttpResponse response, object result)
{
response.ContentType = "application/json";
var serializer = new JavaScriptSerializer();
var json = serializer.Serialize(result);
response.Write(json);
}
Here we have a little more hand work but not so much, the json conversion and output is done completely manual (if some WebForms people knows how to achieve this with fewer code, please let me know cause I’m a little out of this part of ASP.NET, although I support Scott Hanselman with his slogan that “Only One ASP.NET”). The other key point is how to get the Request but with an instance of HttpRequestBase class, the default context.Response is an HttpRequest instance, so after some minutes of try-error-retry I found this way to get right value, again if some knows a better way to do it, you know.
In the next posts I’ll cover the other parts of this solution. The whole source code can be found at https://bitbucket.org/abelperezok/freshupload, I am still preparing the code samples so in a few weeks they will be ready.
