public void CreateDirectoryIfNotExists(string path) { path = AzureBlobsLogsInterface.PathFixer(path); var logClient = _blobsContainerClient.GetAppendBlobClient(path); if (!logClient.Exists()) { logClient.Create(); } }
protected override AppendBlobClient GetResourceClient(BlobContainerClient container, string resourceName = null, BlobClientOptions options = null) { Argument.AssertNotNull(container, nameof(container)); string blobName = resourceName ?? GetNewResourceName(); if (options == null) { return(container.GetAppendBlobClient(blobName)); } container = InstrumentClient(new BlobContainerClient(container.Uri, Tenants.GetNewSharedKeyCredentials(), options ?? ClientBuilder.GetOptions())); return(InstrumentClient(container.GetAppendBlobClient(blobName))); }
/// <summary> /// Sends the events. /// </summary> /// <param name="events">The events that need to be send.</param> /// <remarks> /// <para> /// The subclass must override this method to process the buffered events. /// </para> /// </remarks> protected override void SendBuffer(LoggingEvent[] events) { AppendBlobClient appendBlob = _cloudBlobContainer.GetAppendBlobClient(Filename(_directoryName)); if (!appendBlob.Exists()) { appendBlob.Create(); } else { _lineFeed = Environment.NewLine; } Parallel.ForEach(events, ProcessEvent); }
public async Task CreateAppendBlob_ImmutableStorageWithVersioning() { // Arrange AppendBlobClient appendBlob = InstrumentClient(_containerClient.GetAppendBlobClient(GetNewBlobName())); 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); AppendBlobCreateOptions options = new AppendBlobCreateOptions { ImmutabilityPolicy = immutabilityPolicy, HasLegalHold = true }; // Act Response <BlobContentInfo> createResponse = await appendBlob.CreateAsync(options); // Assert Response <BlobProperties> propertiesResponse = await appendBlob.GetPropertiesAsync(); Assert.AreEqual(expectedImmutabilityPolicyExpiry, propertiesResponse.Value.ImmutabilityPolicy.ExpiresOn); Assert.AreEqual(immutabilityPolicy.PolicyMode, propertiesResponse.Value.ImmutabilityPolicy.PolicyMode); Assert.IsTrue(propertiesResponse.Value.HasLegalHold); }
private async Task WriteToDataFabric(string routeKey, Stream stream, CancellationToken cancellationToken) { if (_diagnostic != null && _diagnostic.IsEnabled() && _diagnostic.IsEnabled(DiagnosticOperations.MessageProcess)) { _diagnostic.Write(DiagnosticOperations.DataFabricWrite, _config); } //Create a unique name for the blob var containerName = $"{_config.ContainerNamePrefix}-{routeKey}"; var containerClient = new BlobContainerClient(_config.StorageConnectionString, containerName); await containerClient.CreateIfNotExistsAsync(cancellationToken : cancellationToken); var blobName = $"{_config.BlobNamePrefix}-{DateTime.UtcNow.ToString(string.IsNullOrEmpty(_config.BlobNameRollingTimeFormat) ? "yyyyMMdd" : _config.BlobNameRollingTimeFormat)}"; var blobClient = containerClient.GetAppendBlobClient(blobName); var blobInfo = await blobClient.CreateIfNotExistsAsync(cancellationToken : cancellationToken); Console.WriteLine("Appending to Blob storage as blob:\n\t {0}\n", blobClient.Uri); await blobClient.AppendBlockAsync(stream, null, new AppendBlobRequestConditions { IfMatch = blobInfo?.Value.ETag }, cancellationToken : cancellationToken); }
public static Task <BlobBaseClient> GetBlobReferenceForArgumentTypeAsync(this BlobContainerClient container, string blobName, Type argumentType, CancellationToken cancellationToken) { if (argumentType == typeof(BlobClient)) { BlobBaseClient blob = container.GetBlobClient(blobName); return(Task.FromResult(blob)); } else if (argumentType == typeof(BlockBlobClient)) { BlobBaseClient blob = container.GetBlockBlobClient(blobName); return(Task.FromResult(blob)); } else if (argumentType == typeof(PageBlobClient)) { BlobBaseClient blob = container.GetPageBlobClient(blobName); return(Task.FromResult(blob)); } else if (argumentType == typeof(AppendBlobClient)) { BlobBaseClient blob = container.GetAppendBlobClient(blobName); return(Task.FromResult(blob)); } else { return(GetExistingOrNewBlockBlobReferenceAsync(container, blobName, cancellationToken)); } }
private async Task <IEnumerable <T> > ConvertBlobs(IAsyncEnumerable <BlobItem> blobItems, BlobContainerClient blobContainerClient) { var list = new List <T>(); await foreach (var blobItem in blobItems.ConfigureAwait(false)) { BlobBaseClient src = null; switch (blobItem.Properties.BlobType) { case BlobType.Block: src = blobContainerClient.GetBlockBlobClient(blobItem.Name); break; case BlobType.Append: src = blobContainerClient.GetAppendBlobClient(blobItem.Name); break; case BlobType.Page: src = blobContainerClient.GetPageBlobClient(blobItem.Name); break; default: throw new InvalidOperationException($"Unexpected blob type {blobItem.Properties.BlobType}"); } var funcCtx = new FunctionBindingContext(Guid.Empty, CancellationToken.None); var valueCtx = new ValueBindingContext(funcCtx, CancellationToken.None); var converted = await _converter(src, null, valueCtx).ConfigureAwait(false); list.Add(converted); } return(list); }
public void WithSnapshot() { var containerName = GetNewContainerName(); var blobName = GetNewBlobName(); BlobServiceClient service = GetServiceClient_SharedKey(); BlobContainerClient container = InstrumentClient(service.GetBlobContainerClient(containerName)); AppendBlobClient blob = InstrumentClient(container.GetAppendBlobClient(blobName)); var builder = new BlobUriBuilder(blob.Uri); Assert.AreEqual("", builder.Snapshot); blob = InstrumentClient(blob.WithSnapshot("foo")); builder = new BlobUriBuilder(blob.Uri); Assert.AreEqual("foo", builder.Snapshot); blob = InstrumentClient(blob.WithSnapshot(null)); builder = new BlobUriBuilder(blob.Uri); Assert.AreEqual("", builder.Snapshot); }
private async Task <AppendBlobClient> CreateBlob(BlobContainerClient containerClient) { AppendBlobClient appendBlobClient = containerClient.GetAppendBlobClient(_fileName); await appendBlobClient.CreateIfNotExistsAsync(); return(appendBlobClient); }
private async Task PushToDataFabric(string routingKey, Stream stream, CancellationToken stoppingToken) { stoppingToken.ThrowIfCancellationRequested(); //Create a unique name for the blob var containerName = $"{_config.ContainerNamePrefix}-{routingKey}"; var containerClient = new BlobContainerClient(_config.StorageConnectionString, containerName); await containerClient.CreateIfNotExistsAsync(cancellationToken : stoppingToken); stoppingToken.ThrowIfCancellationRequested(); var blobName = $"{_config.BlobNamePrefix}-{DateTime.UtcNow.ToString(string.IsNullOrEmpty(_config.BlobNameRollingTimeFormat) ? "yyyyMMdd" : _config.BlobNameRollingTimeFormat)}"; var blobClient = containerClient.GetAppendBlobClient(blobName); var blobInfo = await blobClient.CreateIfNotExistsAsync(cancellationToken : stoppingToken); stoppingToken.ThrowIfCancellationRequested(); _logger.LogInformation("Appending to Blob storage as blob:\n\t {0}\n", blobClient.Uri); await blobClient.AppendBlockAsync(stream, null, new AppendBlobRequestConditions { IfMatch = blobInfo?.Value.ETag }, cancellationToken : stoppingToken); }
/// <summary> /// Initializes the BLOB. /// </summary> /// <param name="blobName">Name of the BLOB.</param> private async Task <AppendBlobClient> InitializeBlob(string blobName, BlobContainerClient blobContainer, string contentType, CancellationToken cancellationToken) { var appendBlob = blobContainer.GetAppendBlobClient(blobName); var blobExits = await appendBlob.ExistsAsync(cancellationToken).ConfigureAwait(false); if (blobExits) { return(appendBlob); } var blobCreateOptions = new Azure.Storage.Blobs.Models.AppendBlobCreateOptions(); var httpHeaders = new Azure.Storage.Blobs.Models.BlobHttpHeaders() { ContentType = contentType, ContentEncoding = Encoding.UTF8.WebName, }; blobCreateOptions.HttpHeaders = httpHeaders; blobCreateOptions.Metadata = _blobMetadata; // Optional custom metadata to set for this append blob. blobCreateOptions.Tags = _blobTags; // Options tags to set for this append blob. await appendBlob.CreateIfNotExistsAsync(blobCreateOptions, cancellationToken).ConfigureAwait(false); return(appendBlob); }
public async Task UploadRangeFromUriAsync_SourceBearerTokenFail() { // Arrange BlobServiceClient blobServiceClient = InstrumentClient(new BlobServiceClient( new Uri(Tenants.TestConfigOAuth.BlobServiceEndpoint), Tenants.GetOAuthCredential(Tenants.TestConfigOAuth), GetBlobOptions())); BlobContainerClient containerClient = InstrumentClient(blobServiceClient.GetBlobContainerClient(GetNewShareName())); try { await containerClient.CreateIfNotExistsAsync(); AppendBlobClient appendBlobClient = InstrumentClient(containerClient.GetAppendBlobClient(GetNewFileName())); await appendBlobClient.CreateAsync(); byte[] data = GetRandomBuffer(Constants.KB); using Stream stream = new MemoryStream(data); await appendBlobClient.AppendBlockAsync(stream); ShareServiceClient serviceClient = SharesClientBuilder.GetServiceClient_OAuthAccount_SharedKey(); await using DisposingShare test = await GetTestShareAsync( service : serviceClient, shareName : GetNewShareName()); ShareDirectoryClient directoryClient = InstrumentClient(test.Share.GetDirectoryClient(GetNewDirectoryName())); await directoryClient.CreateAsync(); ShareFileClient fileClient = InstrumentClient(directoryClient.GetFileClient(GetNewFileName())); await fileClient.CreateAsync(Constants.KB); HttpAuthorization sourceAuthHeader = new HttpAuthorization( "Bearer", "auth token"); ShareFileUploadRangeFromUriOptions options = new ShareFileUploadRangeFromUriOptions { SourceAuthentication = sourceAuthHeader }; HttpRange range = new HttpRange(0, Constants.KB); // Act await TestHelper.AssertExpectedExceptionAsync <RequestFailedException>( fileClient.UploadRangeFromUriAsync( sourceUri: appendBlobClient.Uri, range: range, sourceRange: range, options: options), e => Assert.AreEqual("CannotVerifyCopySource", e.ErrorCode)); } finally { await containerClient.DeleteIfExistsAsync(); } }
public async Task UploadRangeFromUriAsync_SourceBearerToken() { // Arrange BlobServiceClient blobServiceClient = InstrumentClient(new BlobServiceClient( new Uri(TestConfigOAuth.BlobServiceEndpoint), GetOAuthCredential(TestConfigOAuth), GetBlobOptions())); BlobContainerClient containerClient = InstrumentClient(blobServiceClient.GetBlobContainerClient(GetNewShareName())); try { await containerClient.CreateIfNotExistsAsync(); AppendBlobClient appendBlobClient = InstrumentClient(containerClient.GetAppendBlobClient(GetNewFileName())); await appendBlobClient.CreateAsync(); byte[] data = GetRandomBuffer(Constants.KB); using Stream stream = new MemoryStream(data); await appendBlobClient.AppendBlockAsync(stream); ShareServiceClient serviceClient = GetServiceClient_OAuth_SharedKey(); await using DisposingShare test = await GetTestShareAsync( service : serviceClient, shareName : GetNewShareName()); ShareDirectoryClient directoryClient = InstrumentClient(test.Share.GetDirectoryClient(GetNewDirectoryName())); await directoryClient.CreateAsync(); ShareFileClient fileClient = InstrumentClient(directoryClient.GetFileClient(GetNewFileName())); await fileClient.CreateAsync(Constants.KB); string sourceBearerToken = await GetAuthToken(); HttpAuthorization sourceAuthHeader = new HttpAuthorization( "Bearer", sourceBearerToken); ShareFileUploadRangeFromUriOptions options = new ShareFileUploadRangeFromUriOptions { SourceAuthentication = sourceAuthHeader }; HttpRange range = new HttpRange(0, Constants.KB); // Act await fileClient.UploadRangeFromUriAsync( sourceUri : appendBlobClient.Uri, range : range, sourceRange : range, options : options); } finally { await containerClient.DeleteIfExistsAsync(); } }
private void ProcessEvent(LoggingEvent loggingEvent) { AppendBlobClient appendBlob = _cloudBlobContainer.GetAppendBlobClient(Filename(loggingEvent, _directoryName)); var xml = loggingEvent.GetXmlString(Layout); using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(xml))) { appendBlob.AppendBlock(ms); } }
public async Task AppendBlockAsync_WithUnreliableConnection() { const int blobSize = 1 * Constants.MB; await using DisposingContainer test = await GetTestContainerAsync(); BlobContainerClient containerFaulty = InstrumentClient( new BlobContainerClient( test.Container.Uri, new StorageSharedKeyCredential( TestConfigDefault.AccountName, TestConfigDefault.AccountKey), GetFaultyBlobConnectionOptions())); // Arrange var blobName = GetNewBlobName(); AppendBlobClient blobFaulty = InstrumentClient(containerFaulty.GetAppendBlobClient(blobName)); AppendBlobClient blob = InstrumentClient(test.Container.GetAppendBlobClient(blobName)); await blob.CreateAsync(); var data = GetRandomBuffer(blobSize); var progressList = new List <long>(); var progressHandler = new Progress <long>(progress => { progressList.Add(progress); /*logger.LogTrace("Progress: {progress}", progress.BytesTransferred);*/ }); var timesFaulted = 0; // Act using (var stream = new FaultyStream( new MemoryStream(data), 256 * Constants.KB, 1, new IOException("Simulated stream fault"), () => timesFaulted++)) { await blobFaulty.AppendBlockAsync(stream, progressHandler : progressHandler); await WaitForProgressAsync(progressList, data.LongLength); Assert.IsTrue(progressList.Count > 1, "Too few progress received"); // Changing from Assert.AreEqual because these don't always update fast enough Assert.GreaterOrEqual(data.LongLength, progressList.Last(), "Final progress has unexpected value"); } // Assert Response <BlobDownloadInfo> downloadResponse = await blob.DownloadAsync(); var actual = new MemoryStream(); await downloadResponse.Value.Content.CopyToAsync(actual); Assert.AreEqual(data.Length, actual.Length); TestHelper.AssertSequenceEqual(data, actual.ToArray()); Assert.AreNotEqual(0, timesFaulted); }
protected override async Task <AppendBlobClient> GetResourceClientAsync( BlobContainerClient container, int resourceLength = default, bool createResource = default, string resourceName = null, BlobClientOptions options = null) { container = InstrumentClient(new BlobContainerClient(container.Uri, Tenants.GetNewSharedKeyCredentials(), options ?? ClientBuilder.GetOptions())); var appendBlob = InstrumentClient(container.GetAppendBlobClient(resourceName ?? GetNewResourceName())); if (createResource) { await appendBlob.CreateAsync(); } return(appendBlob); }
public async Task AppendLog(string value) { var blobContainerClient = new BlobContainerClient(_blobStorageSettings.ConnectionString, _blobStorageSettings.ContainerName); await blobContainerClient.CreateIfNotExistsAsync(); var fileSuffix = DateTime.UtcNow.Date.ToString(); var blob = blobContainerClient.GetAppendBlobClient($"{_blobStorageSettings.FilePrefix}-{fileSuffix}"); await blob.CreateIfNotExistsAsync(); var content = $"{value} \n"; var stream = new MemoryStream(Encoding.UTF8.GetBytes(content)); await blob.AppendBlockAsync(stream); }
public async Task DeleteArchivedBlobsAsync(BlobServiceClient blobServiceClient, string blobContainerName, string blobNameFormat, int retainedBlobCountLimit) { if (retainedBlobCountLimit < 1) { throw new ArgumentException("Invalid value provided; retained blob count limit must be at least 1 or null."); } BlobContainerClient blobContainer = blobServiceClient.GetBlobContainerClient(blobContainerName); List <BlobItem> logBlobs = new List <BlobItem>(); AsyncPageable <BlobItem> blobItems = blobContainer.GetBlobsAsync(); IAsyncEnumerator <BlobItem> enumerator = blobItems.GetAsyncEnumerator(); try { while (await enumerator.MoveNextAsync()) { logBlobs.Add(enumerator.Current); } } finally { await enumerator.DisposeAsync(); } IEnumerable <BlobItem> validLogBlobs = logBlobs.Where(blobItem => DateTime.TryParseExact( RemoveRolledBlobNameSerialNum(blobItem.Name), blobNameFormat, CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out var _date)); IEnumerable <BlobItem> blobsToDelete = validLogBlobs .OrderByDescending(blobItem => blobItem.Name) .Skip(retainedBlobCountLimit); foreach (var blobItem in blobsToDelete) { AppendBlobClient blobToDelete = blobContainer.GetAppendBlobClient(blobItem.Name); await blobToDelete.DeleteIfExistsAsync(); } }
public static async Task <(BlobBaseClient, BlobProperties)> GetBlobReferenceFromServerAsync(this BlobContainerClient container, string blobName, CancellationToken cancellationToken = default) { BlobProperties blobProperties = await container.GetBlobClient(blobName).GetPropertiesAsync(cancellationToken: cancellationToken).ConfigureAwait(false); switch (blobProperties.BlobType) { case BlobType.Append: return(container.GetAppendBlobClient(blobName), blobProperties); case BlobType.Block: return(container.GetBlockBlobClient(blobName), blobProperties); case BlobType.Page: return(container.GetPageBlobClient(blobName), blobProperties); default: throw new InvalidOperationException(); } }
public async Task AppendBlobSample() { // Instantiate a new BlobServiceClient using a connection string. BlobServiceClient blobServiceClient = new BlobServiceClient(TestConfigurations.DefaultTargetTenant.ConnectionString); // Instantiate a new BlobContainerClient BlobContainerClient blobContainerClient = blobServiceClient.GetBlobContainerClient("mycontainer4"); try { // Create new Container in the Service await blobContainerClient.CreateAsync(); // Instantiate a new PageBlobClient AppendBlobClient appendBlobClient = blobContainerClient.GetAppendBlobClient("appendblob"); // Create PageBlob in the Service await appendBlobClient.CreateAsync(); // Append content to AppendBlob using (FileStream fileStream = File.OpenRead("Samples/SampleSource.txt")) { await appendBlobClient.AppendBlockAsync(fileStream); } // Download PageBlob using (FileStream fileStream = File.Create("AppendDestination.txt")) { Response <BlobDownloadInfo> downloadResponse = await appendBlobClient.DownloadAsync(); await downloadResponse.Value.Content.CopyToAsync(fileStream); } // Delete PageBlob in the Service await appendBlobClient.DeleteAsync(); } finally { // Delete Container in the Service await blobContainerClient.DeleteAsync(); } }
public AzureBlobsLogWriter(BlobContainerClient blobsContainerClient, string fileName, bool appendOpen = false) { fileName = AzureBlobsLogsInterface.PathFixer(fileName); _blobsContainerClient = blobsContainerClient; _logClient = _blobsContainerClient.GetAppendBlobClient(fileName); ETag currentETag; if (_previousOpenAttempts.ContainsKey(fileName) && appendOpen) { // We've opened this blob before and want to be non-destructive. We don't need to CreateIfNotExists, which could be VERY slow. currentETag = _logClient.GetProperties().Value.ETag; } else { try { // Create the file non-destructively if needed, guaranteeing write continuity on creation by grabbing the etag of the create, if needed if (appendOpen) { var response = _logClient.CreateIfNotExists(); if (response != null) { currentETag = response.Value.ETag; } else { currentETag = _logClient.GetProperties().Value.ETag; } } else { currentETag = _logClient.Create().Value.ETag; } } catch { currentETag = _logClient.GetProperties().Value.ETag; } } // Try to grab the blob lease _leaseClient = _logClient.GetBlobLeaseClient(); // The blob hasn't be touched since the last time. This is a candidate for breaking the lease. if (_previousOpenAttempts.ContainsKey(fileName) && (_previousOpenAttempts[fileName].ToString().Equals(currentETag.ToString()))) { _previousOpenAttempts[fileName] = currentETag; // The blob hasn't been updated. Try to break the lease and reacquire var requestConditions = new BlobRequestConditions(); requestConditions = new BlobRequestConditions(); requestConditions.IfMatch = currentETag; // If the condition fails in the break, it's because someone else managed to touch the file, so give up ETag newETag; try { newETag = _leaseClient.Break(null, requestConditions).Value.ETag; } catch (Exception e) { newETag = currentETag; } var etagCondition = new RequestConditions(); etagCondition.IfMatch = newETag; // If the condition fails, someone snuck in and grabbed the lock before we could. Give up. _curLease = _leaseClient.Acquire(TimeSpan.FromSeconds(-1), etagCondition).Value; } else { // Not a candidate for breaking the lease. Just try to acquire. _previousOpenAttempts[fileName] = currentETag; _curLease = _leaseClient.Acquire(TimeSpan.FromSeconds(-1)).Value; } _leaseCondition = new AppendBlobRequestConditions(); _leaseCondition.LeaseId = _curLease.LeaseId; // We got the lease! Set up thread to periodically touch the blob to prevent others from breaking the lease. _blobMetadata = _logClient.GetProperties().Value.Metadata; _stopRelockThread = false; _relockThreadStopped = false; _leaseRenewThread = new Thread(() => { while (!_stopRelockThread) { Thread.Sleep(100); var response = _logClient.SetMetadata(_blobMetadata, _leaseCondition); } _relockThreadStopped = true; }) { IsBackground = true }; _leaseRenewThread.Start(); _bytesToSend = new MemoryStream(); Debug.Assert(_logClient.Exists()); }
#pragma warning disable CA1806 // Do not ignore method results public override void Run(CancellationToken cancellationToken) { // traverse hierarchy down BlobServiceClient.GetBlobContainerClient(ContainerName); BlobContainerClient.GetBlobClient(BlobName); BlobContainerClient.GetBlobBaseClient(BlobName); BlobContainerClient.GetBlockBlobClient(BlobName); BlobContainerClient.GetPageBlobClient(BlobName); BlobContainerClient.GetAppendBlobClient(BlobName); // traverse hierarchy up BlobClient.GetParentBlobContainerClient(); BlobContainerClient.GetParentBlobServiceClient(); // BlobServiceClient ctors new BlobServiceClient(s_connectionString); new BlobServiceClient(BlobServiceClient.Uri); new BlobServiceClient(BlobServiceClient.Uri, s_azureSasCredential); new BlobServiceClient(BlobServiceClient.Uri, s_tokenCredential); new BlobServiceClient(BlobServiceClient.Uri, StorageSharedKeyCredential); // BlobContainerClient ctors new BlobContainerClient(s_connectionString, ContainerName); new BlobContainerClient(BlobContainerClient.Uri); new BlobContainerClient(BlobContainerClient.Uri, s_azureSasCredential); new BlobContainerClient(BlobContainerClient.Uri, s_tokenCredential); new BlobContainerClient(BlobContainerClient.Uri, StorageSharedKeyCredential); // BlobClient ctors new BlobClient(s_connectionString, ContainerName, BlobName); new BlobClient(BlobContainerClient.Uri); new BlobClient(BlobContainerClient.Uri, s_azureSasCredential); new BlobClient(BlobContainerClient.Uri, s_tokenCredential); new BlobClient(BlobContainerClient.Uri, StorageSharedKeyCredential); // BlobBaseClient ctors new BlobBaseClient(s_connectionString, ContainerName, BlobName); new BlobBaseClient(BlobContainerClient.Uri); new BlobBaseClient(BlobContainerClient.Uri, s_azureSasCredential); new BlobBaseClient(BlobContainerClient.Uri, s_tokenCredential); new BlobBaseClient(BlobContainerClient.Uri, StorageSharedKeyCredential); // AppendBlobClient ctors new AppendBlobClient(s_connectionString, ContainerName, BlobName); new AppendBlobClient(BlobContainerClient.Uri); new AppendBlobClient(BlobContainerClient.Uri, s_azureSasCredential); new AppendBlobClient(BlobContainerClient.Uri, s_tokenCredential); new AppendBlobClient(BlobContainerClient.Uri, StorageSharedKeyCredential); // BlockBlobClient ctors new BlockBlobClient(s_connectionString, ContainerName, BlobName); new BlockBlobClient(BlobContainerClient.Uri); new BlockBlobClient(BlobContainerClient.Uri, s_azureSasCredential); new BlockBlobClient(BlobContainerClient.Uri, s_tokenCredential); new BlockBlobClient(BlobContainerClient.Uri, StorageSharedKeyCredential); // PageBlobClient ctors new PageBlobClient(s_connectionString, ContainerName, BlobName); new PageBlobClient(BlobContainerClient.Uri); new PageBlobClient(BlobContainerClient.Uri, s_azureSasCredential); new PageBlobClient(BlobContainerClient.Uri, s_tokenCredential); new PageBlobClient(BlobContainerClient.Uri, StorageSharedKeyCredential); }