public async ValueTask <IFileReference> SaveAsync(byte[] data, IPrivateFileReference file, string contentType, OverwritePolicy overwritePolicy = OverwritePolicy.Always, IDictionary <string, string> metadata = null) { using (var stream = new SyncMemoryStream(data, 0, data.Length)) { return(await this.SaveAsync(stream, file, contentType, overwritePolicy, metadata)); } }
/// <summary> /// Downloads string content of the given blob. If encoding is not specified, it removes the BOM mark from beginning of the string if exists. /// </summary> /// <param name="blob">CloudBlockBlob to download contents.</param> /// <param name="encoding">Encoding which should be used to convert the content of blob to string. If encoding is not specified, it removes the BOM mark from beginning of the string if exists.</param> /// <returns>string content of the given blob.</returns> public static string DownloadString(this CloudBlockBlob blob, System.Text.Encoding encoding = null, AccessCondition accessCondition = null, BlobRequestOptions options = null, OperationContext operationContext = null) { using (SyncMemoryStream stream = new SyncMemoryStream()) { blob.DownloadToStream(stream, accessCondition, options, operationContext); byte[] streamAsBytes = stream.GetBuffer(); return(GetStringUsingEncoding(streamAsBytes, encoding)); } }
public async Task WriteAsync(string filePath, byte[] bytes) { if (string.IsNullOrWhiteSpace(filePath)) { throw new ArgumentNullException(nameof(filePath)); } filePath = Url.DirToUrlSeparator(filePath); //Ensure the directory exists var directory = Url.GetDirectoryName(filePath); if (!string.IsNullOrWhiteSpace(directory) && !await GetDirectoryExistsAsync(directory)) { await CreateDirectoryAsync(directory); } var file = await GetFileAsync(filePath); var stream = new SyncMemoryStream(bytes, 0, bytes.Length); await file.UploadFromStreamAsync(stream); }
public ICancellableAsyncResult BeginDownloadRangeToByteArray(byte[] target, int index, long? blobOffset, long? length, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, AsyncCallback callback, object state) { SyncMemoryStream stream = new SyncMemoryStream(target, index); StorageAsyncResult<int> storageAsyncResult = new StorageAsyncResult<int>(callback, state) { OperationState = stream }; ICancellableAsyncResult result = this.BeginDownloadRangeToStream( stream, blobOffset, length, accessCondition, options, operationContext, this.DownloadRangeToByteArrayCallback, storageAsyncResult); storageAsyncResult.CancelDelegate = result.Cancel; return storageAsyncResult; }
public int DownloadRangeToByteArray(byte[] target, int index, long? blobOffset, long? length, AccessCondition accessCondition = null, BlobRequestOptions options = null, OperationContext operationContext = null) { using (SyncMemoryStream stream = new SyncMemoryStream(target, index)) { this.DownloadRangeToStream(stream, blobOffset, length, accessCondition, options, operationContext); return (int)stream.Position; } }
/// <summary> /// Begins an asynchronous operation to download the blob's contents as a string. /// </summary> /// <param name="encoding">An object that indicates the text encoding to use.</param> /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the access conditions for the blob.</param> /// <param name="options">An object that specifies any additional options for the request.</param> /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param> /// <param name="callback">The callback delegate that will receive notification when the asynchronous operation completes.</param> /// <param name="state">A user-defined object that will be passed to the callback delegate.</param> /// <returns>An <see cref="ICancellableAsyncResult"/> that references the asynchronous operation.</returns> public ICancellableAsyncResult BeginDownloadText(Encoding encoding, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, AsyncCallback callback, object state) { SyncMemoryStream stream = new SyncMemoryStream(); StorageAsyncResult<string> storageAsyncResult = new StorageAsyncResult<string>(callback, state) { OperationState = Tuple.Create(stream, encoding) }; ICancellableAsyncResult result = this.BeginDownloadToStream( stream, accessCondition, options, operationContext, this.DownloadTextCallback, storageAsyncResult); storageAsyncResult.CancelDelegate = result.Cancel; return storageAsyncResult; }
/// <summary> /// Downloads the blob's contents as a string. /// </summary> /// <param name="encoding">An object that indicates the text encoding to use.</param> /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the access conditions for the blob.</param> /// <param name="options">An object that specifies any additional options for the request.</param> /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param> /// <returns>The contents of the blob, as a string.</returns> public string DownloadText(Encoding encoding = null, AccessCondition accessCondition = null, BlobRequestOptions options = null, OperationContext operationContext = null) { using (SyncMemoryStream stream = new SyncMemoryStream()) { this.DownloadToStream(stream, accessCondition, options, operationContext); byte[] streamAsBytes = stream.GetBuffer(); return (encoding ?? Encoding.UTF8).GetString(streamAsBytes, 0, (int)stream.Length); } }
public ICancellableAsyncResult BeginUploadFromByteArray(byte[] buffer, int index, int count, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, AsyncCallback callback, object state) { CommonUtility.AssertNotNull("buffer", buffer); SyncMemoryStream stream = new SyncMemoryStream(buffer, index, count); return this.BeginUploadFromStream(stream, accessCondition, options, operationContext, callback, state); }
public void UploadFromByteArray(byte[] buffer, int index, int count, AccessCondition accessCondition = null, BlobRequestOptions options = null, OperationContext operationContext = null) { CommonUtility.AssertNotNull("buffer", buffer); using (SyncMemoryStream stream = new SyncMemoryStream(buffer, index, count)) { this.UploadFromStream(stream, accessCondition, options, operationContext); } }
public virtual Task UploadFromByteArrayAsync(byte[] buffer, int index, int count, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken) { CommonUtility.AssertNotNull("buffer", buffer); SyncMemoryStream stream = new SyncMemoryStream(buffer, index, count); return this.UploadFromStreamAsync(stream, accessCondition, options, operationContext, cancellationToken); }
internal ICancellableAsyncResult BeginUploadFromStreamHelper(Stream source, long? length, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext, AsyncCallback callback, object state) { CommonUtility.AssertNotNull("source", source); if (length.HasValue) { CommonUtility.AssertInBounds("length", length.Value, 1); if (source.CanSeek && length > source.Length - source.Position) { throw new ArgumentOutOfRangeException("length", SR.StreamLengthShortError); } } this.attributes.AssertNoSnapshot(); BlobRequestOptions modifiedOptions = BlobRequestOptions.ApplyDefaults(options, BlobType.BlockBlob, this.ServiceClient); ExecutionState<NullType> tempExecutionState = CommonUtility.CreateTemporaryExecutionState(modifiedOptions); StorageAsyncResult<NullType> storageAsyncResult = new StorageAsyncResult<NullType>(callback, state); bool lessThanSingleBlobThreshold = CloudBlockBlob.IsLessThanSingleBlobThreshold(source, length, modifiedOptions, false); modifiedOptions.AssertPolicyIfRequired(); if (modifiedOptions.ParallelOperationThreadCount.Value == 1 && lessThanSingleBlobThreshold) { // Because we may or may not want to calculate the MD5, and we may or may not want to encrypt, rather than have four branching code // paths, here we have an action that we will run, which continually gets added to, depending on which operations we need to do. // The confusing part is that we have to build it from the bottom up. string md5 = null; Stream sourceStream = source; Action actionToRun = null; Action uploadAction = () => { if (md5 == null && modifiedOptions.UseTransactionalMD5.Value) { throw new ArgumentException(SR.PutBlobNeedsStoreBlobContentMD5, "options"); } this.UploadFromStreamHandler( sourceStream, length, md5, accessCondition, operationContext, modifiedOptions, storageAsyncResult); }; actionToRun = uploadAction; if (modifiedOptions.StoreBlobContentMD5.Value) { Action<Action> calculateMD5 = (continuation) => { long startPosition = sourceStream.Position; StreamDescriptor streamCopyState = new StreamDescriptor(); sourceStream.WriteToAsync( Stream.Null, length, null /* maxLength */, true, tempExecutionState, streamCopyState, completedState => { ContinueAsyncOperation(storageAsyncResult, completedState, () => { if (completedState.ExceptionRef != null) { storageAsyncResult.OnComplete(completedState.ExceptionRef); } else { sourceStream.Position = startPosition; md5 = streamCopyState.Md5; continuation(); } }); }); storageAsyncResult.CancelDelegate = tempExecutionState.Cancel; if (storageAsyncResult.CancelRequested) { storageAsyncResult.Cancel(); } }; Action oldActionToRun = actionToRun; actionToRun = () => calculateMD5(oldActionToRun); } if (modifiedOptions.EncryptionPolicy != null) { Action<Action> encryptStream = continuation => { SyncMemoryStream syncMemoryStream = new SyncMemoryStream(); options.AssertPolicyIfRequired(); sourceStream = syncMemoryStream; if (modifiedOptions.EncryptionPolicy.EncryptionMode != BlobEncryptionMode.FullBlob) { throw new InvalidOperationException(SR.InvalidEncryptionMode, null); } ICryptoTransform transform = options.EncryptionPolicy.CreateAndSetEncryptionContext(this.Metadata, false /* noPadding */); CryptoStream cryptoStream = new CryptoStream(syncMemoryStream, transform, CryptoStreamMode.Write); StreamDescriptor streamCopyState = new StreamDescriptor(); source.WriteToAsync(cryptoStream, length, null, false, tempExecutionState, streamCopyState, completedState => { ContinueAsyncOperation(storageAsyncResult, completedState, () => { if (completedState.ExceptionRef != null) { storageAsyncResult.OnComplete(completedState.ExceptionRef); } else { // Flush the CryptoStream in order to make sure that the last block of data is flushed. This call is a sync call // but it is ok to have it because we're just writing to a memory stream. cryptoStream.FlushFinalBlock(); // After the tempStream has been written to, we need to seek back to the beginning, so that it can be read from. sourceStream.Seek(0, SeekOrigin.Begin); length = syncMemoryStream.Length; continuation(); } }); }); storageAsyncResult.CancelDelegate = tempExecutionState.Cancel; if (storageAsyncResult.CancelRequested) { storageAsyncResult.Cancel(); } }; Action oldActionToRun = actionToRun; actionToRun = () => encryptStream(oldActionToRun); } actionToRun(); } else { ICancellableAsyncResult result = this.BeginOpenWrite( accessCondition, modifiedOptions, operationContext, ar => { ContinueAsyncOperation(storageAsyncResult, ar, () => { CloudBlobStream blobStream = this.EndOpenWrite(ar); storageAsyncResult.OperationState = blobStream; source.WriteToAsync( blobStream, length, null /* maxLength */, false, tempExecutionState, null /* streamCopyState */, completedState => { ContinueAsyncOperation(storageAsyncResult, completedState, () => { if (completedState.ExceptionRef != null) { storageAsyncResult.OnComplete(completedState.ExceptionRef); } else { ICancellableAsyncResult commitResult = blobStream.BeginCommit( CloudBlob.BlobOutputStreamCommitCallback, storageAsyncResult); storageAsyncResult.CancelDelegate = commitResult.Cancel; if (storageAsyncResult.CancelRequested) { storageAsyncResult.Cancel(); } } }); }); storageAsyncResult.CancelDelegate = tempExecutionState.Cancel; if (storageAsyncResult.CancelRequested) { storageAsyncResult.Cancel(); } }); }, null /* state */); // We do not need to do this inside a lock, as storageAsyncResult is // not returned to the user yet. storageAsyncResult.CancelDelegate = result.Cancel; } return storageAsyncResult; }
public IAsyncOperation<int> DownloadRangeToByteArrayAsync([WriteOnlyArray] byte[] target, int index, long? fileOffset, long? length, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext) { return AsyncInfo.Run(async (token) => { using (SyncMemoryStream stream = new SyncMemoryStream(target, index)) { await this.DownloadRangeToStreamAsync(stream.AsOutputStream(), fileOffset, length, accessCondition, options, operationContext).AsTask(token); return (int)stream.Position; } }); }
/// <summary> /// Downloads the file's contents as a string. /// </summary> /// <param name="accessCondition">An <see cref="AccessCondition"/> object that represents the access conditions for the file.</param> /// <param name="options">An object that specifies additional options for the request.</param> /// <param name="operationContext">An <see cref="OperationContext"/> object that represents the context for the current operation.</param> /// <param name="cancellationToken">A <see cref="CancellationToken"/> to observe while waiting for a task to complete.</param> /// <returns>The contents of the file, as a string.</returns> public Task<string> DownloadTextAsync(AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken) { return Task.Run(async () => { using (SyncMemoryStream stream = new SyncMemoryStream()) { await this.DownloadToStreamAsync(stream, accessCondition, options, operationContext, cancellationToken); byte[] streamAsBytes = stream.ToArray(); return Encoding.UTF8.GetString(streamAsBytes, 0, streamAsBytes.Length); } }, cancellationToken); }
public IAsyncOperation<string> DownloadTextAsync(AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext) { return AsyncInfo.Run(async (token) => { using (SyncMemoryStream stream = new SyncMemoryStream()) { await this.DownloadToStreamAsync(stream.AsOutputStream(), accessCondition, options, operationContext).AsTask(token); byte[] streamAsBytes = stream.ToArray(); return Encoding.UTF8.GetString(streamAsBytes, 0, streamAsBytes.Length); } }); }
public IAsyncAction UploadFromByteArrayAsync([ReadOnlyArray] byte[] buffer, int index, int count, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext) { CommonUtility.AssertNotNull("buffer", buffer); SyncMemoryStream stream = new SyncMemoryStream(buffer, index, count); return this.UploadFromStreamAsync(stream.AsInputStream(), accessCondition, options, operationContext); }
public Task<int> DownloadRangeToByteArrayAsync(byte[] target, int index, long? fileOffset, long? length, AccessCondition accessCondition, FileRequestOptions options, OperationContext operationContext, CancellationToken cancellationToken) { return Task.Run(async () => { using (SyncMemoryStream stream = new SyncMemoryStream(target, index)) { await this.DownloadRangeToStreamAsync(stream, fileOffset, length, accessCondition, options, operationContext, cancellationToken); return (int)stream.Position; } }, cancellationToken); }