public async Task Write(ICloudBlob blob, string content)
		{
			using (Stream stream = new MemoryStream(Encoding.UTF8.GetBytes(content)))
			{
				await blob.UploadFromStreamAsync(stream);
			}
		}

 public UpdateBlob(ICloudBlob blob, IBlobLeaseFactory blobLeaseFactory)
 {
     _blob = blob;
     _blobLeaseFactory = blobLeaseFactory;
     _updateDomain = string.Empty;
     _instanceIds = new HashSet<string>();
 }

 /// <summary>
 /// Creates a new instance from a ICloudBlob.
 /// </summary>
 /// <param name="original">The original cloud blob.</param>
 /// <returns></returns>
 public static AzureBlobInfo Create(ICloudBlob original)
 {
     var file = original as CloudBlockBlob;
     if (file != null)
     {
         var modified = DateTimeOffset.MinValue;
         var modifiedOk = false;
         if (file.Metadata.ContainsKey("CbModifiedTime"))
         {
             modifiedOk = DateTimeOffset.TryParse(file.Metadata["CbModifiedTime"], out modified);
         }
         return new AzureBlobInfo
         {
             BlobElement = file,
             ContentType = file.Properties.ContentType,
             Name = file.Name,
             Size = file.Properties.Length,
             Location = file.Uri.AbsoluteUri,
             ModifiedTime = modifiedOk ? modified : default(DateTimeOffset?)
         };
     }
     var folder = original as CloudBlobDirectory;
     if (folder == null)
     {
         return null;
     }
     return new AzureBlobInfo
     {                
         Name = folder.Prefix,
         Location = folder.Uri.AbsoluteUri
     };
 }

        public AzureIndexInput(AzureDirectory azuredirectory, ICloudBlob blob)
            : base(blob.Name)
        {
            _name = blob.Uri.Segments[blob.Uri.Segments.Length - 1];

            _fileMutex = BlobMutexManager.GrabMutex(_name);
            _fileMutex.WaitOne();

            try
            {
                _azureDirectory = azuredirectory;
                _blobContainer = azuredirectory.BlobContainer;
                _blob = blob;

                string fileName = _name;
                StreamOutput fileStream = _azureDirectory.CreateCachedOutputAsStream(fileName);

                // get the blob
                _blob.DownloadToStream(fileStream);

                fileStream.Flush();
                Debug.WriteLine("GET {0} RETREIVED {1} bytes", _name, fileStream.Length);

                fileStream.Close();

                // and open it as an input
                _indexInput = CacheDirectory.openInput(fileName, IOContext.DEFAULT);
            }
            finally
            {
                _fileMutex.ReleaseMutex();
            }
        }

 private static async Task CreateBlobIfNoneExists(ICloudBlob updateBlob)
 {
     if (!await updateBlob.ExistsAsync())
     {
         await BlobUtils.CreateEmptyBlob(updateBlob);
     }
 }

 public static string DownloadText(ICloudBlob blob, Encoding encoding, AccessCondition accessCondition = null, BlobRequestOptions options = null, OperationContext operationContext = null)
 {
     using (MemoryStream stream = new MemoryStream())
     {
         blob.DownloadToStream(stream, accessCondition, options, operationContext);
         return encoding.GetString(stream.ToArray());
     }
 }

		public async Task<string> Read(ICloudBlob blob)
		{
			using (Stream stream = await blob.OpenReadAsync())
			using (StreamReader reader = new StreamReader(stream))
			{
				return await reader.ReadToEndAsync();
			}
		}

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

 public static async Task<string> DownloadTextAsync(ICloudBlob blob, Encoding encoding, AccessCondition accessCondition = null, BlobRequestOptions options = null, OperationContext operationContext = null)
 {
     using (MemoryStream stream = new MemoryStream())
     {
         await blob.DownloadToStreamAsync(stream.AsOutputStream(), accessCondition, options, operationContext);
         byte[] buffer = stream.ToArray();
         return encoding.GetString(buffer, 0, buffer.Length);
     }
 }

        /// <summary>
        /// Return a secret, persistent Download Url for a given Blob
        /// </summary>
        static string GetDownloadUrlFor(ICloudBlob blob)
        {
            var signature = blob.GetSharedAccessSignature(new SharedAccessBlobPolicy
            {
                SharedAccessExpiryTime = new DateTime(2050, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc)
            }, DownloadPolicyName);

            return string.Format("{0}{1}", blob.Uri.ToString().Replace(" ", "%20"), signature);
        }

 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 static async Task WaitForCopyAsync(ICloudBlob blob)
 {
     bool copyInProgress = true;
     while (copyInProgress)
     {
         await Task.Delay(1000);
         await blob.FetchAttributesAsync();
         copyInProgress = (blob.CopyState.Status == CopyStatus.Pending);
     }
 }

 /// <summary>
 /// Azure storage blob constructor
 /// </summary>
 /// <param name="blob">ICloud blob object</param>
 public AzureStorageBlob(ICloudBlob blob)
 {
     Name = blob.Name;
     ICloudBlob = blob;
     BlobType = blob.BlobType;
     Length = blob.Properties.Length;
     ContentType = blob.Properties.ContentType;
     LastModified = blob.Properties.LastModified;
     SnapshotTime = blob.SnapshotTime;
 }

 public static void WaitForCopyTask(ICloudBlob blob)
 {
     bool copyInProgress = true;
     while (copyInProgress)
     {
         Thread.Sleep(1000);
         blob.FetchAttributesAsync().Wait();
         copyInProgress = (blob.CopyState.Status == CopyStatus.Pending);
     }
 }

 /// <summary>
 /// Creates a job to copy from a blob.
 /// </summary>
 /// <param name="destBlob">Destination blob to copy to. 
 /// User should call the method on this object.</param>
 /// <param name="sourceBlob">Source blob to copy from.</param>
 /// <returns>Job object to do copying.</returns>
 public static BlobCopyJob CreateCopyJob(
     this ICloudBlob destBlob,
     ICloudBlob sourceBlob)
 {
     return new BlobCopyJob()
     {
         SourceBlob = sourceBlob,
         DestBlob = destBlob
     };
 }

 //https://github.com/Particular/NServiceBus.Azure/blob/e9db29beb21d1fd914191e479cb5948fffd92f3b/src/NServiceBus.Azure/DataBus/Azure/BlobStorage/BlobStorageDataBus.cs#L41
 protected override void SetValidUntil(ICloudBlob cloudBlob, TimeSpan timeToBeReceived)
 {
     if (timeToBeReceived == TimeSpan.MaxValue)
     {
         cloudBlob.Metadata["ValidUntil"] = TimeSpan.MaxValue.ToString();
     }
     else
     {
         cloudBlob.Metadata["ValidUntil"] = (DateTime.Now + timeToBeReceived).ToString();
     }
 }

 public static string GetSasUrl(ICloudBlob blob, SharedAccessBlobPermissions permissions)
 {
     var policy = new SharedAccessBlobPolicy
     {
         SharedAccessExpiryTime = DateTime.Now.AddMinutes(30),
         Permissions = permissions
     };
     string sasBlobToken = blob.GetSharedAccessSignature(policy);
     //Return the URI string for the container, including the SAS token.
     return blob.Uri + sasBlobToken;
 }

		/// <summary>
		/// Initializes a new instance of <see cref="OperationHandle" /> class.
		/// </summary>
		/// <param name="source">A source blob.</param>
		/// <param name="target">A destination blob.</param>
		/// <param name="sasToken">A security access token.</param>
		public OperationHandle(ICloudBlob source, ICloudBlob target, String sasToken)
		{
			DeleteIsCompleted = false;

			CopyIsCompleted = false;

			SourceBlob = source;

			TargetBlob = target;

			this.sasToken = sasToken;
		}

 private static async Task UpdateBlob(ICloudBlob blob)
 {
     try
     {
         byte[] dataBytes = new byte[40];
         await blob.UploadFromByteArrayAsync(dataBytes, 0, 40);
     }
     catch (Exception e)
     {
         Console.WriteLine(e);
     }
 }

 /// <summary>
 /// Initializes a new instance of the BlobReadStreamBase class.
 /// </summary>
 /// <param name="blob">Blob reference to read from</param>
 /// <param name="accessCondition">An object that represents the access conditions for the blob. If null, no condition is used.</param>
 /// <param name="options">An object that specifies any additional options for the request.</param>
 /// <param name="operationContext">An <see cref="OperationContext"/> object for tracking the current operation.</param>
 protected BlobReadStreamBase(ICloudBlob blob, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
 {
     this.blob = blob;
     this.isLengthAvailable = false;
     this.currentOffset = 0;
     this.buffer = new MemoryStream();
     this.accessCondition = accessCondition;
     this.lockedToETag = false;
     this.options = options;
     this.operationContext = operationContext;
     this.blobMD5 = options.DisableContentMD5Validation.Value ? null : new MD5Wrapper();
     this.lastException = null;
 }