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)
{
}
