Save base64 file received from HttpPostedFileBase

Question

I am using jquery filedrop and I was getting an error using readAsBinaryString on Internet Explorer (10+). It works on Chrome and Firefox.

Then I changed that method to readAsDataURL , which 'works' in every browser.

The problem is that this last method returns an base64 file from HttpPostedFileBase and I don't know how to save the file as it is.

Thats my code now:

byte[] binaryData;
binaryData = new Byte[file.InputStream.Length];
long bytesRead = file.InputStream.Read(binaryData, 0, (int)file.InputStream.Length);
file.InputStream.Close();
string base64String = System.Convert.ToBase64String(binaryData, 0, binaryData.Length);

byte[] bytes = System.Convert.FromBase64String(base64String);

string filePath = Path.Combine(ed_fisico_provisorio.vr_parametro, no_arquivo_provisorio);

System.IO.FileStream fs = System.IO.File.Create(filePath);
fs.Write(bytes, 0, bytes.Length);
fs.Close();

But saving like this, the content of the file becomes like

data:application/msword;base64,0M8R4KGxGuEAAAAAAAAAAAAAAAAAAAAAPgADAP7...

Any other ideas?

----- UPDATE -----

To clarify, step by step what is happening. By the way, I am using C# MVC.

STEP 1 - Using the plugin jquery.filedrop.js, I drop the file on its view. Can be any file extension.

STEP 2 - Calls the plugin, which includes this code:

// Respond to an upload
        function upload() {

            stop_loop = false;

            if (!files) {
                opts.error(errors[0]);
                return false;
            }

            var filesDone = 0,
                filesRejected = 0;

            if (files_count > opts.maxfiles && opts.queuefiles === 0) {
                opts.error(errors[1]);
                return false;
            }

            // Define queues to manage upload process
            var workQueue = [];
            var processingQueue = [];
            var doneQueue = [];

            // Add everything to the workQueue
            for (var i = 0; i < files_count; i++) {
                workQueue.push(i);
            }

            // Helper function to enable pause of processing to wait
            // for in process queue to complete
            var pause = function (timeout) {
                setTimeout(process, timeout);
                return;
            }

            // Process an upload, recursive
            var process = function () {

                var fileIndex;

                if (stop_loop) return false;

                // Check to see if are in queue mode
                if (opts.queuefiles > 0 && processingQueue.length >= opts.queuefiles) {

                    return pause(opts.queuewait);

                } else {

                    // Take first thing off work queue
                    fileIndex = workQueue[0];
                    workQueue.splice(0, 1);

                    // Add to processing queue
                    processingQueue.push(fileIndex);

                }

                try {
                    if (beforeEach(files[fileIndex]) != false) {
                        if (fileIndex === files_count) return;
                        var reader = new FileReader(),
                            max_file_size = 1048576 * opts.maxfilesize;

                        reader.index = fileIndex;
                        if (files[fileIndex].size > max_file_size) {
                            opts.error(errors[2], files[fileIndex], fileIndex);
                            // Remove from queue
                            processingQueue.forEach(function (value, key) {
                                if (value === fileIndex) processingQueue.splice(key, 1);
                            });
                            filesRejected++;
                            return true;
                        }
                        reader.onloadend = send;





                        //reader.readAsArrayBuffer(files[fileIndex]);


                        reader.readAsDataURL(files[fileIndex]);



                        //reader.readAsBinaryString(files[fileIndex]);

                    } else {
                        filesRejected++;
                    }
                } catch (err) {
                    // Remove from queue
                    processingQueue.forEach(function (value, key) {
                        if (value === fileIndex) processingQueue.splice(key, 1);
                    });
                    opts.error(errors[0]);
                    return false;
                }

                // If we still have work to do,
                if (workQueue.length > 0) {
                    process();
                }

            };

            var send = function (e) {

                var fileIndex = ((typeof (e.srcElement) === "undefined") ? e.target : e.srcElement).index

                // Sometimes the index is not attached to the
                // event object. Find it by size. Hack for sure.
                if (e.target.index == undefined) {
                    e.target.index = getIndexBySize(e.total);
                }

                var xhr = new XMLHttpRequest(),
                    upload = xhr.upload,
                    file = files[e.target.index],
                    index = e.target.index,
                    start_time = new Date().getTime(),
                    boundary = '------multipartformboundary' + (new Date).getTime(),
                    builder;

                newName = rename(file.name);
                mime = file.type
                if (typeof newName === "string") {
                    builder = getBuilder(newName, e.target.result, mime, boundary);
                } else {
                    builder = getBuilder(file.name, e.target.result, mime, boundary);
                }

                upload.index = index;
                upload.file = file;
                upload.downloadStartTime = start_time;
                upload.currentStart = start_time;
                upload.currentProgress = 0;
                upload.startData = 0;
                upload.addEventListener("progress", progress, false);


                xhr.open("POST", opts.url, true);
                xhr.setRequestHeader('content-type', 'multipart/form-data; boundary=' + boundary);

                // Add headers
                $.each(opts.headers, function (k, v) {
                    xhr.setRequestHeader(k, v);
                });

                xhr.sendAsBinary(builder);

                opts.uploadStarted(index, file, files_count);

                xhr.onload = function () {
                    if (xhr.responseText) {
                        var now = new Date().getTime(),
                            timeDiff = now - start_time,
                            result = opts.uploadFinished(index, file, jQuery.parseJSON(xhr.responseText), timeDiff, xhr);
                        filesDone++;

                        // Remove from processing queue
                        processingQueue.forEach(function (value, key) {
                            if (value === fileIndex) processingQueue.splice(key, 1);
                        });

                        // Add to donequeue
                        doneQueue.push(fileIndex);

                        if (filesDone == files_count - filesRejected) {
                            afterAll();
                        }
                        if (result === false) stop_loop = true;
                    }
                };

            }

            // Initiate the processing loop
            process();

        }

STEP 3 - The plugin return to the controller where I receive the file and try to save it:

[HttpPost]
public ActionResult UploadFiles(IEnumerable<HttpPostedFileBase> files)
            {                
                    byte[] binaryData;
                    binaryData = new Byte[file.InputStream.Length];
                    long bytesRead = file.InputStream.Read(binaryData, 0, (int)file.InputStream.Length);
                    file.InputStream.Close();
                    string base64String = System.Convert.ToBase64String(binaryData, 0, binaryData.Length);

                    byte[] bytes = System.Convert.FromBase64String(base64String);

                    //Salva arquivo físico em pasta provisória
                    string filePath = Path.Combine(ed_fisico_provisorio.vr_parametro, file.FileName);

                    System.IO.FileStream fs = System.IO.File.Create(filePath);

                    fs.Write(bytes, 0, bytes.Length);
                    fs.Close();
    }

The content of the saved file is as said above.

Any help will be appreciated.

Answer 1

It's a little unclear what technology you're using to receive the file (WEBAPI, MVC, Something Awesome) but I have used this in WebAPI 2 endpoints in the past and handled the file data using streams.

    public async Task<IHttpActionResult> Post()
    {
        var provider = new MultipartMemoryStreamProvider();
        var stream = await Request.Content.ReadAsMultipartAsync(provider).ConfigureAwait(false);

        // Returns the first file it finds
        var fileStream = stream.Contents.FirstOrDefault(x => x.Headers.ContentDisposition.FileName != null);

        // return a result
    }

With the fileStream object you can then use fileStream.ReadAsStreamAsync() or fileStream.ReadAsStringAsync() if the file contents is text.