public async Task WriteFileAsync(string share, string filename, Stream source, string contentType = "application/octet-stream", CancellationToken token = default(CancellationToken)) { if (string.IsNullOrEmpty(share)) { throw new ArgumentNullException("share"); } if (string.IsNullOrEmpty("filename")) { throw new ArgumentNullException("filename"); } if (source == null) { throw new ArgumentNullException("source"); } Exception error = null; Stopwatch watch = new Stopwatch(); watch.Start(); double time = watch.Elapsed.TotalMilliseconds; long bytesTransferred = 0; IProgress <StorageProgress> progressHandler = new Progress <StorageProgress>( progress => { bytesTransferred = bytesTransferred < progress.BytesTransferred ? progress.BytesTransferred : bytesTransferred; if (watch.Elapsed.TotalMilliseconds > time + 1000.0 && bytesTransferred <= progress.BytesTransferred) { OnUploadBytesTransferred?.Invoke(this, new BytesTransferredEventArgs(share, filename, bytesTransferred, source.Length)); } }); try { CloudFileShare choudShare = client.GetShareReference(share); CloudFileDirectory dir = choudShare.GetRootDirectoryReference(); CloudFile file = dir.GetFileReference(filename); file.Properties.ContentType = contentType; await file.UploadFromStreamAsync(source, source.Length, default(AccessCondition), default(FileRequestOptions), default(OperationContext), progressHandler, token); } catch (Exception ex) { if (ex.InnerException is TaskCanceledException) { source = null; } else { error = ex; throw ex; } } finally { watch.Stop(); OnUploadCompleted?.Invoke(this, new BlobCompleteEventArgs(share, filename, token.IsCancellationRequested, error)); } }
private void Remote_OnUploadCompleted(object sender, BlobCompleteEventArgs e) { if (uploadTokenSources.ContainsKey(e.Filename)) { uploadTokenSources.Remove(e.Filename); } OnUploadCompleted?.Invoke(this, e); }
void SendFileCallback(IAsyncResult result) { FTContainer.FTSocket.Client.EndSendFile(result); FTContainer.FTSocket.Client.Send(encoding.GetBytes("$End")); FTContainer.Sending = false; DebugLogging("File Uploaded"); OnUploadCompleted?.Invoke(FTContainer); }
public async Task WritePageBlobAsync(string containerName, string filename, byte[] source, string contentType = "application/octet-stream", CancellationToken token = default(CancellationToken)) { if (string.IsNullOrEmpty(filename)) { throw new ArgumentNullException("filename"); } if (source == null) { throw new ArgumentException("source"); } Exception error = null; Stopwatch watch = new Stopwatch(); watch.Start(); double time = watch.Elapsed.TotalMilliseconds; long bytesTransferred = 0; IProgress <StorageProgress> progressHandler = new Progress <StorageProgress>( progress => { bytesTransferred = bytesTransferred < progress.BytesTransferred ? progress.BytesTransferred : bytesTransferred; if (watch.Elapsed.TotalMilliseconds > time + 1000.0 && bytesTransferred <= progress.BytesTransferred) { OnUploadBytesTransferred?.Invoke(this, new BytesTransferredEventArgs(containerName, filename, bytesTransferred, source.Length)); } }); try { CloudBlobContainer container = await GetContainerReferenceAsync(containerName); CloudPageBlob blob = container.GetPageBlobReference(filename); blob.Properties.ContentType = contentType; await blob.UploadFromByteArrayAsync(source, 0, source.Length, null, default(AccessCondition), default(BlobRequestOptions), default(OperationContext), progressHandler, token); } catch (Exception ex) { if (ex.InnerException is TaskCanceledException) { source = null; } else { error = ex; throw ex; } } finally { watch.Stop(); OnUploadCompleted?.Invoke(this, new BlobCompleteEventArgs(containerName, filename, token.IsCancellationRequested, error)); } }
public async Task <byte[]> ReadFileAsync(string filename, CancellationToken token) { if (!File.Exists(filename)) { return(null); } await AccessWaitAsync(filename, TimeSpan.FromSeconds(5)); readContainer.Add(filename.ToLowerInvariant()); try { using (FileStream stream = new FileStream(filename, FileMode.Open, FileAccess.Read)) { byte[] message = null; int bytesRead = 0; do { if (token.IsCancellationRequested) { message = null; break; } byte[] buffer = new byte[ushort.MaxValue]; bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length); if (message == null) { message = new byte[bytesRead]; Buffer.BlockCopy(buffer, 0, message, 0, bytesRead); } else { byte[] temp = new byte[message.Length + buffer.Length]; Buffer.BlockCopy(message, 0, temp, 0, message.Length); Buffer.BlockCopy(buffer, 0, temp, message.Length, buffer.Length); message = temp; } } while (bytesRead > 0); return(message); } } finally { readContainer.Remove(filename.ToLowerInvariant()); if (token.IsCancellationRequested) { OnUploadCompleted?.Invoke(this, new BlobCompleteEventArgs(filename, true)); } } }
private void M_ftp2_UploadFileCompleted(object sender, System.Net.UploadFileCompletedEventArgs e) { try { OnUploadCompleted?.Invoke(sender, e); } catch (Exception ex) { Log.OutputBox(ex); Log.ShowError(m_ftp.ErrorMsg); } }
void HandOutFileCallback(IAsyncResult result) { FTSocketContainer ft = (FTSocketContainer)result.AsyncState; ft.FTSocket.Client.EndSendFile(result); ft.FTSocket.Client.Send(encoding.GetBytes("$End")); ft.Sending = false; DebugLogging("File Uploaded"); DequeueUpload(ft); OnUploadCompleted?.Invoke(ft); }
/// <summary> /// This method gives you access to the files that were uploaded /// </summary> /// <param name="eventArgs"></param> private async void OnFileChange(InputFileChangeEventArgs eventArgs) { // Starting the upload UploadComplete = false; //// Get access to the file if (!MultipleFiles) { await UploadFile(eventArgs.File); } else { try { // Will upload all the select files IReadOnlyList <IBrowserFile> files = eventArgs.GetMultipleFiles(MaxFileCount); foreach (IBrowserFile file in files) { await UploadFile(file); } } catch (InvalidOperationException) { // If this happens is because the has selected more files than allowed in MaxFileCount UploadedFileInfo uploadedFileInfo = new(null, null, false, null) { // Upload was aborted Aborted = true, ErrorMessage = FileCountExceededMessage, Exception = new Exception("The numbers of files to upload is bigger than maximum allowed.") }; // Notify the caller the upload was aborted due to an error FileUploaded(uploadedFileInfo); } } // The upload has completed UploadComplete = true; // Refresh the UI StateHasChanged(); // Fires the event to indicate that all files has been uploaded await OnUploadCompleted.InvokeAsync(); }
private async Task UploadAsync(CloudBlockBlob blob, byte[] buffer, CancellationToken token) { string fullpath = blob.Container.Name + "/" + blob.Name; Stopwatch watch = new Stopwatch(); watch.Start(); double time = watch.Elapsed.TotalMilliseconds; long bytesTransferred = 0; BlobRequestOptions options = new BlobRequestOptions(); options.SingleBlobUploadThresholdInBytes = 1048576; IProgress <StorageProgress> progressHandler = new Progress <StorageProgress>( progress => { bytesTransferred = bytesTransferred < progress.BytesTransferred ? progress.BytesTransferred : bytesTransferred; if (watch.Elapsed.TotalMilliseconds > time + 1000.0 && bytesTransferred <= progress.BytesTransferred) { OnUploadBytesTransferred?.Invoke(this, new BytesTransferredEventArgs(fullpath, buffer.Length, progress.BytesTransferred)); } }); try { await blob.UploadFromByteArrayAsync(buffer, 0, buffer.Length, default(AccessCondition), options, default(OperationContext), progressHandler, token); } catch (Exception ex) { watch.Stop(); if (ex.InnerException is TaskCanceledException) { buffer = null; } else { throw ex; } } OnUploadCompleted?.Invoke(this, new BlobCompleteEventArgs(fullpath, token.IsCancellationRequested)); }
private void Operations_OnUploadCompleted(object sender, BlobCompleteEventArgs e) { OnUploadCompleted?.Invoke(this, e); }
async void UploadProgress(UploadOperation upload) { LogStatus(string.Format("Progress: {0}, Status: {1}", upload.Guid, upload.Progress.Status)); MainPage.Current?.ShowMediaUploadingUc(); BackgroundUploadProgress progress = upload.Progress; double percentSent = 100; if (progress.TotalBytesToSend > 0) { percentSent = progress.BytesSent * 100 / progress.TotalBytesToSend; } SendNotify(percentSent); LogStatus(string.Format(" - Sent bytes: {0} of {1} ({2}%), Received bytes: {3} of {4}", progress.BytesSent, progress.TotalBytesToSend, percentSent, progress.BytesReceived, progress.TotalBytesToReceive)); if (progress.HasRestarted) { LogStatus(" - Upload restarted"); } if (progress.HasResponseChanged) { var resp = upload.GetResponseInformation(); LogStatus(" - Response updated; Header count: " + resp.Headers.Count); var response = upload.GetResultStreamAt(0); StreamReader stream = new StreamReader(response.AsStreamForRead()); Debug.WriteLine("----------------------------------------Response from upload----------------------------------"); var st = stream.ReadToEnd(); Debug.WriteLine(st); if (UploadItem.IsVideo) { if (!UploadItem.IsStory) { var thumbStream = (await UploadItem.ImageToUpload.OpenAsync(FileAccessMode.Read)).AsStream(); var bytes = await thumbStream.ToByteArray(); var img = new InstaImageUpload { ImageBytes = bytes, Uri = UploadItem.ImageToUpload.Path }; await UploadSinglePhoto(img, UploadId); } await Task.Delay(15000); if (!UploadItem.IsStory) { await FinishVideoAsync(); } await Task.Delay(1500); } if (!UploadItem.IsAlbum) { await ConfigurMediaAsync(); } else { OnUploadCompleted?.Invoke(this); } } }
/// <summary> /// 开始上传 /// </summary> /// <param name="upload"></param> public async void UploadStart(Upload upload) { UploadStatus = UploadStatus.Uploading; if (upload != null && upload.FileType != (int)FileType.UNKNOWN) { using (FileStream fileStream = new FileStream(upload.FilePath, FileMode.Open, FileAccess.Read)) { var buffer = new byte[CHUNKSIZE]; int chunkNumber = upload.ChunkNumber; int totalSize = upload.FileSize; int totalChunks = (int)Math.Ceiling((double)totalSize / CHUNKSIZE); int bytesRead = 0; int offset = chunkNumber * CHUNKSIZE; int uploadedLength = offset; fileStream.Seek((long)offset, SeekOrigin.Begin); while ((bytesRead = fileStream.Read(buffer, 0, buffer.Length)) != 0) { //如果暂停了 if (UploadStatus == UploadStatus.Pause) { break; } //开始时间 var watch = new Stopwatch(); watch.Start(); //byte转换 var finalBuffer = new byte[bytesRead]; Buffer.BlockCopy(buffer, 0, finalBuffer, 0, bytesRead); //上传一个分片 var response = await HttpManager.Instance.BreakPointUploadAsync <BreakPointUploadResponse>( new UploadAlbumFileRequest(upload.TargetId, upload.AlbumId, (AlbumType)upload.AlbumType, upload.FileName, (FileType)upload.FileType, upload.Identifier, totalSize, totalChunks, chunkNumber, CHUNKSIZE, bytesRead), finalBuffer ); Logger.Log(response.message); //当前分片上传失败(只要不是完成和分片成功都视为失败) if (!response.Ok && response.code != 201) { OnUploadFailure?.Invoke(); break; } //上传完成 if (response.Ok) { OnUploadCompleted?.Invoke(); UploadManager.DeleteUploader(upload); break; } var progress = Convert.ToDouble((uploadedLength / (Double)totalSize) * 100); //当前分片上传成功 upload.Progress = progress; upload.ChunkNumber = chunkNumber; var a = UploadManager.UpdateUploader(upload); chunkNumber++;//文件块序号+1 //结束时间 watch.Stop(); uploadedLength += bytesRead; //速度计算byte/s var speed = CHUNKSIZE * 1000L / watch.ElapsedMilliseconds; //计算剩余时间 var time = (totalSize - uploadedLength) / speed; //上传进度通知 OnUploadProgressChanged?.Invoke(progress, (int)time, speed / 1024); } } } }
public async Task UploadFileToBlockBlob(string filePath, string containerName, string blobFilename, string contentType = "application/octet-stream", CancellationToken token = default(CancellationToken)) { if (string.IsNullOrEmpty(filePath)) { throw new ArgumentNullException("filenamePath"); } if (string.IsNullOrEmpty(containerName)) { throw new ArgumentNullException("containerName"); } if (string.IsNullOrEmpty("blobFilename")) { throw new ArgumentNullException("blobFilename"); } if (!File.Exists(filePath)) { throw new FileNotFoundException(filePath); } Exception error = null; Stopwatch watch = new Stopwatch(); watch.Start(); double time = watch.Elapsed.TotalMilliseconds; long bytesTransferred = 0; IProgress <StorageProgress> progressHandler = new Progress <StorageProgress>( progress => { bytesTransferred = bytesTransferred < progress.BytesTransferred ? progress.BytesTransferred : bytesTransferred; FileInfo info = new FileInfo(filePath); if (watch.Elapsed.TotalMilliseconds > time + 1000.0 && bytesTransferred <= progress.BytesTransferred) { OnUploadBytesTransferred?.Invoke(this, new BytesTransferredEventArgs(containerName, blobFilename, bytesTransferred, info.Length)); } }); try { CloudBlobContainer container = await GetContainerReferenceAsync(containerName); CloudBlockBlob blob = container.GetBlockBlobReference(blobFilename); await blob.UploadFromFileAsync(filePath, default(AccessCondition), default(BlobRequestOptions), default(OperationContext), progressHandler, token); } catch (Exception ex) { if (!(ex.InnerException is TaskCanceledException)) { error = ex; throw ex; } } finally { watch.Stop(); OnUploadCompleted?.Invoke(this, new BlobCompleteEventArgs(containerName, blobFilename, token.IsCancellationRequested, error)); } }