public BlobClientOptions GetOptions(bool parallelRange = false) { var options = new BlobClientOptions { Diagnostics = { IsLoggingEnabled = true }, Retry = { Mode = RetryMode.Exponential, MaxRetries = Azure.Storage.Constants.MaxReliabilityRetries, Delay = TimeSpan.FromSeconds(this.Mode == RecordedTestMode.Playback ? 0.01 : 0.5), MaxDelay = TimeSpan.FromSeconds(this.Mode == RecordedTestMode.Playback ? 0.1 : 10) } }; if (Mode != RecordedTestMode.Live) { options.AddPolicy(new RecordedClientRequestIdPolicy(Recording, parallelRange), HttpPipelinePosition.PerCall); } return(Recording.InstrumentClientOptions(options)); }
/// <summary> /// Get BlobClientOptions instrumented for recording. /// </summary> protected BlobClientOptions GetBlobOptions() { var options = new BlobClientOptions(_serviceVersion) { Diagnostics = { IsLoggingEnabled = true }, Retry = { Mode = RetryMode.Exponential, MaxRetries = Azure.Storage.Constants.MaxReliabilityRetries, Delay = TimeSpan.FromSeconds(Mode == RecordedTestMode.Playback? 0.01 : 1), MaxDelay = TimeSpan.FromSeconds(Mode == RecordedTestMode.Playback ? 0.1 : 60) } }; if (Mode != RecordedTestMode.Live) { options.AddPolicy(new RecordedClientRequestIdPolicy(Recording), HttpPipelinePosition.PerCall); } return(InstrumentClientOptions(options)); }
/// <summary> /// Creates a pipeline to use for processing sub-operations before they /// are combined into a single multipart request. /// </summary> /// <param name="pipeline"> /// The pipeline used to submit the live request. /// </param> /// <param name="authenticationPolicy"> /// An optional <see cref="HttpPipelinePolicy"/> used to authenticate /// the sub-operations. /// </param> /// <param name="serviceVersion"> /// The serviceVersion used when generating sub-requests. /// </param> /// <returns>A pipeline to use for processing sub-operations.</returns> private static HttpPipeline CreateBatchPipeline( HttpPipeline pipeline, HttpPipelinePolicy authenticationPolicy, BlobClientOptions.ServiceVersion serviceVersion) { // Configure the options to use minimal policies var options = new BlobClientOptions(serviceVersion); options.Diagnostics.IsLoggingEnabled = false; options.Diagnostics.IsTelemetryEnabled = false; options.Diagnostics.IsDistributedTracingEnabled = false; options.Retry.MaxRetries = 0; // Use an empty transport so requests aren't sent options.Transport = new BatchPipelineTransport(pipeline); // Use the same authentication mechanism return(HttpPipelineBuilder.Build( options, RemoveVersionHeaderPolicy.Shared, authenticationPolicy)); }
/// <summary> /// Download blob with blob Uri /// If blob is on a managed disk account, and server return 401 and requires a bearer token besides Sas Uri to download, /// will try to generate a bearer token and download again with both Sas Uri and bearer token. /// </summary> /// <param name="blobUri"></param> /// <param name="fileName"></param> internal void GetBlobContent(string blobUri, string fileName) { BlobClientOptions blobClientOptions = this.ClientOptions; BlobBaseClient blobclient = new BlobBaseClient(new Uri(blobUri), blobClientOptions); Track2Models.BlobProperties blobproperties; if (blobclient.AccountName.ToLower().StartsWith("md-")) // managed disk account, must be page blob { blobClientOptions.Diagnostics.LoggedHeaderNames.Add("WWW-Authenticate"); blobclient = new PageBlobClient(new Uri(blobUri), blobClientOptions); try { blobproperties = blobclient.GetProperties(null, this.CmdletCancellationToken).Value; } catch (global::Azure.RequestFailedException e) when(e.Status == 401) // need diskRP bearer token { string audience = Util.GetAudienceFrom401ExceptionMessage(e.Message); if (audience != null) { WriteDebugLog(string.Format("Need bearer token with audience {0} to access the blob, so will generate bearer token and resend the request.", audience)); AzureSessionCredential customerToken = new AzureSessionCredential(DefaultContext, customAudience: audience); blobclient = new PageBlobClient(new Uri(blobUri), customerToken, this.ClientOptions); } else { throw e; } } } else // need check blob type for none md account { blobproperties = blobclient.GetProperties(null, this.CmdletCancellationToken).Value; blobclient = Util.GetTrack2BlobClient(new Uri(blobUri), null, blobClientOptions, blobproperties.BlobType); } GetBlobContent(blobclient, fileName); }
public async Task <IActionResult> Download(string file, CancellationToken cancellationToken) { try { // Configure an exponential backoff strategy, should a download be failing due to transient errors. BlobClientOptions options = new BlobClientOptions(); options.Retry.Mode = RetryMode.Exponential; options.Retry.MaxRetries = 3; options.Retry.Delay = new TimeSpan(0, 0, 5); // Create a BlobServiceClient object which will be used to create a container client BlobServiceClient blobServiceClient = new BlobServiceClient(STORAGE_CONNECTION_STRING, options); // connect to the container BlobContainerClient blobContainerClient = blobServiceClient.GetBlobContainerClient(CONTAINER_NAME); // SKIP validation - Let this be an exception, as the 'check if exists' is an additional roundtrip //if (!await blobContainerClient.ExistsAsync()) //{ // return NotFound(fileName); //} var blobClient = blobContainerClient.GetBlobClient(file); // SKIP validation - Let this be an exception, as the 'check if exists' is an additional roundtrip //if (!await blobClient.ExistsAsync()) //{ // return NotFound(fileName); //} var download = await blobClient.DownloadAsync(cancellationToken); return(new FileStreamResult(download.Value.Content, "text/plain")); } catch (Exception e) { _logger.LogError(e, "Download"); return(NotFound()); } }
public BlobClientOptions GetOptions(bool parallelRange = false) { var options = new BlobClientOptions(_serviceVersion) { Diagnostics = { IsLoggingEnabled = true }, Retry = { Mode = RetryMode.Exponential, MaxRetries = Storage.Constants.MaxReliabilityRetries, Delay = TimeSpan.FromSeconds(Mode == RecordedTestMode.Playback ? 0.01 : 1), MaxDelay = TimeSpan.FromSeconds(Mode == RecordedTestMode.Playback ? 0.1 : 60), NetworkTimeout = TimeSpan.FromSeconds(Mode == RecordedTestMode.Playback ? 100 : 400), }, }; if (Mode != RecordedTestMode.Live) { options.AddPolicy(new RecordedClientRequestIdPolicy(Recording, parallelRange), HttpPipelinePosition.PerCall); } return(InstrumentClientOptions(options)); }
public BlobClientOptions GetOptions() { var options = new BlobClientOptions { Diagnostics = { IsLoggingEnabled = true }, Retry = { Mode = RetryMode.Exponential, MaxRetries = Constants.MaxReliabilityRetries, Delay = TimeSpan.FromSeconds(Mode == RecordedTestMode.Playback ? 0.01 : 1), MaxDelay = TimeSpan.FromSeconds(Mode == RecordedTestMode.Playback ? 0.1 : 60) }, Transport = GetTransport() }; if (Mode != RecordedTestMode.Live) { options.AddPolicy(new RecordedClientRequestIdPolicy(Recording), HttpPipelinePosition.PerCall); } return(InstrumentClientOptions(options)); }
/// <inheritdoc /> public BlobServiceClient CreateBlobClient(BlobDataStoreConfiguration configuration) { EnsureArg.IsNotNull(configuration, nameof(configuration)); _logger.LogInformation("Creating BlobClient instance"); // Configure the blob client default request options and retry logic var blobClientOptions = new BlobClientOptions(); blobClientOptions.Retry.MaxRetries = configuration.RequestOptions.ExponentialRetryMaxAttempts; blobClientOptions.Retry.Mode = Azure.Core.RetryMode.Exponential; blobClientOptions.Retry.Delay = TimeSpan.FromSeconds(configuration.RequestOptions.ExponentialRetryBackoffDeltaInSeconds); blobClientOptions.Retry.NetworkTimeout = TimeSpan.FromMinutes(configuration.RequestOptions.ServerTimeoutInMinutes); if (configuration.AuthenticationType == BlobDataStoreAuthenticationType.ManagedIdentity) { var defaultCredentials = new DefaultAzureCredential(); return(new BlobServiceClient(new Uri(configuration.ConnectionString), defaultCredentials, blobClientOptions)); } return(new BlobServiceClient(configuration.ConnectionString, blobClientOptions)); }
/// <summary> /// Initializes a new instance of the <see cref="BlobBatchClient"/> /// class for the same account as the <see cref="BlobServiceClient"/>. /// The new <see cref="BlobBatchClient"/> uses the same request policy /// pipeline as the <see cref="BlobServiceClient"/>. /// </summary> /// <param name="client">The <see cref="BlobServiceClient"/>.</param> public BlobBatchClient(BlobServiceClient client) { _uri = client.Uri; _pipeline = BlobServiceClientInternals.GetHttpPipeline(client); BlobClientOptions options = BlobServiceClientInternals.GetClientOptions(client); _version = options.Version; _clientDiagnostics = new StorageClientDiagnostics(options); // Construct a dummy pipeline for processing batch sub-operations // if we don't have one cached on the service _batchOperationPipeline = CreateBatchPipeline( _pipeline, BlobServiceClientInternals.GetAuthenticationPolicy(client), _version); (ServiceRestClient serviceRestClient, ContainerRestClient containerRestClient) = BuildRestClients(_uri); _serviceRestClient = serviceRestClient; _containerRestClient = containerRestClient; _isContainerScoped = false; }
public BlobClient GetBlobClient(Uri uri, BlobClientOptions options = null, bool useCredentials = true) { if (!useCredentials) { return(new BlobClient(uri, options)); } if (string.IsNullOrEmpty(this.AccountName)) { throw new ArgumentException("No suitable configuration found to connect to storage account."); } if (string.IsNullOrEmpty(this.AccountKey)) { return(new BlobClient(uri, new DefaultAzureCredential(), options)); } return(new BlobClient( uri, base.CreateStorageSharedKeyCredential(), options )); }
/// <summary> /// Creates a BlobContainerClient from a connection string. Called when one does not exist yet. /// </summary> /// <param name="connectionString">Connection string</param> /// <param name="containerName">Container name</param> /// <param name="context">current storage context</param> /// <returns> /// A BlobContainerClient object. /// </returns> internal StorageContainerClientSleeve CreateBlobContainerClientForConnectionString(string connectionString, string containerName, StorageClientProviderContext context) { var ctxCopy = new StorageClientProviderContext(context); BlobContainerClient blobContainerClient; BlobClientOptions clientOptions; try { clientOptions = new BlobClientOptions(); var clientRequestIdPolicy = new BlobClientPipelinePolicy(ctxCopy); blobContainerClient = new BlobContainerClient(connectionString, containerName, clientOptions); } catch (Exception e) { _log.LogExceptionObject(LogEventIds.BlobContainerClientProviderFailedToCreateBlobContainerClient, e, new { connectionString, containerName }); throw; } return(new StorageContainerClientSleeve(blobContainerClient, new BlobServiceClient(connectionString, clientOptions), ctxCopy)); }
static async Task Main(string[] args) { var connectionString = Environment.GetEnvironmentVariable("STORAGE_CONNECTION_STRING"); var blobClientOptions = new BlobClientOptions(); // When using an HTTPS _faultInjectorUri, you must either trust the .NET developer certificate, // or uncomment the following line to disable SSL validation. // blobClientOptions.Transport = new HttpClientTransport(new System.Net.Http.HttpClient(new System.Net.Http.HttpClientHandler() // { // ServerCertificateCustomValidationCallback = (message, cert, chain, errors) => true // })); // FaultInjectionPolicy should be per-retry to run as late as possible in the pipeline. For example, some // clients compute a request signature as a per-retry policy, and FaultInjectionPolicy should run after the // signature is computed to avoid altering the signature. blobClientOptions.AddPolicy(new FaultInjectionPolicy(_faultInjectorUri), HttpPipelinePosition.PerRetry); // The request can be redirected to the HttpFaultInjector using either a Transport or a Policy. // A Policy is recommended by default. // blobClientOptions.Transport = new FaultInjectionTransport(blobClientOptions.Transport, _faultInjectorUri); // Use a single fast retry instead of the default settings blobClientOptions.Retry.Mode = RetryMode.Fixed; blobClientOptions.Retry.Delay = TimeSpan.Zero; blobClientOptions.Retry.MaxRetries = 1; var blobClient = new BlobClient(connectionString, "sample", "sample.txt", blobClientOptions); Console.WriteLine("Sending request..."); var response = await blobClient.DownloadAsync(); var content = (new StreamReader(response.Value.Content)).ReadToEnd(); Console.WriteLine($"Content: {content}"); }
public async Task RetryPolicy() { string connectionString = this.ConnectionString; string data = "hello world"; //setup blob string containerName = Randomize("sample-container"); string blobName = Randomize("sample-file"); var containerClient = new BlobContainerClient(ConnectionString, containerName); try { await containerClient.CreateIfNotExistsAsync(); await containerClient.GetBlobClient(blobName).UploadAsync(BinaryData.FromString(data)); #region Snippet:SampleSnippetsBlobMigration_RetryPolicy BlobClientOptions blobClientOptions = new BlobClientOptions(); blobClientOptions.Retry.Mode = RetryMode.Exponential; blobClientOptions.Retry.Delay = TimeSpan.FromSeconds(10); blobClientOptions.Retry.MaxRetries = 6; BlobServiceClient service = new BlobServiceClient(connectionString, blobClientOptions); BlobClient blobClient = service.GetBlobContainerClient(containerName).GetBlobClient(blobName); Stream targetStream = new MemoryStream(); await blobClient.DownloadToAsync(targetStream); #endregion } finally { await containerClient.DeleteIfExistsAsync(); } Assert.Pass(); }
/// <summary> /// Initializes a new instance of the <see cref="AppendBlobClient"/> /// class. /// </summary> /// <param name="blobUri"> /// A <see cref="Uri"/> referencing the append blob that includes the /// name of the account, the name of the container, and the name of /// the blob. /// This is likely to be similar to "https://{account_name}.blob.core.windows.net/{container_name}/{blob_name}". /// </param> /// <param name="options"> /// Optional client options that define the transport pipeline /// policies for authentication, retries, etc., that are applied to /// every request. /// </param> public AppendBlobClient(Uri blobUri, BlobClientOptions options = default) : base(blobUri, options) { AssertNoClientSideEncryption(options); }
/// <summary> /// Initializes a new instance of the <see cref="AppendBlobClient"/> /// class. /// </summary> /// <param name="blobUri"> /// A <see cref="Uri"/> referencing the append blob that includes the /// name of the account, the name of the container, and the name of /// the blob. /// This is likely to be similar to "https://{account_name}.blob.core.windows.net/{container_name}/{blob_name}". /// </param> /// <param name="credential"> /// The token credential used to sign requests. /// </param> /// <param name="options"> /// Optional client options that define the transport pipeline /// policies for authentication, retries, etc., that are applied to /// every request. /// </param> public AppendBlobClient(Uri blobUri, TokenCredential credential, BlobClientOptions options = default) : base(blobUri, credential, options) { AssertNoClientSideEncryption(options); }
public BlobServiceClient GetServiceClient_SharedKey(BlobClientOptions options = default) => GetServiceClientFromSharedKeyConfig(TestConfigDefault, options);
/// <summary> /// Initializes a new instance of the <see cref="AppendBlobClient"/> /// class. /// </summary> /// <param name="blobUri"> /// A <see cref="Uri"/> referencing the append blob that includes the /// name of the account, the name of the container, and the name of /// the blob. /// </param> /// <param name="options"> /// Optional client options that define the transport pipeline /// policies for authentication, retries, etc., that are applied to /// every request. /// </param> public AppendBlobClient(Uri blobUri, BlobClientOptions options = default) : base(blobUri, options) { }
public static void AddPolicy(this BlobClientOptions options, HttpPipelinePolicy policy, HttpPipelinePosition position) { options.AddPolicy(position, policy); }
private BlobServiceClient GetServiceClientFromSharedKeyConfig(TenantConfiguration config, BlobClientOptions options = default) => InstrumentClient( new BlobServiceClient( new Uri(config.BlobServiceEndpoint), new StorageSharedKeyCredential(config.AccountName, config.AccountKey), options ?? GetOptions()));
public async Task ProcessEvents() { #region Snippet:EventHubs_Processor_Sample06_ChooseStorageVersion var storageConnectionString = "<< CONNECTION STRING FOR THE STORAGE ACCOUNT >>"; var blobContainerName = "<< NAME OF THE BLOB CONTAINER >>"; /*@@*/ /*@@*/ storageConnectionString = StorageTestEnvironment.Instance.StorageConnectionString; /*@@*/ blobContainerName = _storageScope.ContainerName; var eventHubsConnectionString = "<< CONNECTION STRING FOR THE EVENT HUBS NAMESPACE >>"; var eventHubName = "<< NAME OF THE EVENT HUB >>"; var consumerGroup = "<< NAME OF THE EVENT HUB CONSUMER GROUP >>"; /*@@*/ /*@@*/ eventHubsConnectionString = EventHubsTestEnvironment.Instance.EventHubsConnectionString; /*@@*/ eventHubName = _eventHubScope.EventHubName; /*@@*/ consumerGroup = _eventHubScope.ConsumerGroups.First(); var storageClientOptions = new BlobClientOptions(); storageClientOptions.AddPolicy( new StorageApiVersionPolicy(), HttpPipelinePosition.PerCall); var storageClient = new BlobContainerClient( storageConnectionString, blobContainerName, storageClientOptions); var processor = new EventProcessorClient( storageClient, consumerGroup, eventHubsConnectionString, eventHubName); try { using var cancellationSource = new CancellationTokenSource(); cancellationSource.CancelAfter(TimeSpan.FromSeconds(30)); // The event handlers are not relevant for this sample; for // illustration, they're delegating the implementation to the // host application. processor.ProcessEventAsync += Application.ProcessorEventHandler; processor.ProcessErrorAsync += Application.ProcessorErrorHandler; try { await processor.StartProcessingAsync(cancellationSource.Token); await Task.Delay(Timeout.Infinite, cancellationSource.Token); } catch (TaskCanceledException) { // This is expected if the cancellation token is // signaled. } finally { // This may take up to the length of time defined // as part of the configured TryTimeout of the processor; // by default, this is 60 seconds. await processor.StopProcessingAsync(); } } catch { // The processor will automatically attempt to recover from any // failures, either transient or fatal, and continue processing. // Errors in the processor's operation will be surfaced through // its error handler. // // If this block is invoked, then something external to the // processor was the source of the exception. } finally { // It is encouraged that you unregister your handlers when you have // finished using the Event Processor to ensure proper cleanup. This // is especially important when using lambda expressions or handlers // in any form that may contain closure scopes or hold other references. processor.ProcessEventAsync -= Application.ProcessorEventHandler; processor.ProcessErrorAsync -= Application.ProcessorErrorHandler; } #endregion }
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> /// Initializes a new instance of the <see cref="AppendBlobClient"/> /// class. /// </summary> /// <param name="blobUri"> /// A <see cref="Uri"/> referencing the append blob that includes the /// name of the account, the name of the container, and the name of /// the blob. /// </param> /// <param name="credential"> /// The token credential used to sign requests. /// </param> /// <param name="options"> /// Optional client options that define the transport pipeline /// policies for authentication, retries, etc., that are applied to /// every request. /// </param> public AppendBlobClient(Uri blobUri, TokenCredential credential, BlobClientOptions options = default) : base(blobUri, credential, options) { }
/// <summary> /// Initializes a new instance of the <see cref="AppendBlobClient"/> /// class. /// </summary> /// <param name="blobUri"> /// A <see cref="Uri"/> referencing the append blob that includes the /// name of the account, the name of the container, and the name of /// the blob. /// </param> /// <param name="pipeline"> /// The transport pipeline used to send every request. /// </param> /// <param name="options"> /// Optional client options that define the transport pipeline /// policies for authentication, retries, etc., that are applied to /// every request. /// </param> internal AppendBlobClient(Uri blobUri, HttpPipeline pipeline, BlobClientOptions options = default) : base(blobUri, pipeline, options) { }
/// <summary> /// Initializes a new instance of the <see cref="AppendBlobClient"/> /// class. /// </summary> /// <param name="connectionString"> /// A connection string includes the authentication information /// required for your application to access data in an Azure Storage /// account at runtime. /// /// For more information, <see href="https://docs.microsoft.com/azure/storage/common/storage-configure-connection-string">Configure Azure Storage connection strings</see> /// </param> /// <param name="blobContainerName"> /// The name of the container containing this append blob. /// </param> /// <param name="blobName"> /// The name of this append blob. /// </param> /// <param name="options"> /// Optional client options that define the transport pipeline /// policies for authentication, retries, etc., that are applied to /// every request. /// </param> public AppendBlobClient(string connectionString, string blobContainerName, string blobName, BlobClientOptions options) : base(connectionString, blobContainerName, blobName, options) { AssertNoClientSideEncryption(options); }
/// <summary> /// Initializes a new instance of the <see cref="BlockBlobClient"/> /// class. /// </summary> /// <param name="blobUri"> /// A <see cref="Uri"/> referencing the blob that includes the /// name of the account, the name of the container, and the name of /// the blob. /// </param> /// <param name="credential"> /// The shared key credential used to sign requests. /// </param> /// <param name="options"> /// Optional client options that define the transport pipeline /// policies for authentication, retries, etc., that are applied to /// every request. /// </param> public EncryptedBlockBlobClient(Uri blobUri, StorageSharedKeyCredential credential, BlobClientOptions options = default) : base(blobUri, credential, options) { }
/// <summary> /// Initializes a new instance of the <see cref="AppendBlobClient"/> /// class. /// </summary> /// <param name="connectionString"> /// A connection string includes the authentication information /// required for your application to access data in an Azure Storage /// account at runtime. /// /// For more information, <see href="https://docs.microsoft.com/en-us/azure/storage/common/storage-configure-connection-string"/>. /// </param> /// <param name="blobContainerName"> /// The name of the container containing this append blob. /// </param> /// <param name="blobName"> /// The name of this append blob. /// </param> /// <param name="options"> /// Optional client options that define the transport pipeline /// policies for authentication, retries, etc., that are applied to /// every request. /// </param> public AppendBlobClient(string connectionString, string blobContainerName, string blobName, BlobClientOptions options) : base(connectionString, blobContainerName, blobName, options) { }
/// <summary> /// Get an BlobContainerClient instance in local /// </summary> /// <param name="name">Container name</param> /// <returns>A BlobContainerClient in local memory</returns> public BlobContainerClient GetBlobContainerClient(string name, BlobClientOptions options = null) { return(GetBlobServiceClient(options).GetBlobContainerClient(name)); }
/// <summary> /// Initializes a new instance of the <see cref="EncryptedBlockBlobClient"/> /// class. /// </summary> /// <param name="connectionString"> /// A connection string includes the authentication information /// required for your application to access data in an Azure Storage /// account at runtime. /// /// For more information, <see href="https://docs.microsoft.com/en-us/azure/storage/common/storage-configure-connection-string"/>. /// </param> /// <param name="containerName"> /// The name of the container containing this encrypted block blob. /// </param> /// <param name="blobName"> /// The name of this encrypted block blob. /// </param> /// <param name="options"> /// Optional client options that define the transport pipeline /// policies for authentication, retries, etc., that are applied to /// every request. /// </param> public EncryptedBlockBlobClient(string connectionString, string containerName, string blobName, BlobClientOptions options) : base(connectionString, containerName, blobName, options) { }
/// <summary> /// Initializes a new instance of the <see cref="BlockBlobClient"/> /// class. /// </summary> /// <param name="blobUri"> /// A <see cref="Uri"/> referencing the blob that includes the /// name of the account, the name of the container, and the name of /// the blob. /// </param> /// <param name="credential"> /// The token credential used to sign requests. /// </param> /// <param name="options"> /// Optional client options that define the transport pipeline /// policies for authentication, retries, etc., that are applied to /// every request. /// </param> public EncryptedBlockBlobClient(Uri blobUri, TokenCredential credential, BlobClientOptions options = default) : base(blobUri, credential, options) { }
/// <summary> /// Initializes a new instance of the <see cref="BlockBlobClient"/> /// class. /// </summary> /// <param name="blobUri"> /// A <see cref="Uri"/> referencing the encrypted block blob that includes the /// name of the account, the name of the container, and the name of /// the blob. /// </param> /// <param name="options"> /// Optional client options that define the transport pipeline /// policies for authentication, retries, etc., that are applied to /// every request. /// </param> public EncryptedBlockBlobClient(Uri blobUri, BlobClientOptions options = default) : base(blobUri, options) { }