C# CloudBlobContainer.ListBlobs方法代码示例

        /// <summary>
        ///  Taken from: http://blogs.msdn.com/b/windowsazurestorage/archive/2012/06/12/introducing-asynchronous-cross-account-copy-blob.aspx
        /// </summary>
        /// <param name="destContainer">The container to monitor</param>
        public static void MonitorCopy(CloudBlobContainer destContainer)
        {
            var pendingCopy = true;

            while (pendingCopy)
            {
                var destBlobList = destContainer.ListBlobs(true, BlobListingDetails.Copy);

                foreach (var destBlob in destBlobList.Select(dest => dest as CloudBlob))
                {
                    if (destBlob.CopyState == null)
                    {
                        Debug.WriteLine("BlobStorage.MonitorCopy: CopyState is null. Small sleep, then we assume it's done!");
                        Thread.Sleep(5000);
                        return;
                    }

                    switch (destBlob.CopyState.Status)
                    {
                        case CopyStatus.Failed:
                        case CopyStatus.Aborted:
                            Debug.WriteLine("BlobStorage.MonitorCopy: Copy Failed or Aborted; restarting copy");
                            destBlob.StartCopyFromBlob(destBlob.CopyState.Source);
                            break;
                        case CopyStatus.Success:
                            pendingCopy = false;
                            break;
                    }
                }

                Thread.Sleep(1000);
            }
        }

        public ContainerTreeNode(CloudBlobContainer container)
            : this()
        {
            Container = container;

            foreach (var blob in container.ListBlobs().OfType<CloudBlob>())
                Nodes.Add(new BlobTreeNode(blob));

            Text = container.Name;
        }

        protected void DeleteAllBlobs(CloudBlobContainer container) {
            foreach ( var blob in container.ListBlobs() ) {
                if ( blob is CloudBlob ) {
                    ( (CloudBlob)blob ).DeleteIfExists();
                }

                if ( blob is CloudBlobDirectory ) {
                    DeleteAllBlobs((CloudBlobDirectory)blob);
                }
            }
        }

        public const int CacheControlOneWeekExpiration = 7 * 24 * 60 * 60; // 1 week

        #endregion Fields

        #region Methods

        /// <summary>
        ///   Finds all js and css files in a container and creates a gzip compressed
        ///   copy of the file with ".gzip" appended to the existing blob name
        /// </summary>
        public static void EnsureGzipFiles(
            CloudBlobContainer container,
            int cacheControlMaxAgeSeconds)
        {
            string cacheControlHeader = "public, max-age=" + cacheControlMaxAgeSeconds.ToString();

            var blobInfos = container.ListBlobs(
                new BlobRequestOptions() { UseFlatBlobListing = true });
            Parallel.ForEach(blobInfos, (blobInfo) =>
            {
                string blobUrl = blobInfo.Uri.ToString();
                CloudBlob blob = container.GetBlobReference(blobUrl);

                // only create gzip copies for css and js files
                string extension = Path.GetExtension(blobInfo.Uri.LocalPath);
                if (extension != ".css" && extension != ".js")
                    return;

                // see if the gzip version already exists
                string gzipUrl = blobUrl + ".gzip";
                CloudBlob gzipBlob = container.GetBlobReference(gzipUrl);
                if (gzipBlob.Exists())
                    return;

                // create a gzip version of the file
                using (MemoryStream memoryStream = new MemoryStream())
                {
                    // push the original blob into the gzip stream
                    using (GZipStream gzipStream = new GZipStream(
                        memoryStream, CompressionMode.Compress, CompressionLevel.BestCompression))
                    using (BlobStream blobStream = blob.OpenRead())
                    {
                        blobStream.CopyTo(gzipStream);
                    }

                    // the gzipStream MUST be closed before its safe to read from the memory stream
                    byte[] compressedBytes = memoryStream.ToArray();

                    // upload the compressed bytes to the new blob
                    gzipBlob.UploadByteArray(compressedBytes);

                    // set the blob headers
                    gzipBlob.Properties.CacheControl = cacheControlHeader;
                    gzipBlob.Properties.ContentType = GetContentType(extension);
                    gzipBlob.Properties.ContentEncoding = "gzip";
                    gzipBlob.SetProperties();
                }
            });
        }

        /// <summary>
        /// Get Items
        /// </summary>
        /// <param name="container">Container</param>
        /// <param name="client">Client</param>
        /// <param name="path">Path</param>
        /// <returns>Storage Items</returns>
        private IEnumerable<IStorageItem> GetItems(CloudBlobContainer container, AmazonS3 client, string path)
        {
            if (null != container)
            {
                var options = new BlobRequestOptions()
                {
                    UseFlatBlobListing = true,
                };
                return container.ListBlobs(options).Select(b => new Azure(container, b.Uri.ToString())).Where(c => c.Exists());
            }
            else if (null != client)
            {
                var request = new ListObjectsRequest()
                {
                    BucketName = path,
                };

                using (var response = client.ListObjects(request))
                {
                    return response.S3Objects.Select(s3 => new S3(client, path, s3.Key, s3.ETag));
                }
            }
            else
            {
                return this.GetFiles(path, path, new List<IStorageItem>());
            }
        }

        static void Sync(CloudBlobContainer container, string rootPath)
        {
            // iterate all files from storage
            foreach (CloudBlob item in container.ListBlobs(new BlobRequestOptions() { UseFlatBlobListing = true })) {
                try {
                    var localPath = Path.Combine(rootPath, item.Name);

                    if (File.Exists(localPath) && File.GetLastWriteTimeUtc(localPath).ToFileTime() > item.Properties.LastModifiedUtc.ToFileTime())
                        continue; // local file is more recent

                    if (!Directory.Exists(Path.GetDirectoryName(localPath)))
                        Directory.CreateDirectory(Path.GetDirectoryName(localPath));

                    for (var i = 0; i < RETRY_COUNT; i++) {
                        try {
                            using (var fs = File.Open(localPath, FileMode.Create)) {
                                item.DownloadToStream(fs);
                                break; // all OK
                            }
                        } catch (IOException) {
                            // retry again later
                            System.Threading.Thread.Sleep(SLEEPMS_ONFAIL);
                        }
                        //catch (UnauthorizedAccessException) {
                        //    // ??? just catch this silently otherwise IIS will crash
                        //}
                    }
                } catch (Exception ex) {
                    NLog.LogManager.GetLogger("optQuick").Error(string.Format("Unable to process path {0} => {1}", rootPath, item.Name));
                    NLog.LogManager.GetLogger("optQuick").Error(ex);
                    throw;
                }
            }
        }

        /// <summary>
        ///   Iterates through each blob in the specified container and adds the
        ///   Cache-Control and ContentType headers
        /// </summary>
        public static void EnsureStaticFileHeaders(
            CloudBlobContainer container,
            int cacheControlMaxAgeSeconds)
        {
            string cacheControlHeader = "public, max-age=" + cacheControlMaxAgeSeconds.ToString();

            var blobInfos = container.ListBlobs(
                new BlobRequestOptions() { UseFlatBlobListing = true });
            Parallel.ForEach(blobInfos, (blobInfo) =>
            {
                // get the blob properties and set headers if necessary
                CloudBlob blob = container.GetBlobReference(blobInfo.Uri.ToString());
                blob.FetchAttributes();
                var properties = blob.Properties;

                bool wasModified = false;

                // see if a content type is defined for the extension
                string extension = Path.GetExtension(blobInfo.Uri.LocalPath);
                string contentType = GetContentType(extension);
                if (String.IsNullOrEmpty(contentType))
                {
                    Trace.TraceWarning("Content type not found for extension:" + extension);
                }
                else
                {
                    if (properties.ContentType != contentType)
                    {
                        properties.ContentType = contentType;
                        wasModified = true;
                    }
                }

                if (properties.CacheControl != cacheControlHeader)
                {
                    properties.CacheControl = cacheControlHeader;
                    wasModified = true;
                }

                if (wasModified)
                {
                    blob.SetProperties();
                }
            });
        }

 void ClearContainer(CloudBlobContainer c)
 {
     BlobRequestOptions opt = new BlobRequestOptions();
     opt.UseFlatBlobListing = true;
     foreach (CloudBlob blob in c.ListBlobs(opt))
         blob.Delete();
 }

        ///<summary>Updates the blobs in a storage container.</summary>
        ///<param name="container">The container to update.</param>
        ///<param name="newVersion">The new version being uploaded.</param>
        ///<param name="sourcePath">The directory on the local disk containing the new files.</param>
        public static void UpdateStorage(CloudBlobContainer container, Version newVersion, string sourcePath)
        {
            container.FetchAttributes();

            var remoteFiles = container.ListBlobs(Options).Cast<CloudBlob>().ToArray();
            var oldBlobs = remoteFiles.ToDictionary(
                blob => Path.Combine(sourcePath,
                    container.Uri.MakeRelativeUri(blob.Uri).ToString().Replace('/', '\\')
                )
            );

            var baseUri = new Uri(sourcePath, UriKind.Absolute);
            foreach (var file in new DirectoryInfo(sourcePath).EnumerateFiles("*", SearchOption.AllDirectories)) {
                CloudBlob blob;
                byte[] hash = file.SHA512Hash();

                //If there already is a blob for this file, use it.
                if (!oldBlobs.TryGetValue(file.FullName, out blob)) {
                    blob = container.GetBlobReference(baseUri.MakeRelativeUri(new Uri(file.FullName, UriKind.Absolute)).ToString());
                } else {
                    oldBlobs.Remove(file.FullName);	//Remove the blob from the dictionary; all blobs left in the dictionary will be deleted.

                    if (file.Length == blob.Properties.Length
                     && Convert.FromBase64String(blob.Metadata["SHA512"]).SequenceEqual(hash))
                        continue;	//If the blob is identical, don't re-upload it.
                }
                blob.Metadata["SHA512"] = Convert.ToBase64String(hash);
                blob.UploadFile(file.FullName);
            }

            foreach (var blob in oldBlobs.Values)
                blob.Delete();

            container.Metadata["Version"] = newVersion.ToString();
            container.SetMetadata();
        }

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

        /// <summary>
        /// Copy configuration files from Azure Storage to the config VHD
        /// </summary>
        /// <param name="dbConfigPath"></param>
        /// <param name="container"></param>
        /// <param name="account"></param>
        /// <returns></returns>
        public static bool CopyConfigFromAzureStorage(string dbConfigPath, CloudBlobContainer container, CloudStorageAccount account)
        {
            try
            {
                _account = account;
                _container = container;
                _dbConfigPath = dbConfigPath;

                // We delete the older files
                Trace.TraceInformation("Deleting the older config files");
                try
                {
                    DeleteFilesAndDirectories(dbConfigPath);
                }
                catch (Exception ex)
                {
                    Trace.TraceError(string.Format("MongoHelper.CopyConfigFromAzureStorage Exception : {0}", ex.Message));
                }

                BlobRequestOptions options = new BlobRequestOptions();
                options.UseFlatBlobListing = true;

                GetBlobs(container.ListBlobs(options));

                return true;
            }
            catch (Exception ex)
            {
                Trace.TraceError(string.Format("CopyConfigFromAzureStorage : Exception while Gettings blobs : {0} ({1}) ", ex.Message, ex.InnerException == null ? "" : ex.InnerException.Message));
                return false;
            }
        }