C# CloudBlob.FetchAttributes方法代码示例

 public static void DoEvery(CloudBlob blob, TimeSpan interval, Action action)
 {
     while (true)
     {
         var lastPerformed = DateTimeOffset.MinValue;
         using (var arl = new AutoRenewLease(blob))
         {
             if (arl.HasLease)
             {
                 blob.FetchAttributes();
                 DateTimeOffset.TryParseExact(blob.Metadata["lastPerformed"], "R", CultureInfo.CurrentCulture, DateTimeStyles.AdjustToUniversal, out lastPerformed);
                 if (DateTimeOffset.UtcNow >= lastPerformed + interval)
                 {
                     action();
                     lastPerformed = DateTimeOffset.UtcNow;
                     blob.Metadata["lastPerformed"] = lastPerformed.ToString("R");
                     blob.SetMetadata(arl.leaseId);
                 }
             }
         }
         var timeLeft = (lastPerformed + interval) - DateTimeOffset.UtcNow;
         var minimum = TimeSpan.FromSeconds(5); // so we're not polling the leased blob too fast
         Thread.Sleep(
             timeLeft > minimum
             ? timeLeft
             : minimum);
     }
 }

        /// <summary>
        /// Check whether the specified blob exists
        /// </summary>
        /// <param name="blob">Blob to check</param>
        /// <returns>true if specified blob exists, and false if it doesn't</returns>
        private static bool BlobExists(CloudBlob blob)
        {
            try
            {
                // try fetching Attributes
                blob.FetchAttributes();
                return true;
            }
            catch (StorageClientException e)
            {
                if (e.ErrorCode == StorageErrorCode.ResourceNotFound)
                {
                    // if failed with ResourceNotFound error code, then the blob doesn't exist
                    return false;
                }
                else
                {
                    // something else went wrong
                    //throw;
                    Console.Write(e);
                    return false;

                }
            }
            catch (Exception e)
            {
                Console.Write(e);
                return false;
            }
        }

        public static void Read(BlobRequestOptions mapped, CloudBlob blob, ReaderDelegate reader)
        {
            blob.FetchAttributes(mapped);
            var props = MapFetchedAttrbitues(blob);

            var compression = blob.Properties.ContentEncoding ?? "";
            var md5 = blob.Metadata[LokadHashFieldName];

            switch (compression)
            {
                case "gzip":
                    using (var stream = blob.OpenRead(mapped))
                    {
                        ReadAndVerifyHash(stream, s =>
                            {
                                // important is not to flush the decompression stream
                                using (var decompress = new GZipStream(s, CompressionMode.Decompress, true))
                                {
                                    reader(props, decompress);
                                }
                            }, md5);
                    }

                    break;
                case "":
                    using (var stream = blob.OpenRead(mapped))
                    {
                        ReadAndVerifyHash(stream, s => reader(props, s), md5);
                    }
                    break;
                default:
                    var error = string.Format("Unsupported ContentEncoding '{0}'", compression);
                    throw new InvalidOperationException(error);
            }
        }

        /// <summary>
        /// Copies the full binary contents of the given blob to the given HTTP response.
        /// </summary>
        private static void CopyContents(CloudBlob blob, HttpResponseBase response, long offset = 0)
        {
            blob.FetchAttributes();

            response.BufferOutput = false;
            response.AddHeader("Content-Length", blob.Attributes.Properties.Length.ToString());
            response.Flush();

            using (var reader = blob.OpenRead())
            {
                reader.Seek(offset, System.IO.SeekOrigin.Begin);

                byte[] buffer = new byte[1024 * 4]; // 4KB buffer
                while (reader.CanRead)
                {
                    int numBytes = reader.Read(buffer, 0, buffer.Length);

                    if (numBytes <= 0)
                        break;

                    response.BinaryWrite(buffer);
                    response.Flush();
                }
            }
        }

        // The mutex must already exists
        public Mutex(CloudBlobContainer container, string mutexName, Exception e)
        {
            blob = container.GetBlobReference(mutexName);

            byte[] b1 = { 1 };
            BlobRequestOptions requestOpt = new BlobRequestOptions();
            bool keepGoing = true;
            string oldEtag = "";
            int lastChange = 0;
            do
            {
                byte[] b;
                string eTag;
                try
                {
                    blob.FetchAttributes();
                    eTag = blob.Attributes.Properties.ETag;
                    if (eTag != oldEtag)
                    {
                        lastChange = Environment.TickCount;
                        oldEtag = eTag;
                    }
                    b = blob.DownloadByteArray();
                }
                catch (Exception)
                {
                    throw e;
                }

                requestOpt.AccessCondition = AccessCondition.IfMatch(eTag);
                if (b[0] == 0 || Environment.TickCount - lastChange > 3000) // on ne peut garder un lock plus de 3 s
                {
                    try
                    {
                        blob.UploadByteArray(b1, requestOpt);
                        keepGoing = false;
                    }
                    catch (StorageClientException ex)
                    {
                        if (ex.ErrorCode != StorageErrorCode.ConditionFailed)
                            throw;
                    }
                }
                else
                    Thread.Sleep(50);   // constante arbitraire
            } while (keepGoing);
        }

 public bool Exists(CloudBlob blob)
 {
     try
     {
         blob.FetchAttributes();
         return true;
     }
     catch (StorageClientException e)
     {
         if (e.ErrorCode == StorageErrorCode.ResourceNotFound)
         {
             return false;
         }
         else
         {
             throw;
         }
     }
 }

 private void DownloadBlobInParallel(CloudBlob blob, Stream stream)
 {
     try
     {
         blob.FetchAttributes();
         var order = new List<string>();
         var blocksToDownload = new Queue<Block>();
         CalculateBlocks(blocksToDownload, (int)blob.Properties.Length, order);
         ExecuteInParallel(() => AsLongAsThereAre(blocksToDownload, block =>
         {
             var s = DownloadBlockFromBlob(blob, block, blocksToDownload); if (s == null) return;
             var buffer = new byte[BlockSize];
             ExtractBytesFromBlockIntoBuffer(buffer, s, block);
             lock (stream)
             {
                 stream.Position = block.Offset;
                 stream.Write(buffer, 0,block.Length);
             }
         }));
         stream.Seek(0, SeekOrigin.Begin);
     }
     catch (StorageClientException ex) // to handle race conditions between multiple active instances.
     {
         logger.Warn(ex.Message);
     }
     catch (StorageServerException ex) // prevent azure hickups from hurting us.
     {
         logger.Warn(ex.Message);
     }
 }

 private void DownloadBlobInParallel(CloudBlob blob, Stream stream)
 {
     blob.FetchAttributes();
     var order = new List<string>();
     var blocksToDownload = new Queue<Block>();
     CalculateBlocks(blocksToDownload, (int)blob.Properties.Length, order);
     ExecuteInParallel(() => AsLongAsThereAre(blocksToDownload, block =>
     {
         var s = DownloadBlockFromBlob(blob, block, blocksToDownload); if (s == null) return;
         var buffer = new byte[BlockSize];
         ExtractBytesFromBlockIntoBuffer(buffer, s, block);
         lock (stream)
         {
             stream.Position = block.Offset;
             stream.Write(buffer, 0,block.Length);
         }
     }));
     stream.Seek(0, SeekOrigin.Begin);
 }

 private static void FetchMetadataIfMissing(CloudBlob blob)
 {
     if(blob.Metadata.Count == 0)
     {
         try
         {
             blob.FetchAttributes();
         } catch(StorageClientException stEx)
         {
             if (stEx.ErrorCode == StorageErrorCode.BlobNotFound || stEx.ErrorCode == StorageErrorCode.ResourceNotFound)
                 return;
             throw;
         }
     }
 }

 static bool Exists(CloudBlob blob)
 {
     try
     {
         blob.FetchAttributes();
         return true;
     }
     catch (StorageClientException e)
     {
         switch (e.ErrorCode)
         {
             case StorageErrorCode.ContainerNotFound:
             case StorageErrorCode.ResourceNotFound:
                 return false;
         }
         throw;
     }
 }

 private static void HandlePublicBlobRequestWithCacheSupport(HttpContext context, CloudBlob blob, HttpResponse response)
 {
     // Set the cache request properties as IIS will include them regardless for now
     // even when we wouldn't want them on 304 response...
     response.Cache.SetMaxAge(TimeSpan.FromMinutes(0));
     response.Cache.SetCacheability(HttpCacheability.Private);
     var request = context.Request;
     blob.FetchAttributes();
     string ifNoneMatch = request.Headers["If-None-Match"];
     string ifModifiedSince = request.Headers["If-Modified-Since"];
     if (ifNoneMatch != null)
     {
         if (ifNoneMatch == blob.Properties.ETag)
         {
             response.ClearContent();
             response.StatusCode = 304;
             return;
         }
     }
     else if (ifModifiedSince != null)
     {
         DateTime ifModifiedSinceValue;
         if (DateTime.TryParse(ifModifiedSince, out ifModifiedSinceValue))
         {
             ifModifiedSinceValue = ifModifiedSinceValue.ToUniversalTime();
             if (blob.Properties.LastModifiedUtc <= ifModifiedSinceValue)
             {
                 response.ClearContent();
                 response.StatusCode = 304;
                 return;
             }
         }
     }
     var fileName = blob.Name.Contains("/MediaContent/") ?
         request.Path : blob.Name;
     response.ContentType = StorageSupport.GetMimeType(fileName);
     //response.Cache.SetETag(blob.Properties.ETag);
     response.Headers.Add("ETag", blob.Properties.ETag);
     response.Cache.SetLastModified(blob.Properties.LastModifiedUtc);
     blob.DownloadToStream(response.OutputStream);
 }

 private static void BreakTestLeaseIfExists(CloudBlob blob)
 {
     blob.FetchAttributes();
     if (blob.Metadata.AllKeys.Contains(leasedForTestTag))
         BreakLease(blob);
 }

        public static List<CloudBlob> ListBlobs()
        {
            List<IListBlobItem> blobItemList = null;

            List<CloudBlob> blobList = null;

            try
            {
                string storageAccountConnection = string.Empty;

                storageAccountConnection = ConfigurationManager.AppSettings["StorageAccount.ConnectionString"].ToString();

                Logger.Write("Storage Connection: " + storageAccountConnection);

                // If you want to use Windows Azure cloud storage account, use the following
                // code (after uncommenting) instead of the code above.
                cloudStorageAccount = CloudStorageAccount.Parse(storageAccountConnection);

                Logger.Write("Blob Uri: " + cloudStorageAccount.BlobEndpoint.AbsoluteUri);

                // Create the blob client, which provides
                // authenticated access to the Blob service.
                blobClient = cloudStorageAccount.CreateCloudBlobClient();

                string deploymentPackageFolderString = string.Empty;

                deploymentPackageFolderString = ConfigurationManager.AppSettings["DeploymentPackageFolder"].ToString();

                Logger.Write("Deployment Package Folder: " + deploymentPackageFolderString);

                // Get the container reference.
                blobContainer = blobClient.GetContainerReference(deploymentPackageFolderString);

                // Create the container if it does not exist.
                blobContainer.CreateIfNotExist();

                // Set permissions on the container.
                containerPermissions = new BlobContainerPermissions();

                // This sample sets the container to have public blobs. Your application
                // needs may be different. See the documentation for BlobContainerPermissions
                // for more information about blob container permissions.
                containerPermissions.PublicAccess = BlobContainerPublicAccessType.Blob;

                blobContainer.SetPermissions(containerPermissions);

                BlobRequestOptions blobReqOptions = new BlobRequestOptions();

                blobReqOptions.BlobListingDetails = BlobListingDetails.All;
                blobReqOptions.Timeout = new TimeSpan(0, 5, 0);
                blobReqOptions.UseFlatBlobListing = true;

                blobItemList = blobContainer.ListBlobs(blobReqOptions).ToList();

                if (blobList == null)
                {
                    blobList = new List<CloudBlob>();
                }

                foreach (IListBlobItem blobItem in blobItemList)
                {
                    Logger.Write("Blob Uri: " + blobItem.Uri.ToString());

                    CloudBlob blobEntry = new CloudBlob(blobItem.Uri.ToString());

                    blobEntry.FetchAttributes();

                    blobList.Add(blobEntry);
                }
            }
            catch (System.Exception ex)
            {
                Logger.Write(string.Format("Error in List<IListBlobItem> ListBlobs()  Error: {0}", ex.Message));

                blobList = null;
            }

            return blobList;
        }