public async Task<UploadedFileInfo> TransmitFileAsync(RestHost host, string url, UploadedFile file, Action<FileUploadProgress> progressAction,
             Action<HttpWebRequest> adjustRequest)
        {
            ExceptionDispatchInfo capturedException = null;
            int totalChunks = (int)Math.Ceiling((double)file.FileData.Length / MAX_CHUNK_SIZE_BYTES);
            int currentChunk = 1;
            UploadedFileInfo fileResponse = new UploadedFileInfo(file.UploadContext);
            using (var rdr = new BinaryReader(file.FileData))

                for (var i = currentChunk; i <= totalChunks; i++)
                {
                    FileUploadProgress progress = new FileUploadProgress() { UploadContext = file.UploadContext };
                    string boundary = Guid.NewGuid().ToString("N");
                    var chunk = rdr.ReadBytes(MAX_CHUNK_SIZE_BYTES);
                    var bytesToSend = PrepareDataChunk(chunk, currentChunk, boundary, totalChunks, file);

                    var request = CreateRequest(host, url, adjustRequest, host.PostTimeout);
                    request.Method = "POST";

                    try
                    {

                        request.ContentType = "multipart/form-data; boundary=" + boundary;
                        request.ContentLength = bytesToSend.Length;
                        using (var requestStream =await  request.GetRequestStreamAsync())
                        {
                            await requestStream.WriteAsync(bytesToSend, 0, bytesToSend.Length);

                            requestStream.Close();
                        }

                        using (HttpWebResponse response =  (HttpWebResponse)await request.GetResponseAsync())
                        {
                            var str = response.GetResponseStream();
                        }


                        if (progressAction != null)
                            progressAction(progress);

                        currentChunk++;

                    }
                    catch (Exception ex)
                    {

                        capturedException = ExceptionDispatchInfo.Capture(ex);
                    }

                    if (capturedException != null )
                    {
                        fileResponse.IsError = true;
                        fileResponse.Message = capturedException.SourceException.Message;
                        var webException = capturedException.SourceException as WebException;
                        if (webException != null  )
                        {
                            var errorResponse = webException.Response as HttpWebResponse;
                            if (errorResponse != null && errorResponse.StatusCode == HttpStatusCode.InternalServerError)
                            {
                                var resp = await ReadUploadErrorAsync(errorResponse.GetResponseStream());
                                if (resp != null && resp.error != null)
                                {
                                    fileResponse.Message = resp.error.message;
                                }

                            }
                        }
                    }

                }
            return fileResponse;
        }
        public UploadedFileInfo TransmitFile(RestHost host, string url, UploadedFile file,Action<FileUploadProgress> progressAction,
            Action<HttpWebRequest> adjustRequest)
        {

            int totalChunks = (int)Math.Ceiling((double)file.FileData.Length / MAX_CHUNK_SIZE_BYTES);
            int currentChunk = 1;
            UploadedFileInfo fileResponse = new UploadedFileInfo(file.UploadContext);
            using (var rdr = new BinaryReader(file.FileData))
                
                for(var i =currentChunk;i<= totalChunks;i++)
                {
                    FileUploadProgress progress = new FileUploadProgress() {UploadContext = file.UploadContext };
                    string boundary = Guid.NewGuid().ToString("N");
                    var chunk = rdr.ReadBytes(MAX_CHUNK_SIZE_BYTES);
                    var bytesToSend = PrepareDataChunk(chunk, currentChunk, boundary, totalChunks, file);

                    var request = CreateRequest(host, url, adjustRequest, host.PostTimeout);
                    request.Method = "POST";
         
                        try
                        {

                            request.ContentType = "multipart/form-data; boundary=" + boundary;
                            request.ContentLength = bytesToSend.Length;
                            using (var requestStream = request.GetRequestStream())
                            {
                                requestStream.Write(bytesToSend, 0, bytesToSend.Length);
                               
                                requestStream.Close();
                            }

                            using (var response = (HttpWebResponse)request.GetResponse())
                            {
                                var stream = response.GetResponseStream();
                                if (stream != null)
                                {
                                   using (var reader = new StreamReader(stream))
                                    {
                                        var responseData = reader.ReadToEnd();
                                        if (!string.IsNullOrEmpty(responseData))
                                        {
                                            var uploadResponse = JsonConvert.Deserialize(responseData);
                                            fileResponse.DownloadUrl = uploadResponse.result.downloadUrl;
                                        }
                                    }
                                }
                            }


                            if (progressAction != null)
                                progressAction(progress);

                            currentChunk ++;
                            
                        }
                        catch (Exception  ex)
                        {

                            fileResponse.IsError = true;
                            fileResponse.Message =ex.Message;
                            var webException =  ex as WebException;
                            if (webException != null)
                            {
                                var errorResponse = webException.Response as HttpWebResponse;
                                if (errorResponse != null && errorResponse.StatusCode == HttpStatusCode.InternalServerError)
                                {
                                    var resp =  ReadUploadError(errorResponse.GetResponseStream());
                                    if (resp != null && resp.error != null)
                                    {
                                        fileResponse.Message = resp.error.message;
                                    }

                                }
                            }
                        }
                        
                }
            return fileResponse;
        }