/// <summary>
 /// Constructs a web request to delete the container and all of the blobs within it.
 /// </summary>
 /// <param name="uri">The absolute URI to the container.</param>
 /// <param name="timeout">The server timeout interval.</param>
 /// <param name="accessCondition">The access condition to apply to the request.</param>
 /// <param name="operationContext">An <see cref="OperationContext"/> object for tracking the current operation.</param>
 /// <returns>A web request to use to perform the operation.</returns>
 public static HttpWebRequest Delete(Uri uri, int? timeout, AccessCondition accessCondition, OperationContext operationContext)
 {
     UriQueryBuilder containerBuilder = GetContainerUriQueryBuilder();
     HttpWebRequest request = HttpWebRequestFactory.Delete(uri, containerBuilder, timeout, operationContext);
     request.ApplyAccessCondition(accessCondition);
     return request;
 }

 /// <summary>
 /// Constructs a web request to delete the directory and all of the files within it.
 /// </summary>
 /// <param name="uri">The absolute URI to the directory.</param>
 /// <param name="timeout">The server timeout interval.</param>
 /// <param name="accessCondition">The access condition to apply to the request.</param>
 /// <param name="useVersionHeader">A boolean value indicating whether to set the <i>x-ms-version</i> HTTP header.</param>
 /// <param name="operationContext">An <see cref="OperationContext" /> object for tracking the current operation.</param>
 /// <returns>A <see cref="System.Net.HttpWebRequest"/> object.</returns>
 public static HttpWebRequest Delete(Uri uri, int? timeout, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext)
 {
     UriQueryBuilder directoryBuilder = GetDirectoryUriQueryBuilder();
     HttpWebRequest request = HttpWebRequestFactory.Delete(uri, directoryBuilder, timeout, useVersionHeader, operationContext);
     request.ApplyAccessCondition(accessCondition);
     return request;
 }

 /// <summary>
 /// Generates a web request to return the properties and user-defined metadata for this directory.
 /// </summary>
 /// <param name="uri">The absolute URI to the directory.</param>
 /// <param name="timeout">The server timeout interval.</param>
 /// <param name="accessCondition">The access condition to apply to the request.</param>
 /// <returns>A web request to use to perform the operation.</returns>
 public static HttpRequestMessage GetProperties(Uri uri, int? timeout, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
 {
     UriQueryBuilder directoryBuilder = GetDirectoryUriQueryBuilder();
     HttpRequestMessage request = HttpRequestMessageFactory.GetProperties(uri, timeout, directoryBuilder, content, operationContext);
     request.ApplyAccessCondition(accessCondition);
     return request;
 }

 /// <summary>
 /// Generates a web request to return the user-defined metadata for this container.
 /// </summary>
 /// <param name="uri">The absolute URI to the container.</param>
 /// <param name="timeout">The server timeout interval.</param>
 /// <param name="accessCondition">The access condition to apply to the request.</param>
 /// <returns>A web request to use to perform the operation.</returns>
 public static StorageRequestMessage GetMetadata(Uri uri, int? timeout, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials)
 {
     UriQueryBuilder containerBuilder = GetContainerUriQueryBuilder();
     StorageRequestMessage request = HttpRequestMessageFactory.GetMetadata(uri, timeout, containerBuilder, content, operationContext, canonicalizer, credentials);
     request.ApplyAccessCondition(accessCondition);
     return request;
 }

        /// <summary>
        /// Applies the condition to the web request.
        /// </summary>
        /// <param name="request">The request to be modified.</param>
        /// <param name="accessCondition">Access condition to be added to the request.</param>
        internal static void ApplyAccessCondition(this HttpWebRequest request, AccessCondition accessCondition)
        {
            if (accessCondition != null)
            {
                if (!string.IsNullOrEmpty(accessCondition.IfMatchETag))
                {
                    request.Headers[HttpRequestHeader.IfMatch] = accessCondition.IfMatchETag;
                }

                if (!string.IsNullOrEmpty(accessCondition.IfNoneMatchETag))
                {
                    request.Headers[HttpRequestHeader.IfNoneMatch] = accessCondition.IfNoneMatchETag;
                }

                if (accessCondition.IfModifiedSinceTime.HasValue)
                {
                    // Not using this property will cause Restricted property exception to be thrown
                    request.IfModifiedSince = accessCondition.IfModifiedSinceTime.Value.UtcDateTime;
                }

                if (accessCondition.IfNotModifiedSinceTime.HasValue)
                {
                    request.Headers[HttpRequestHeader.IfUnmodifiedSince] =
                        HttpUtility.ConvertDateTimeToHttpString(accessCondition.IfNotModifiedSinceTime.Value);
                }

                if (!string.IsNullOrEmpty(accessCondition.LeaseId))
                {
                    request.Headers[Constants.HeaderConstants.LeaseIdHeader] = accessCondition.LeaseId;
                }
            }
        }

 /// <summary>
 /// Generates a web request to return the user-defined metadata for this container.
 /// </summary>
 /// <param name="uri">The absolute URI to the container.</param>
 /// <param name="timeout">The server timeout interval.</param>
 /// <param name="accessCondition">The access condition to apply to the request.</param>
 /// <returns>A web request to use to perform the operation.</returns>
 public static HttpRequestMessage GetMetadata(Uri uri, int? timeout, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
 {
     UriQueryBuilder containerBuilder = GetContainerUriQueryBuilder();
     HttpRequestMessage request = HttpRequestMessageFactory.GetMetadata(uri, timeout, containerBuilder, content, operationContext);
     request.ApplyAccessCondition(accessCondition);
     return request;
 }

        public async virtual void UploadBlockBlobAsync(string blobName, Stream streamToUpload, string contentType, AccessCondition accessCondition = null)
        {
            var blockBlob = GetBlockBlobReference(blobName);
            blockBlob.Properties.ContentType = contentType;

            await blockBlob.UploadFromStreamAsync(streamToUpload, accessCondition, null, null);
        }

 /// <summary>
 /// Constructs a web request to delete the share and all of the files within it.
 /// </summary>
 /// <param name="uri">The absolute URI to the share.</param>
 /// <param name="timeout">The server timeout interval.</param>
 /// <param name="accessCondition">The access condition to apply to the request.</param>
 /// <returns>A web request to use to perform the operation.</returns>
 public static HttpRequestMessage Delete(Uri uri, int? timeout, AccessCondition accessCondition, HttpContent content, OperationContext operationContext)
 {
     UriQueryBuilder shareBuilder = GetShareUriQueryBuilder();
     HttpRequestMessage request = HttpRequestMessageFactory.Delete(uri, timeout, shareBuilder, content, operationContext);
     request.ApplyAccessCondition(accessCondition);
     return request;
 }

 /// <summary>
 /// Generates a web request to return the user-defined metadata for this share.
 /// </summary>
 /// <param name="uri">The absolute URI to the share.</param>
 /// <param name="timeout">The server timeout interval.</param>
 /// <param name="accessCondition">The access condition to apply to the request.</param>
 /// <param name="useVersionHeader">A flag indicating whether to set the x-ms-version HTTP header.</param>
 /// <param name="operationContext">An <see cref="OperationContext" /> object for tracking the current operation.</param>
 /// <returns>A web request to use to perform the operation.</returns>
 public static HttpWebRequest GetMetadata(Uri uri, int? timeout, AccessCondition accessCondition, bool useVersionHeader, OperationContext operationContext)
 {
     UriQueryBuilder shareBuilder = GetShareUriQueryBuilder();
     HttpWebRequest request = HttpWebRequestFactory.GetMetadata(uri, timeout, shareBuilder, useVersionHeader, operationContext);
     request.ApplyAccessCondition(accessCondition);
     return request;
 }

 static async Task UploadTextAsync(ICloudBlob blob, string text, AccessCondition accessCondition)
 {
     blob.Properties.ContentEncoding = "UTF-8";
     blob.Properties.ContentType = "text/plain";
     using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(text))) {
         await blob.UploadFromStreamAsync(stream, accessCondition, null, null);
     }
 }

        /// <summary>
        /// Constructs a web request to delete the share and all of the files within it.
        /// </summary>
        /// <param name="uri">The absolute URI to the share.</param>
        /// <param name="timeout">The server timeout interval.</param>
        /// <param name="accessCondition">The access condition to apply to the request.</param>
        /// <returns>A web request to use to perform the operation.</returns>
        public static StorageRequestMessage Delete(Uri uri, int? timeout, AccessCondition accessCondition, HttpContent content, OperationContext operationContext, ICanonicalizer canonicalizer, StorageCredentials credentials)
        {
            UriQueryBuilder shareBuilder = GetShareUriQueryBuilder();

            StorageRequestMessage request = HttpRequestMessageFactory.Delete(uri, timeout, shareBuilder, content, operationContext, canonicalizer, credentials);
            request.ApplyAccessCondition(accessCondition);
            return request;
        }

        public static void Run()
        {
            #region Obtain a client from the connection string

              CloudStorageAccount storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString"));
              CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
              Console.WriteLine("Parsed connection string and created blob client.");

              #endregion

              #region Obtain reference to images container

              CloudBlobContainer imageContainer = blobClient.GetContainerReference("images");
              Console.WriteLine("Obtained reference to images container.");

              #endregion

              #region Show concurrency management using ETag property

              Console.WriteLine();

              CloudBlockBlob blockBlob1 = imageContainer.GetBlockBlobReference(@"rocks/WhitePocketFocus.jpg");
              CloudBlockBlob blockBlob2 = imageContainer.GetBlockBlobReference(@"rocks/WhitePocketFocus.jpg");
              blockBlob1.FetchAttributes();
              blockBlob2.FetchAttributes();
              Console.WriteLine("[1] Obtained ETag {0} for rocks/WhitePocketFocus.jpg in images container.", blockBlob1.Properties.ETag);
              Console.WriteLine("[2] Obtained ETag {0} for rocks/WhitePocketFocus.jpg in images container.", blockBlob2.Properties.ETag);

              var etag = blockBlob1.Properties.ETag;
              var accessCondition = new AccessCondition {IfMatchETag = etag};

              var metadata = new Dictionary<string, string>()
              {
            { "License",  "snowpeak" },
            { "URL",      "http://www.flickr.com/photos/snowpeak/7394540572/sizes/l/in/[email protected]/"}
              };

              Console.WriteLine("[1] Setting metadata on rocks/WhitePocketFocus.jpg in images container.");
              foreach (KeyValuePair<string, string> pair in metadata) { blockBlob1.Metadata.Add(pair); }
              blockBlob1.SetMetadata(accessCondition);

              blockBlob1.FetchAttributes();
              Console.WriteLine("[1] New ETag {0} for rocks/WhitePocketFocus.jpg in images container.", blockBlob1.Properties.ETag);

              try
              {
            Console.WriteLine("[2] Setting metadata on rocks/WhitePocketFocus.jpg in images container.");
            foreach (KeyValuePair<string, string> pair in metadata) { blockBlob2.Metadata.Add(pair); }
            blockBlob2.SetMetadata(accessCondition);
              }
              catch (Exception exception)
              {
            Console.WriteLine("[2] Caught exception '" + exception.GetType() + "' while trying to set metadata on rocks/WhitePocketFocus.jpg in images container.");
            Console.WriteLine(exception.StackTrace);
              }

              #endregion
        }

     public async static Task UploadFromStreamEncryptedAsync(this ICloudBlob blob, IBlobCryptoProvider provider, Stream stream,
 AccessCondition accessCondition = null, BlobRequestOptions options = null,
 OperationContext operationContext = null)
     {
         using (Stream encryptedStream = provider.EncryptedStream(stream))
         {
             await blob.UploadFromStreamAsync(encryptedStream, accessCondition, options, operationContext);
         }
     }

 static void UploadText(ICloudBlob blob, string text, AccessCondition accessCondition)
 {
     blob.Properties.ContentEncoding = "UTF-8";
     blob.Properties.ContentType = "text/plain";
     using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(text)))
     {
         blob.UploadFromStream(stream, accessCondition);
     }
 }

     public async static Task DownloadToFileEncryptedAsync(this ICloudBlob blob, IBlobCryptoProvider provider, string path, FileMode mode,
 AccessCondition accessCondition = null, BlobRequestOptions options = null,
 OperationContext operationContext = null)
     {
         using (FileStream fileStream = new FileStream(path, mode))
         {
             await blob.DownloadToStreamEncryptedAsync(provider, fileStream, accessCondition, options, operationContext);
         }
     }

        public AzureWriteBlockBlobStream(CloudBlockBlob blob, AccessCondition condition)
        {
            _blob = blob;
            _condition = condition;

            long min = Math.Min(blob.Properties.Length, AzureBlockSize);
            if (min < 0) { min = 0; }
            _buff = new MemoryStream((int)min);
            _partNumber = 1;
        }

 public static void DownloadToStreamEncrypted(this ICloudBlob blob, IBlobCryptoProvider provider, Stream stream,
     AccessCondition accessCondition = null, BlobRequestOptions options = null,
     OperationContext operationContext = null)
 {
     using (Stream blobStream = blob.OpenRead(accessCondition, options, operationContext))
     using (Stream decryptedStream = provider.DecryptedStream(blobStream))
     {
         decryptedStream.CopyTo(stream);
     }
 }

     public async static Task UploadFromFileEncryptedAsync(this ICloudBlob blob, IBlobCryptoProvider provider, string path, FileMode mode,
 AccessCondition accessCondition = null, BlobRequestOptions options = null,
 OperationContext operationContext = null)
     {
         using (FileStream fileStream = new FileStream(path, mode))
         using (Stream encryptedStream = provider.EncryptedStream(fileStream))
         {
             await blob.UploadFromStreamAsync(encryptedStream, accessCondition, options, operationContext);
         }
     }

 public static CloudBlockBlob Upload(this CloudBlockBlob blob, string text
     , AccessCondition accessCondition = null, BlobRequestOptions blobRequestOptions = null, OperationContext operationContext = null)
 {
     var bytes = Encoding.UTF8.GetBytes(text);
     using (var ms = new MemoryStream(bytes))
     {
         blob.UploadFromStream(ms, accessCondition, blobRequestOptions, operationContext);
     }
     return blob;
 }

 public static CloudBlob GetBlobReferenceFromServer(
     CloudBlobContainer container, 
     string blobName, 
     AccessCondition accessCondition = null,
     BlobRequestOptions options = null,
     OperationContext operationContext = null)
 {
     CloudBlob blob = container.GetBlobReference(blobName);
     return GetBlobReferenceFromServer(blob, accessCondition, options, operationContext);
 }