C# CloudBlobContainer.GetPermissions方法代码示例

        public HomeController()
        {
            storageAccount = CloudStorageAccount.Parse(
            ConfigurationManager.AppSettings["StorageConnectionString"]);

            tableClient = storageAccount.CreateCloudTableClient();

            table = tableClient.GetTableReference("fouramigos");

            table.CreateIfNotExists();

            blobClient = storageAccount.CreateCloudBlobClient();

            container = blobClient.GetContainerReference("fouramigos");

            container.CreateIfNotExists();

            BlobContainerPermissions permissions = container.GetPermissions();
            permissions.PublicAccess = BlobContainerPublicAccessType.Container;
            container.SetPermissions(permissions);


            //lägga till nya
            //var tablemodels = new TableModel("Brutus", "Uggla") { Location = "T4", Description="Uggla i träd", Type="Foto" };
            //var tablemodels1 = new TableModel("brutus", "Örn") { Location = "T4", Description="Örn som flyger", Type = "Foto" };

            //var opreation = TableOperation.Insert(tablemodels);
            //var operation2 = TableOperation.Insert(tablemodels1);

            //table.Execute(opreation);
            //table.Execute(operation2);
        }

		/// <summary>
		/// Creates a new BlobStorage object
		/// </summary>
		/// <param name="blobContainerName">The name of the blob to be managed</param>
		/// <param name="storageConnectionString">The connection string pointing to the storage account (this can be local or hosted in Windows Azure</param>
		public BlobStorageAsync(string blobContainerName, string storageConnectionString)
		{
			Validate.BlobContainerName(blobContainerName, "blobContainerName");
			Validate.String(storageConnectionString, "storageConnectionString");

			var cloudStorageAccount = CloudStorageAccount.Parse(storageConnectionString);
			var cloudBlobClient = cloudStorageAccount.CreateCloudBlobClient();

			cloudBlobContainer = cloudBlobClient.GetContainerReference(blobContainerName);
			cloudBlobContainer.CreateIfNotExists();

			var permissions = cloudBlobContainer.GetPermissions();
			permissions.PublicAccess = BlobContainerPublicAccessType.Container;
			cloudBlobContainer.SetPermissions(permissions);
		}

        /// <summary>
        /// Creates a new Shared Access Policy for the container
        /// </summary>
        /// <param name="blobClient">The blob client to use for this operation</param>
        /// <param name="container">The container to create the policy for</param>
        /// <param name="policyName">The name of the policy</param>
        static void CreateSharedAccessPolicy(CloudBlobClient blobClient, CloudBlobContainer container,
    string policyName)
        {
            //Create a new shared access policy and define its constraints.
            SharedAccessBlobPolicy sharedPolicy = new SharedAccessBlobPolicy()
            {
                // What is the expiration date of this policy?
                SharedAccessExpiryTime = DateTime.UtcNow.AddYears(1),
                // What permissions does this policy grant?
                Permissions = SharedAccessBlobPermissions.Read | SharedAccessBlobPermissions.List
            };

            //Get the container's existing permissions.
            BlobContainerPermissions permissions = container.GetPermissions();

            //Add the new policy to the container's permissions, and set the container's permissions.
            permissions.SharedAccessPolicies.Add(policyName, sharedPolicy);
            container.SetPermissions(permissions);
        }

        //Initializing constructor...
        public AzureContext(string appSettingsKey) 
        {
            if ( null == _cloudStorageAccount ) //ASSUMPTION: This member is ALWAYS allocated first...
            {
                lock (lockObject)
                {
                    if ( null == _cloudStorageAccount )
                    {
                        string connectionString = ConfigurationManager.AppSettings[appSettingsKey];
                        _cloudStorageAccount = CloudStorageAccount.Parse(connectionString);

                        _cloudBlobClient = _cloudStorageAccount.CreateCloudBlobClient();

                        _cloudBlobContainer = _cloudBlobClient.GetContainerReference(ConfigurationManager.AppSettings["blobContainer"]);

                        //ASSUMPTION: container access settings: public read access blobs only...
                        BlobContainerPermissions bcp = _cloudBlobContainer.GetPermissions();

                        Debug.Assert(BlobContainerPublicAccessType.Blob == bcp.PublicAccess);
                    }
                }
            }
        }

 /// <summary>
 /// Get container presssions
 /// </summary>
 /// <param name="container">A cloudblobcontainer object</param>
 /// <param name="accessCondition">Access condition</param>
 /// <param name="options">Blob request option</param>
 /// <param name="operationContext">Operation context</param>
 /// <returns>The container's permission</returns>
 public BlobContainerPermissions GetContainerPermissions(CloudBlobContainer container, AccessCondition accessCondition, BlobRequestOptions options, OperationContext operationContext)
 {
     return container.GetPermissions(accessCondition, options, operationContext);
 }

        private SharedAccessBlobPolicy GetNonExpiredContainerPolicy(CloudBlobContainer container)
        {
            SharedAccessBlobPolicy policy;
            bool policyExpired = false;
            var permissions = container.GetPermissions();
            var policyExists = permissions.SharedAccessPolicies.TryGetValue(PolicyName, out policy);

            if (policyExists)
            {
                policyExpired = policy.SharedAccessExpiryTime < DateTime.UtcNow;
            }

            if (policyExpired || !policyExists)
            {
                policy = CreateSharedAccessPolicy();
                permissions.SharedAccessPolicies.Remove(PolicyName);
                permissions.SharedAccessPolicies.Add(PolicyName, policy);
                container.SetPermissions(permissions);
            }

            return policy;
        }

 public static void PackContainerCompareData(CloudBlobContainer container, Dictionary<string, object> dic)
 {
     BlobContainerPermissions permissions = container.GetPermissions();
     dic["PublicAccess"] = permissions.PublicAccess;
     dic["Permission"] = permissions;
     dic["LastModified"] = container.Properties.LastModified;
 }

 /// <summary>
 /// Test container reads and writes, expecting success.
 /// </summary>
 /// <param name="testContainer">The container.</param>
 /// <param name="testAccessCondition">The access condition to use.</param>
 private void ContainerReadWriteExpectLeaseSuccess(CloudBlobContainer testContainer, AccessCondition testAccessCondition)
 {
     testContainer.FetchAttributes(testAccessCondition, null /* options */);
     testContainer.GetPermissions(testAccessCondition, null /* options */);
     testContainer.SetMetadata(testAccessCondition, null /* options */);
     testContainer.SetPermissions(new BlobContainerPermissions(), testAccessCondition, null /* options */);
 }

        /// <summary>
        /// Test container reads and writes, expecting lease failure.
        /// </summary>
        /// <param name="testContainer">The container.</param>
        /// <param name="testAccessCondition">The failing access condition to use.</param>
        /// <param name="expectedErrorCode">The expected error code.</param>
        /// <param name="description">The reason why these calls should fail.</param>
        private void ContainerReadWriteExpectLeaseFailure(CloudBlobContainer testContainer, AccessCondition testAccessCondition, HttpStatusCode expectedStatusCode, string expectedErrorCode, string description)
        {
            // FetchAttributes is a HEAD request with no extended error info, so it returns with the generic ConditionFailed error code.
            TestHelper.ExpectedException(
                () => testContainer.FetchAttributes(testAccessCondition, null /* options */),
                description + "(Fetch Attributes)",
                HttpStatusCode.PreconditionFailed);

            TestHelper.ExpectedException(
                () => testContainer.GetPermissions(testAccessCondition, null /* options */),
                description + " (Get Permissions)",
                expectedStatusCode,
                expectedErrorCode);
            TestHelper.ExpectedException(
                () => testContainer.SetMetadata(testAccessCondition, null /* options */),
                description + " (Set Metadata)",
                expectedStatusCode,
                expectedErrorCode);
            TestHelper.ExpectedException(
                () => testContainer.SetPermissions(new BlobContainerPermissions(), testAccessCondition, null /* options */),
                description + " (Set Permissions)",
                expectedStatusCode,
                expectedErrorCode);
        }

        static void CreateSharedAccessPolicy(CloudBlobClient blobClient, CloudBlobContainer container, string policyName)
        {
            SharedAccessBlobPolicy sharedPolicy = new SharedAccessBlobPolicy()
            {
                SharedAccessExpiryTime = DateTime.UtcNow.AddHours(24),
                                            Permissions = SharedAccessBlobPermissions.Write | SharedAccessBlobPermissions.List | SharedAccessBlobPermissions.Read
            };

            BlobContainerPermissions permissions = container.GetPermissions();

            permissions.SharedAccessPolicies.Add(policyName, sharedPolicy);
            container.SetPermissions(permissions);


        }

        public CloudBlobContainer GetContainer(string containerName)
        {
            container = blobClient.GetContainerReference(containerName);

            if (container.CreateIfNotExists())
            {
                // configure container for public access
                var permissions = container.GetPermissions();
                permissions.PublicAccess = BlobContainerPublicAccessType.Container;
                container.SetPermissions(permissions);
            }

            return container;
        }