Uppy, Dropzone or FilePond vs AjaxUploader

Use an open-source library when it fits

All three libraries are MIT-licensed and free to use. If your team is comfortable writing and maintaining the server side of an upload, or your front end is already a JavaScript application that talks to an API, one of them is a reasonable choice and there is nothing to buy.

• Uppy is a modular uploader from Transloadit. It has plugins for resumable uploads over the tus protocol and for uploads to S3, and a separate Node.js server, Companion, for importing from remote sources.
• Dropzone is a drag-and-drop library that sends files as ordinary multipart form posts, with an option to split files into chunks.
• FilePond is a plugin-based uploader from PQINA with image preview plugins and support for chunked uploads to an endpoint you provide.

Check each project's own documentation for its current features. They change between releases, and this page does not try to track them.

What a browser library leaves to you

These libraries run in the browser. None of them ships an ASP.NET Web Forms server control, so the server half of the upload is yours to write. In a Web Forms application that usually means:

• An upload endpoint. A handler such as an .ashx that receives each request, checks it, and saves the file.
• Chunk assembly and resume. If you turn on chunking, the server has to store the parts, put them back in order, and cope with retries and abandoned uploads. Resumable uploads over tus need a tus server.
• Server-side validation. Size, extension and content checks in the browser are a convenience. The server has to repeat them, because a request can be sent without the library.
• The join with the page. The upload happens outside the postback. You have to connect the uploaded files to the form the user then submits, including inside an UpdatePanel, and keep ViewState and validation working.
• Temporary file clean-up. Something has to delete uploads that were started and never finished.

A minimal handler is short. The work is in everything around it:

public class UploadHandler : IHttpHandler
{
    public void ProcessRequest(HttpContext context)
    {
        HttpPostedFile file = context.Request.Files[0];
        // Still to write: authentication, size and type checks, safe file names,
        // chunk assembly, resume, clean-up, and linking the file to the page.
        file.SaveAs(Path.Combine(context.Server.MapPath("~/App_Data/uploads"),
                                 Path.GetFileName(file.FileName)));
    }
    public bool IsReusable { get { return false; } }
}

What AjaxUploader does differently

AjaxUploader is a Web Forms server control. The browser engine and the server handler ship together, and the upload arrives in your page as a server event:

<au:AjaxFileUpload ID="Uploader1" runat="server" AllowMultiple="true"
                   AutoPostBack="true" OnFileUploaded="Uploader1_FileUploaded" />

protected void Uploader1_FileUploaded(object sender, FileUploadedEventArgs e)
{
    var destination = Path.Combine(Server.MapPath("~/App_Data/uploads"), e.FileName);
    new UploadService().CopyFile(e.FileGuid, destination);
}

Chunking, resume, temporary storage and clean-up are handled by the control. You can see each of these running in the online demos.

Side by side

How to decide

Choose an open-source library if you already have, or want to own, the upload endpoint, and your team will maintain it. Choose AjaxUploader if the application is Web Forms and you would rather add a control and a handler method than build and maintain the server side yourself. The evaluation package is free to download and runs locally, so you can compare the two approaches on one of your own pages before buying anything.