C# CloudStorageAccount.ToString方法代码示例

        public void CloudStorageAccountAnonymousRoundtrip()
        {
            string accountString = "BlobEndpoint=http://blobs/";

            Assert.AreEqual(accountString, CloudStorageAccount.Parse(accountString).ToString(true));

            CloudStorageAccount account = new CloudStorageAccount(null, new Uri("http://blobs/"), null, null);

            AccountsAreEqual(account, CloudStorageAccount.Parse(account.ToString(true)));
        }

 public void CloudStorageAccountDefaultStorageAccountWithHttps()
 {
     StorageCredentials cred = new StorageCredentials(TestBase.TargetTenantConfig.AccountName, TestBase.TargetTenantConfig.AccountKey);
     CloudStorageAccount cloudStorageAccount = new CloudStorageAccount(cred, true);
     Assert.AreEqual(cloudStorageAccount.BlobEndpoint,
         new Uri(String.Format("https://{0}.blob.core.windows.net", TestBase.TargetTenantConfig.AccountName)));
     Assert.AreEqual(cloudStorageAccount.QueueEndpoint,
         new Uri(String.Format("https://{0}.queue.core.windows.net", TestBase.TargetTenantConfig.AccountName)));
     Assert.AreEqual(cloudStorageAccount.TableEndpoint,
         new Uri(String.Format("https://{0}.table.core.windows.net", TestBase.TargetTenantConfig.AccountName)));
     string cloudStorageAccountToStringNoSecrets = cloudStorageAccount.ToString();
     string cloudStorageAccountToStringWithSecrets = cloudStorageAccount.ToString(true);
     CloudStorageAccount testAccount = CloudStorageAccount.Parse(cloudStorageAccountToStringWithSecrets);
     // make sure it round trips
     AccountsAreEqual(testAccount, cloudStorageAccount);
 }

        private void AccountsAreEqual(CloudStorageAccount a, CloudStorageAccount b)
        {
            // endpoints are the same
            Assert.AreEqual(a.BlobEndpoint, b.BlobEndpoint);
            Assert.AreEqual(a.QueueEndpoint, b.QueueEndpoint);
            Assert.AreEqual(a.TableEndpoint, b.TableEndpoint);
            
            // seralized representatons are the same.
            string aToStringNoSecrets = a.ToString();
            string aToStringWithSecrets = a.ToString(true);
            string bToStringNoSecrets = b.ToString(false);
            string bToStringWithSecrets = b.ToString(true);
            Assert.AreEqual(aToStringNoSecrets, bToStringNoSecrets, false);
            Assert.AreEqual(aToStringWithSecrets, bToStringWithSecrets, false);
            
            // credentials are the same
            if (a.Credentials != null && b.Credentials != null)
            {
                Assert.AreEqual(a.Credentials.IsAnonymous, b.Credentials.IsAnonymous);
                Assert.AreEqual(a.Credentials.IsSAS, b.Credentials.IsSAS);
                Assert.AreEqual(a.Credentials.IsSharedKey, b.Credentials.IsSharedKey);

                // make sure 
                if (!a.Credentials.IsAnonymous &&
                    a.Credentials != CloudStorageAccount.DevelopmentStorageAccount.Credentials &&
                    b.Credentials != CloudStorageAccount.DevelopmentStorageAccount.Credentials)
                {
                    Assert.AreNotEqual(aToStringWithSecrets, bToStringNoSecrets, true);
                }
            }
            else if (a.Credentials == null && b.Credentials == null)
            {
                return;
            }
            else
            {
                Assert.Fail("credentials mismatch");
            }
        }

        public void StorageCredentialsEmptyKeyValue()
        {
            string accountName = TestBase.TargetTenantConfig.AccountName;
            string keyValue = TestBase.TargetTenantConfig.AccountKey;
            string emptyKeyValueAsString = string.Empty;
            string emptyKeyConnectionString = string.Format(CultureInfo.InvariantCulture, "DefaultEndpointsProtocol=https;AccountName={0};AccountKey=", accountName);

            StorageCredentials credentials1 = new StorageCredentials(accountName, emptyKeyValueAsString);
            Assert.AreEqual(accountName, credentials1.AccountName);
            Assert.IsFalse(credentials1.IsAnonymous);
            Assert.IsFalse(credentials1.IsSAS);
            Assert.IsTrue(credentials1.IsSharedKey);
            Assert.AreEqual(emptyKeyValueAsString, Convert.ToBase64String(credentials1.ExportKey()));

            CloudStorageAccount account1 = new CloudStorageAccount(credentials1, true);
            Assert.AreEqual(emptyKeyConnectionString, account1.ToString(true));
            Assert.IsNotNull(account1.Credentials);
            Assert.AreEqual(accountName, account1.Credentials.AccountName);
            Assert.IsFalse(account1.Credentials.IsAnonymous);
            Assert.IsFalse(account1.Credentials.IsSAS);
            Assert.IsTrue(account1.Credentials.IsSharedKey);
            Assert.AreEqual(emptyKeyValueAsString, Convert.ToBase64String(account1.Credentials.ExportKey()));

            CloudStorageAccount account2 = CloudStorageAccount.Parse(emptyKeyConnectionString);
            Assert.AreEqual(emptyKeyConnectionString, account2.ToString(true));
            Assert.IsNotNull(account2.Credentials);
            Assert.AreEqual(accountName, account2.Credentials.AccountName);
            Assert.IsFalse(account2.Credentials.IsAnonymous);
            Assert.IsFalse(account2.Credentials.IsSAS);
            Assert.IsTrue(account2.Credentials.IsSharedKey);
            Assert.AreEqual(emptyKeyValueAsString, Convert.ToBase64String(account2.Credentials.ExportKey()));

            CloudStorageAccount account3;
            bool isValidAccount3 = CloudStorageAccount.TryParse(emptyKeyConnectionString, out account3);
            Assert.IsTrue(isValidAccount3);
            Assert.IsNotNull(account3);
            Assert.AreEqual(emptyKeyConnectionString, account3.ToString(true));
            Assert.IsNotNull(account3.Credentials);
            Assert.AreEqual(accountName, account3.Credentials.AccountName);
            Assert.IsFalse(account3.Credentials.IsAnonymous);
            Assert.IsFalse(account3.Credentials.IsSAS);
            Assert.IsTrue(account3.Credentials.IsSharedKey);
            Assert.AreEqual(emptyKeyValueAsString, Convert.ToBase64String(account3.Credentials.ExportKey()));

            StorageCredentials credentials2 = new StorageCredentials(accountName, keyValue);
            Assert.AreEqual(accountName, credentials2.AccountName);
            Assert.IsFalse(credentials2.IsAnonymous);
            Assert.IsFalse(credentials2.IsSAS);
            Assert.IsTrue(credentials2.IsSharedKey);
            Assert.AreEqual(keyValue, Convert.ToBase64String(credentials2.ExportKey()));

            credentials2.UpdateKey(emptyKeyValueAsString, null);
            Assert.AreEqual(emptyKeyValueAsString, Convert.ToBase64String(credentials2.ExportKey()));

#if !WINDOWS_RT
            byte[] emptyKeyValueAsByteArray = new byte[0];

            StorageCredentials credentials3 = new StorageCredentials(accountName, keyValue);
            Assert.AreEqual(accountName, credentials3.AccountName);
            Assert.IsFalse(credentials3.IsAnonymous);
            Assert.IsFalse(credentials3.IsSAS);
            Assert.IsTrue(credentials3.IsSharedKey);
            Assert.AreEqual(keyValue, Convert.ToBase64String(credentials3.ExportKey()));

            credentials3.UpdateKey(emptyKeyValueAsByteArray, null);
            Assert.AreEqual(Convert.ToBase64String(emptyKeyValueAsByteArray), Convert.ToBase64String(credentials3.ExportKey()));
#endif
        }

        /// <summary>
        /// Gets connection string of the given storage service name.
        /// </summary>
        /// <param name="name">The storage service name</param>
        /// <returns>The connection string</returns>
        public string GetStorageServiceConnectionString(string name)
        {
            StorageServiceGetResponse storageService;
            StorageAccountGetKeysResponse storageKeys;

            try
            {
                storageService = StorageClient.StorageAccounts.Get(name);
                storageKeys = StorageClient.StorageAccounts.GetKeys(name);
            }
            catch
            {
                throw new Exception(string.Format(Resources.StorageAccountNotFound, name));
            }

            Debug.Assert(storageService.ServiceName != null);
            Debug.Assert(storageKeys != null);

            StorageCredentials credentials = new StorageCredentials(
                storageService.ServiceName,
                storageKeys.PrimaryKey);

            CloudStorageAccount cloudStorageAccount = new CloudStorageAccount(
                credentials,
                General.CreateHttpsEndpoint(storageService.Properties.Endpoints[0].ToString()),
                General.CreateHttpsEndpoint(storageService.Properties.Endpoints[1].ToString()),
                General.CreateHttpsEndpoint(storageService.Properties.Endpoints[2].ToString())
                );

            return cloudStorageAccount.ToString(true);
        }

 public void CloudStorageAccountDefaultStorageAccountWithHttp()
 {
     StorageCredentials cred = new StorageCredentials(TestBase.TargetTenantConfig.AccountName, TestBase.TargetTenantConfig.AccountKey);
     CloudStorageAccount cloudStorageAccount = new CloudStorageAccount(cred, false);
     Assert.AreEqual(cloudStorageAccount.BlobEndpoint,
         new Uri(String.Format("http://{0}.blob.core.windows.net", TestBase.TargetTenantConfig.AccountName)));
     Assert.AreEqual(cloudStorageAccount.QueueEndpoint,
         new Uri(String.Format("http://{0}.queue.core.windows.net", TestBase.TargetTenantConfig.AccountName)));
     Assert.AreEqual(cloudStorageAccount.TableEndpoint,
         new Uri(String.Format("http://{0}.table.core.windows.net", TestBase.TargetTenantConfig.AccountName)));
     Assert.AreEqual(cloudStorageAccount.FileEndpoint,
         new Uri(String.Format("http://{0}.file.core.windows.net", TestBase.TargetTenantConfig.AccountName)));
     Assert.AreEqual(cloudStorageAccount.BlobStorageUri.SecondaryUri,
         new Uri(String.Format("http://{0}-secondary.blob.core.windows.net", TestBase.TargetTenantConfig.AccountName)));
     Assert.AreEqual(cloudStorageAccount.QueueStorageUri.SecondaryUri,
         new Uri(String.Format("http://{0}-secondary.queue.core.windows.net", TestBase.TargetTenantConfig.AccountName)));
     Assert.AreEqual(cloudStorageAccount.TableStorageUri.SecondaryUri,
         new Uri(String.Format("http://{0}-secondary.table.core.windows.net", TestBase.TargetTenantConfig.AccountName)));
     Assert.AreEqual(cloudStorageAccount.FileStorageUri.SecondaryUri,
         new Uri(String.Format("http://{0}-secondary.file.core.windows.net", TestBase.TargetTenantConfig.AccountName)));
     
     string cloudStorageAccountToStringNoSecrets = cloudStorageAccount.ToString();
     string cloudStorageAccountToStringWithSecrets = cloudStorageAccount.ToString(true);
     CloudStorageAccount testAccount = CloudStorageAccount.Parse(cloudStorageAccountToStringWithSecrets);
     
     AccountsAreEqual(testAccount, cloudStorageAccount);
 }