/// <inheritdoc /> public async Task <Uri> StoreFileAsync( VersionedInstanceIdentifier versionedInstanceIdentifier, Stream stream, CancellationToken cancellationToken) { EnsureArg.IsNotNull(versionedInstanceIdentifier, nameof(versionedInstanceIdentifier)); EnsureArg.IsNotNull(stream, nameof(stream)); BlockBlobClient blob = GetInstanceBlockBlob(versionedInstanceIdentifier); stream.Seek(0, SeekOrigin.Begin); var blobUploadOptions = new BlobUploadOptions { TransferOptions = _options.Upload }; try { await blob.UploadAsync( stream, blobUploadOptions, cancellationToken); return(blob.Uri); } catch (Exception ex) { throw new DataStoreException(ex); } }
private async Task <string> UploadImageAsync(HttpPostedFileBase fileToUpload) { try { string connectionString = Environment.GetEnvironmentVariable("AZURE_STORAGE_CONNECTION_STRING"); BlobServiceClient blobServiceClient = new BlobServiceClient(connectionString); string containerName = "techstoreimage"; BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(containerName); string fileName = Guid.NewGuid().ToString() + ".jpg"; BlobClient blobClient = containerClient.GetBlobClient(fileName); BlobUploadOptions blobUploadOptions = new BlobUploadOptions { HttpHeaders = new BlobHttpHeaders { ContentType = "image/jpeg" } }; await blobClient.UploadAsync(fileToUpload.InputStream, blobUploadOptions); return(blobClient.Uri.AbsoluteUri); } catch { } return("default.jpg"); }
public async Task Step2_cause_blob_to_end_up_in_a_limbo_state_by_moving_it() { // Download the blob var serviceClient = new BlobServiceClient(connectionString); var containerClient = serviceClient.GetBlobContainerClient("repro"); var blobClient = containerClient.GetBlobClient("aabbccdd-1122-3344-5566-778899aabbcc.txt"); var response = await blobClient.DownloadAsync(); // upload to the destination - first two characters and then the original blob var uploadClient = containerClient.GetBlobClient("aa/aabbccdd-1122-3344-5566-778899aabbcc.txt"); // The code set the LocalId in case this is an insert and verifies the blob tag value is lesser value in case it's an update var options = new BlobUploadOptions { Tags = new Dictionary <string, string> { { "LocalId", "123" } }, Conditions = new BlobRequestConditions { TagConditions = $@"""LocalId"" < '123'" } }; try { await uploadClient.UploadAsync(response.Value.Content, options); } catch (RequestFailedException exception) when(exception.ErrorCode == BlobErrorCode.ConditionNotMet) { output.WriteLine("The blob 'repo/aa/aabbccdd-1122-3344-5566-778899aabbcc.txt' is now a limbo state."); } }
protected void SendFile(BlobClient blob, string fileNameAndPath) { if (!File.Exists(fileNameAndPath)) { throw new CantSendFileDataWhenFileDoesNotExistException(fileNameAndPath); } if (!overwrite && blob.ExistsAsync().Result) { return; } using (StreamReader sr = new StreamReader(fileNameAndPath)) { var uploadOptions = new BlobUploadOptions() { HttpHeaders = new BlobHttpHeaders() { ContentHash = ComputeHash(fileNameAndPath) }, TransferOptions = new global::Azure.Storage.StorageTransferOptions() { InitialTransferSize = 50000000 } }; blob.Upload(sr.BaseStream, uploadOptions); } }
public async Task UploadAsync_Stream_Tags() { // Arrange await using DisposingContainer test = await GetTestContainerAsync(); var name = GetNewBlobName(); BlobClient blob = InstrumentClient(test.Container.GetBlobClient(name)); var data = GetRandomBuffer(Constants.KB); IDictionary <string, string> tags = BuildTags(); BlobUploadOptions options = new BlobUploadOptions { Tags = tags }; // Act using (var stream = new MemoryStream(data)) { await blob.UploadAsync(stream, options); } Response <GetBlobTagResult> response = await blob.GetTagsAsync(); // Assert AssertDictionaryEquality(tags, response.Value.Tags); }
/// <summary> /// Adds a new item to the container /// </summary> /// <param name="file">File object that will be added</param> /// <returns>A storage item representing the added item</returns> public async Task <StoredItem> AddItem(IFormFile file, string containerName) { var container = await GetContainer(containerName); var blobClient = container.GetBlobClient(Guid.NewGuid().ToString()); // Configure the content type and store the original file name as metadata BlobUploadOptions options = new BlobUploadOptions(); options.HttpHeaders = new BlobHttpHeaders { ContentType = file.ContentType }; options.Metadata = new Dictionary <string, string>() { { Constants.FileNameMetadataItemName, file.FileName } }; // Upload the file using (var stream = file.OpenReadStream()) { await blobClient.UploadAsync(stream, options); } // Return uploaded file info as storage item return(new StoredItem { Name = file.FileName, Location = blobClient.Name, FileSize = file.Length }); }
private async Task <string> PersistFileToAzureStorage( BlobFileUpload blobFileUpload, IFormFile formFile, CancellationToken cancellationToken = default) { var storage = _configuration.GetValue <string>("AzureStorage:StorageAndContainerName"); var fileFullName = $"{storage}{blobFileUpload.Name}"; var blobUri = new Uri(fileFullName); var blobUploadOptions = new BlobUploadOptions { Metadata = new Dictionary <string, string> { { "uploadedBy", blobFileUpload.UploadedBy }, { "description", blobFileUpload.Description } } }; var blobClient = new BlobClient(blobUri, _tokenAcquisitionTokenCredential); var inputStream = formFile.OpenReadStream(); await blobClient.UploadAsync(inputStream, blobUploadOptions, cancellationToken); return($"{blobFileUpload.Name} successfully saved to Azure Storage Container"); }
public async Task <BlobCreateResultModel> CreateAsync(string containerName, string blobName, Stream stream, string contentType = "", CancellationToken cancellationToken = default) { try { var containerClient = GetBlobContainerClient(containerName); EnsureContainerCreated(containerClient); var blobClient = containerClient.GetBlobClient(blobName); var uploadOptions = new BlobUploadOptions(); if (!string.IsNullOrWhiteSpace(contentType)) { uploadOptions.HttpHeaders = new BlobHttpHeaders { ContentType = contentType }; } var result = await blobClient.UploadAsync(stream, uploadOptions, cancellationToken); return(new BlobCreateResultModel { ContainerName = blobClient.BlobContainerName, BlobName = blobClient.Name, Uri = blobClient.Uri.ToString(), }); } catch (Exception ex) { logger.LogError(ex.Message); throw; } }
void UploadText(BlobClient blob, string text, BlobRequestConditions conditions) { //var properties = blob.GetProperties(); var headers = new BlobHttpHeaders { // Set the MIME ContentType every time the properties // are updated or the field will be cleared ContentType = "text/plain", ContentLanguage = "en-us", // Populate remaining headers with // the pre-existing properties //CacheControl = properties.Value.CacheControl, //ContentDisposition = properties.Value.ContentDisposition, ContentEncoding = "UTF-8", // properties.Value.ContentEncoding, //ContentHash = properties.Value.ContentHash }; // Set the blob's properties. //blob.SetHttpHeaders(headers); using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(text))) { // Set the If-Match condition to the original ETag. var options = new BlobUploadOptions() { Conditions = conditions, HttpHeaders = headers, }; blob.Upload(stream, options); } }
private static async Task <string> ImageUploadToBlob(string fileName, MemoryStream imageStream, string contentType, AppSettings appSettings) { var containerName = appSettings.MediaStorageContainer; var storageConnectionString = appSettings.MediaStorageConnectionString; //create a blob container client BlobContainerClient blobContainerClient = new BlobContainerClient(storageConnectionString, containerName); //create a blob BlobClient blobClient = blobContainerClient.GetBlobClient(fileName); var blobUploadOptions = new BlobUploadOptions { HttpHeaders = new BlobHttpHeaders { ContentType = contentType } }; await blobClient.UploadAsync(imageStream, blobUploadOptions); //get url (without query string as it will contain SAS token if used in connection string) string url = blobClient.Uri.GetLeftPart(UriPartial.Path); return(url); }
/// <summary> /// Uploads the image to azure blob storage /// </summary> /// <param name="file"> file to upload </param> /// <returns> new BlobClient object </returns> public async Task <BlobClient> UploadImage(IFormFile file) { BlobContainerClient container = new BlobContainerClient(Configuration["ImageBlob"], "images"); await container.CreateIfNotExistsAsync(); BlobClient blob = container.GetBlobClient(file.FileName); using var stream = file.OpenReadStream(); BlobUploadOptions options = new BlobUploadOptions() { HttpHeaders = new BlobHttpHeaders() { ContentType = file.ContentType } }; if (!blob.Exists()) { await blob.UploadAsync(stream, options); } return(blob); }
/// <inheritdoc/> public async Task UploadBlobAsync( BlobContainerClient containerClient, string blobName, Stream input, string contentType, string contentEncoding, CancellationToken cancellationToken = default) { try { // Ensure container is created await containerClient.CreateIfNotExistsAsync(PublicAccessType.None, cancellationToken : cancellationToken); var headers = new BlobHttpHeaders { ContentEncoding = contentEncoding, ContentType = contentType, }; var options = new BlobUploadOptions { HttpHeaders = headers, }; // Upload blob BlobClient blob = containerClient.GetBlobClient(blobName); await blob.UploadAsync(input, options, cancellationToken); } catch (Exception ex) { throw CreateException(ex, "Could not upload BLOB", containerClient.Name, blobName); } }
private static void UploadImages(bool upload1000) { Console.WriteLine("Uploading images"); int uploaded = 0; // Setup the number of the concurrent operations. BlobUploadOptions options = new BlobUploadOptions { TransferOptions = new Azure.Storage.StorageTransferOptions { MaximumConcurrency = 64 } }; // Set ServicePointManager.DefaultConnectionLimit to the number of eight times the number of cores. ServicePointManager.DefaultConnectionLimit = Environment.ProcessorCount * 8; ServicePointManager.Expect100Continue = false; // Setup the transfer context and track the upload progress. //var context = new SingleTransferContext //{ // ProgressHandler = // new Progress<TransferStatus>( // (progress) => { Console.WriteLine("Bytes uploaded: {0}", progress.BytesTransferred); }) //}; if (upload1000) { LoadImagesFromDisk(true); for (var i = 0; i < 200; i++) { foreach (var image in _sourceImages) { // Rewind the memory stream image.Position = 0; var filename = GenerateRandomFileName(); var blobBlockClient = new BlockBlobClient(BlobStorageConnection, "images", filename); var task = blobBlockClient.UploadAsync(image, options); task.Wait(); uploaded++; Console.WriteLine($"Uploaded image {uploaded}: {filename}"); } } } else { LoadImagesFromDisk(false); foreach (var image in _sourceImages) { var filename = GenerateRandomFileName(); var blobBlockClient = new BlockBlobClient(BlobStorageConnection, "images", filename); var task = blobBlockClient.UploadAsync(image, options); task.Wait(); uploaded++; Console.WriteLine($"Uploaded image {uploaded}: {filename}"); } } Console.WriteLine("Finished uploading images"); }
internal byte[] GetThumbnail(string fileId, string fileName, int width, int height, int align) { byte[] bytes = null; string thumbBlobName = $"{ObjectType}/{ObjectId}/{width}x{height}x{align}/{fileName}"; var thumbBlob = Container.GetBlobClient(thumbBlobName); if (thumbBlob.Exists()) { var downloadResult = thumbBlob.DownloadContent().Value; bytes = downloadResult.Content.ToArray(); } else { var imageBlob = Container.GetBlobClient(fileId); if (imageBlob.Exists()) { Stream imageStream = null; MemoryStream thumbStream = null; try { var downloadResult = imageBlob.DownloadContent().Value; imageStream = downloadResult.Content.ToStream(); thumbStream = new MemoryStream(); Thumbnail.Create(imageStream, fileName, width, height, align, thumbStream); var uploadOptions = new BlobUploadOptions { HttpHeaders = new BlobHttpHeaders { ContentType = MimeType.Jpeg, CacheControl = Settings.ClientCacheControl } }; thumbBlob.Upload(thumbStream, uploadOptions); thumbStream.Position = 0; bytes = thumbStream.ToArray(); } finally { imageStream?.Dispose(); thumbStream?.Dispose(); } } } return(bytes); }
public string UploadImage(string id, Stream stream, string contentType) { BlobClient blobClient = _blobContainerClient.GetBlobClient(id); var options = new BlobUploadOptions { HttpHeaders = new BlobHttpHeaders { ContentType = contentType }, }; blobClient.Upload(stream, options); return(blobClient.Uri.AbsoluteUri); }
public Task FileUploadAsync(string name, MemoryStream file, string mimetype, CancellationToken cancellationToken) { BlobClient blob = _assetsContainer.GetBlobClient(name); var options = new BlobUploadOptions { HttpHeaders = new BlobHttpHeaders { ContentType = mimetype } }; return(blob.UploadAsync(file, options, cancellationToken)); }
/// <inheritdoc/> public async Task <Response <BlobContentInfo> > WritePolicyConditionallyAsync(string filepath, Stream fileStream, string blobLeaseId) { BlobClient blobClient = CreateBlobClient(filepath); BlobUploadOptions blobUploadOptions = new BlobUploadOptions() { Conditions = new BlobRequestConditions() { LeaseId = blobLeaseId } }; return(await WriteBlobStreamInternal(blobClient, fileStream, blobUploadOptions)); }
/// <inheritdoc/> public async ValueTask PutFileAsync(IFileSystemEntry entry, CancellationToken cancellationToken = default) { var options = new BlobUploadOptions { HttpHeaders = new BlobHttpHeaders { ContentType = entry.ContentType, } }; // TODO: Check file size limit here. using Stream stream = await entry.CreateReadStreamAsync(); _ = await this.container.GetBlobClient(entry.Name).UploadAsync(stream, options, cancellationToken); }
private async Task WriteStateAndCreateContainerIfNotExists <T>(string grainType, GrainReference grainId, IGrainState <T> grainState, BinaryData contents, string mimeType, BlobClient blob) { try { var conditions = string.IsNullOrEmpty(grainState.ETag) ? new BlobRequestConditions { IfNoneMatch = ETag.All } : new BlobRequestConditions { IfMatch = new ETag(grainState.ETag) }; var options = new BlobUploadOptions { HttpHeaders = new BlobHttpHeaders { ContentType = mimeType }, Conditions = conditions, }; var result = await DoOptimisticUpdate( () => blob.UploadAsync(contents, options), blob, grainState.ETag) .ConfigureAwait(false); grainState.ETag = result.Value.ETag.ToString(); grainState.RecordExists = true; } catch (RequestFailedException exception) when(exception.IsContainerNotFound()) { // if the container does not exist, create it, and make another attempt if (this.logger.IsEnabled(LogLevel.Trace)) { this.logger.LogTrace((int)AzureProviderErrorCode.AzureBlobProvider_ContainerNotFound, "Creating container: GrainType={GrainType} GrainId={GrainId} ETag={ETag} to BlobName={BlobName} in Container={ContainerName}", grainType, grainId, grainState.ETag, blob.Name, container.Name); } await container.CreateIfNotExistsAsync().ConfigureAwait(false); await WriteStateAndCreateContainerIfNotExists(grainType, grainId, grainState, contents, mimeType, blob).ConfigureAwait(false); } }
public async Task Second_upload_of_blob_from_RetryableStreamImpl_with_tags_and_INvalid_conditions_should_NOT_overwrite_blob() { BlobClient blobClient = Fixture.GetBlobClient(Guid.NewGuid().ToString()); var options = new BlobUploadOptions { Tags = new Dictionary <string, string> { { "MyTag", "10" } } }; await using var sourceStream = await Fixture.GetSampleBlob(); await blobClient.UploadAsync(sourceStream, options).ConfigureAwait(false); string text = await TestFixture.DownloadAndReadBlobContents(blobClient).ConfigureAwait(false); Assert.Equal("sample", text); // Reupload with conditions options = new BlobUploadOptions { Tags = new Dictionary <string, string> { { "MyTag", "1" } }, Conditions = new BlobRequestConditions { TagConditions = $@"""MyTag"" < '1'" } }; await using var sourceStream2 = await Fixture.GetSampleBlob(TestFixture.Samples.sample2); try { await blobClient.UploadAsync(sourceStream2, options).ConfigureAwait(false); } catch (RequestFailedException exception) when(exception.ErrorCode == BlobErrorCode.ConditionNotMet) { // We are expecting this! The BlobRequestConditions aren't met } // We should still have original content here text = await TestFixture.DownloadAndReadBlobContents(blobClient).ConfigureAwait(false); Assert.Equal("sample", text); }
private async Task <string> UploadAsync(BlobContainerClient client, AuditEvent auditEvent, string existingBlobName) { var blobName = existingBlobName ?? BlobNameBuilder?.Invoke(auditEvent) ?? string.Format("{0}.json", Guid.NewGuid()); var blob = client.GetBlobClient(blobName); var options = new BlobUploadOptions() { Metadata = MetadataBuilder?.Invoke(auditEvent), AccessTier = AccessTierBuilder?.Invoke(auditEvent) }; #if NETSTANDARD2_0 await blob.UploadAsync(new BinaryData(auditEvent, JsonSettings), options); #else await blob.UploadAsync(new BinaryData(auditEvent, Core.Configuration.JsonSettings), options); #endif return(blobName); }
private static async Task ImageUploadToBlob(BlobContainerClient blobContainerClient, HttpContent content, string fileName) { // Get image stream var stream = await content.ReadAsStreamAsync(); //create a blob var blobClient = blobContainerClient.GetBlobClient(fileName); var blobUploadOptions = new BlobUploadOptions { HttpHeaders = new BlobHttpHeaders { ContentType = content.Headers.ContentType.ToString() } }; await blobClient.UploadAsync(stream, blobUploadOptions); }
public async Task Upload_ImmutableStorageWithVersioning(bool multipart) { // Arrange await using DisposingImmutableStorageWithVersioningContainer vlwContainer = await GetTestVersionLevelWormContainer(TestConfigOAuth); BlockBlobClient blockBlob = InstrumentClient(vlwContainer.Container.GetBlockBlobClient(GetNewBlobName())); byte[] data = GetRandomBuffer(Constants.KB); using Stream stream = new MemoryStream(data); BlobImmutabilityPolicy immutabilityPolicy = new BlobImmutabilityPolicy { ExpiresOn = Recording.UtcNow.AddMinutes(5), PolicyMode = BlobImmutabilityPolicyMode.Unlocked }; // The service rounds Immutability Policy Expiry to the nearest second. DateTimeOffset expectedImmutabilityPolicyExpiry = RoundToNearestSecond(immutabilityPolicy.ExpiresOn.Value); BlobUploadOptions options = new BlobUploadOptions { ImmutabilityPolicy = immutabilityPolicy, LegalHold = true }; if (multipart) { StorageTransferOptions transferOptions = new StorageTransferOptions { InitialTransferSize = Constants.KB / 2, MaximumTransferSize = Constants.KB / 2 }; options.TransferOptions = transferOptions; } // Act await blockBlob.UploadAsync(stream, options); // Assert Response <BlobProperties> propertiesResponse = await blockBlob.GetPropertiesAsync(); Assert.AreEqual(expectedImmutabilityPolicyExpiry, propertiesResponse.Value.ImmutabilityPolicy.ExpiresOn); Assert.AreEqual(immutabilityPolicy.PolicyMode, propertiesResponse.Value.ImmutabilityPolicy.PolicyMode); Assert.IsTrue(propertiesResponse.Value.HasLegalHold); }
private static async Task IndexUploadToBlob(BlobContainerClient blobContainerClient, MediaItem mediaItem, string fileName) { //convert string to stream var stream = new MemoryStream(); JsonHelper.WriteJsonToStream(mediaItem, stream); //create a blob var blobClient = blobContainerClient.GetBlobClient(fileName); var blobUploadOptions = new BlobUploadOptions { HttpHeaders = new BlobHttpHeaders { ContentType = "application/json" } }; await blobClient.UploadAsync(stream, blobUploadOptions); }
public async Task <string> SaveDocumentAsync(string fileName, string contentType, Stream fileStream, CancellationToken token) { _logger.LogInformation($"fileName: {fileName}"); var blobContainer = await GetContainerAsync(); // Get a reference to a blob var blobClient = blobContainer.GetBlobClient(fileName); var options = new BlobUploadOptions(); BlobHttpHeaders blobHttpHeaders = new BlobHttpHeaders(); blobHttpHeaders.ContentType = contentType; options.HttpHeaders = blobHttpHeaders; options.HttpHeaders.ContentType = contentType; await blobClient.UploadAsync(fileStream, options, token); return(string.Concat(blobClient.Uri.AbsoluteUri, "?", DateTime.UtcNow.ToEpoch())); }
public async Task UploadAsync_File_Tags() { // Arrange await using DisposingContainer test = await GetTestContainerAsync(); var name = GetNewBlobName(); BlobClient blob = InstrumentClient(test.Container.GetBlobClient(name)); var data = GetRandomBuffer(Constants.KB); IDictionary <string, string> tags = BuildTags(); BlobUploadOptions options = new BlobUploadOptions { Tags = tags }; using (var stream = new MemoryStream(data)) { var path = Path.GetTempFileName(); try { File.WriteAllBytes(path, data); // Test that we can upload a read-only file. File.SetAttributes(path, FileAttributes.ReadOnly); // Act await blob.UploadAsync(path, options); } finally { if (File.Exists(path)) { File.SetAttributes(path, FileAttributes.Normal); File.Delete(path); } } } Response <GetBlobTagResult> response = await blob.GetTagsAsync(); // Assert AssertDictionaryEquality(tags, response.Value.Tags); }
public async Task Upload_blob_from_RetryableStreamImpl_with_tags_should_work() { BlobClient blobClient = Fixture.GetBlobClient(Guid.NewGuid().ToString()); var options = new BlobUploadOptions { Tags = new Dictionary <string, string> { { "MyTag", "1" } } }; await using var sourceStream = await Fixture.GetSampleBlob(); await blobClient.UploadAsync(sourceStream, options).ConfigureAwait(false); string text = await TestFixture.DownloadAndReadBlobContents(blobClient).ConfigureAwait(false); Assert.Equal("sample", text); }
public void UploadBlob(string containerName, string blobName, string contentType, Stream content) { var containerClient = _blobServiceClient.GetBlobContainerClient(containerName); if (!containerClient.Exists()) { throw new ApplicationException($"Unable to upload blobs to container '{containerName}' as the container does not exists"); } var blobClient = containerClient.GetBlobClient(blobName); var options = new BlobUploadOptions() { HttpHeaders = new BlobHttpHeaders() { ContentType = contentType } }; var response = blobClient.Upload(content, options); }
public async Task Step3_attempt_to_upload_a_new_version_of_blob_using_stream_workaround_that_works() { // Download the blob var serviceClient = new BlobServiceClient(connectionString); var containerClient = serviceClient.GetBlobContainerClient("repro"); var blobClient = containerClient.GetBlobClient("aabbccdd-1122-3344-5566-778899aabbcc.txt"); var response = await blobClient.DownloadAsync(); // upload to the destination - first two characters and then the original blob var uploadClient = containerClient.GetBlobClient("aa/aabbccdd-1122-3344-5566-778899aabbcc.txt"); // The code set the LocalId in case this is an insert and verifies the blob tag value is lesser value in case it's an update var options = new BlobUploadOptions { Tags = new Dictionary <string, string> { { "LocalId", "456" } }, Conditions = new BlobRequestConditions { TagConditions = $@"""LocalId"" < '456'" } }; // Workaround for https://github.com/Azure/azure-sdk-for-net/issues/20931 await using var memoryStreamFix = new MemoryStream(); await response.Value.Content.CopyToAsync(memoryStreamFix).ConfigureAwait(false); memoryStreamFix.Position = 0; // End Workaround try { await uploadClient.UploadAsync(memoryStreamFix, options); } catch (RequestFailedException exception) when(exception.ErrorCode == BlobErrorCode.ConditionNotMet) { output.WriteLine("Failed to copy 'repo/aa/aabbccdd-1122-3344-5566-778899aabbcc.txt' to 'repo/aa/aabbccdd-1122-3344-5566-778899aabbcc.txt' despite workaround."); output.WriteLine("Reason: 'repo/aa/aabbccdd-1122-3344-5566-778899aabbcc.txt' reported as existing and condition not met (412) despite 'repo/aa/aabbccdd-1122-3344-5566-778899aabbcc.txt' absense."); output.WriteLine($"Exception: {exception.Message}"); } }
public async Task <StoragePutResult> PutAsync( string path, Stream content, string contentType, CancellationToken cancellationToken) { var blob = _container.GetBlockBlobClient(path); //new global::Azure.Storage.Blobs.Models.BlobRequestConditions { } //var condition = AccessCondition.GenerateIfNotExistsCondition(); //blob.Properties.ContentType = contentType; try { var options = new BlobUploadOptions { Metadata = new Dictionary <string, string> { { "ContentType", contentType } }, AccessTier = AccessTier.Cool, //Conditions = new BlobRequestConditions //{ // IfMatch = new ETag() //} }; await blob.UploadAsync(content, options, cancellationToken); return(StoragePutResult.Success); } catch (RequestFailedException e) when(e.IsAlreadyExistsException()) { using var targetStream = await blob.OpenReadAsync(new BlobOpenReadOptions (true), cancellationToken); content.Position = 0; return(content.Matches(targetStream) ? StoragePutResult.AlreadyExists : StoragePutResult.Conflict); } }