Windows Azure Storage

之前都是在博客园看别人的文章，今天开始就开启自己的博客咯，欢迎阅读，共同探讨！

简单点说Widows Azure Storage就是一个大的网盘，可以让用户存储任何想存储的数据，数据一旦存储到“云”中就永远不会丢失，程序员可以在任何时候，任何终端，任何地点获取任意大小的数据。

目前来说，Windoows Azure Storage 是由4部分组成，如下：

1.Windows Azure Blob Service:主要存储一些大型的Unstructure的数据，Text or Binary,像Media, Document等等。

2.Windows Azure Table Service:以前在开发一些Asp.net程序的时候，大多数会使用关系型数据库(SQL Server)，往往一个应用程序中的类对应数据库中的某些表，然后你需要大量的代码或者工具来完成关系数据库到对象之间的映射，这个时候你是多么想直接将实体类存储到数据库当中呀！Windows Azure Table服务就是来解决这个问题的。它可以直接将实体类、实体对象存入到表结构当中,它和一般的关系型数据库中的Table很像，当时也有很大的不同，比如它不能提供像SQL中的Join方法，也不能管理Foreign Key.

3.Windows Azure Queue Service:不同于前两种都是在存储或者读取数据，Queue Service主要是用来存储消息队列，应用得最多的就是为Work Role和Web Role来传递消息。

4.Windows Azure File Storage:提供在云上的文件共享服务,你可以存储任何你需要共享的文件，比如用得比较多的就是共享应用程序的配置文件,日志文件,Crash Dumps等等。同样也可以实现在多台虚拟机上挂载共享存储。

下面分别介绍下这4种存储的结构，如下：

1.Blob Storage Concepts:

Storage Account:所有对Storage的操作都是通过Storage Account来完成的,可以说是Azure  Storage的入口.

Container:Container提供了一组Blob的分组,一个Accout能包含无个数限制的Container,一个Container能包含无个数限制的Blo.

Blob:任何类型或者大小的文件。在这里用得比较多的是Block Blob.它是存储text或者Binary的理想选择。Page Blob其实和Black Blob很像,因为它就是Black Blob组成的。比较适用于存储逐渐增长的这种数据，Like Logging.还有一种就是Page Block,对于那种需要频繁的读写操作的存储更加高效,一般作为虚拟机的Data Disk比较多。

2.Table Storage Concepts:

Storage Account:所有对Storage的操作都是通过Storage Account来完成的,可以说是Azure  Storage的入口.

Table:存储实体类或者实体对象(Entity)的集合.

Entity:一组属性的实体,类似于数据库的行.

Properties:一个属性就是一个Name-Value的键值对,每个实体（Entity）有3个系统的属性, partition key, a row key, and a timestamp.

3.Queue Storage Concepts

Storage Account:所有对Storage的操作都是通过Storage Account来完成的,可以说是Azure  Storage的入口.

Queue:存储message.

4.File Storage Concepts

Storage Account:所有对Storage的操作都是通过Storage Account来完成的,可以说是Azure  Storage的入口.

Share:是Azure上的一个File Share的地方,所有的Directory或者File都必须在share里面创建.

Directory:可选的在这种层级里面.

File:需要共享的文件.

最后介绍下这4种结构的创建和一些常见的用法,如下：

这4种存储都可以通过Azure Portal或者Power Shell来创建和操作,具体可以参考:https://azure.microsoft.com/en-us/documentation/articles/storage-introduction/

下面我们介绍以编程的方式分别访问这几种Storage:

1.Blob:

 public  class BlobStorage
    {
        public  CloudStorageAccount storageAccount;
        public  CloudBlobClient blobClient;
        public  CloudBlobContainer container;

        public void initial()
        {
            //CloudStorageAccount storageAccount = CloudStorageAccount.Parse(ConfigurationManager.ConnectionStrings["StorageConnectionString"].ConnectionString);
            storageAccount = CloudStorageAccount.Parse("DefaultEndpointsProtocol=https;AccountName=mystoraget;AccountKey=mykey");

            blobClient = storageAccount.CreateCloudBlobClient();
            container = blobClient.GetContainerReference("mycontainer");
            container.CreateIfNotExists();
        }

        //Upload a file into a container
        public  void UploadBlodToContainer()
        {
            container.SetPermissions(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob });

            CloudBlockBlob blockBlob = container.GetBlockBlobReference("myblob");
            using (var filestream = System.IO.File.OpenRead(@"C:data.txt"))
            {
                blockBlob.UploadFromStream(filestream);
            }
            CloudBlockBlob blockBlob2 = container.GetBlockBlobReference("myblob2");
            using (var filestream = System.IO.File.OpenRead(@"C:MyFoldermytext.txt"))
            {
                blockBlob2.UploadFromStream(filestream);
            }

            Console.WriteLine("Upload blob to container succeed!");
        }

        //List the blobs in a container
        public  void ListBlodFromContainer()
        {
            foreach (IListBlobItem item in container.ListBlobs(null, false))
            {
                if (item.GetType() == typeof(CloudBlockBlob))
                {
                    CloudBlockBlob blob = (CloudBlockBlob)item;
                    Console.WriteLine("Block blob of length {0}: {1}", blob.Properties.Length, blob.Uri);
                }
                else if (item.GetType() == typeof(CloudPageBlob))
                {
                    CloudPageBlob pageBlob = (CloudPageBlob)item;

                    Console.WriteLine("Page blob of length {0}: {1}", pageBlob.Properties.Length, pageBlob.Uri);
                }

            }
            Console.WriteLine("List Blod succeed!");
        }

        //Download file from blobs
        public void DownloadToStream()
        {
            CloudBlockBlob blockBlob = container.GetBlockBlobReference("myblob");

            using (var fileStream = System.IO.File.OpenWrite(@"C:MyFolderInputext.txt"))
            {
                blockBlob.DownloadToStream(fileStream);
            }

            Console.WriteLine("Download blob to stream succeed!");
        }

        //Delete blob
        public  void DeleteBlob()
        {
            CloudBlockBlob blockBlob = container.GetBlockBlobReference("myblob");

            blockBlob.Delete();
            Console.WriteLine("Delete blob succeed!");
        }
    }

2.Table

public  class TableStorage
    {
        public  CloudStorageAccount storageAccount;
        public  CloudTableClient tableClient;
        public  CloudTable table;

        //Create a table
        public void initial()
        {
            storageAccount = CloudStorageAccount.Parse("DefaultEndpointsProtocol=https;AccountName=mystoraget;AccountKey=mykey");

            tableClient = storageAccount.CreateCloudTableClient();
            table = tableClient.GetTableReference("people");
            table.CreateIfNotExists();
        }

        //Add an entity to a table
        public void AddEntityToTable()
        {
            CustomerEntity customer1 = new CustomerEntity("Harp", "Walter");
            customer1.Email = "Walter@contoso.com";
            customer1.PhoneNumber = "425-555-0101";
            TableOperation inserOperation = TableOperation.Insert(customer1);

            table.Execute(inserOperation);
            Console.WriteLine("Insert entity to a table succeed");
        }

        //Insert a batch of entities
        public void AddbatchEntityToTable()
        {
            TableBatchOperation batchOperation = new TableBatchOperation();

            CustomerEntity customer1 = new CustomerEntity("Smith", "Jeff");
            customer1.Email = "Jeff@contoso.com";
            customer1.PhoneNumber = "425-555-0104";

            CustomerEntity customer2 = new CustomerEntity("Smith", "Ben");
            customer2.Email = "Ben@contoso.com";
            customer1.PhoneNumber = "425-555-0102";

            batchOperation.Insert(customer1);
            batchOperation.Insert(customer2);

            table.ExecuteBatch(batchOperation);
            Console.WriteLine("Insert a batch of entities to a table succeed");
        }

        //Query a table for all Entity
        public void QueryEntityFromTable()
        {
            TableQuery<CustomerEntity> query = new TableQuery<CustomerEntity>().Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, "Smith"));
            foreach (CustomerEntity entity in table.ExecuteQuery(query))
            {
                Console.WriteLine("{0}, {1}	{2}	{3}", entity.PartitionKey, entity.RowKey,
                    entity.Email, entity.PhoneNumber);
            }
        }

        //Delete Entity from table
        public void DeleteEntityFromTable()
        {
            TableOperation retrieveOperation = TableOperation.Retrieve<CustomerEntity>("Smith", "Ben");
            TableResult retrievedResult = table.Execute(retrieveOperation);

            CustomerEntity deleteEntity = (CustomerEntity)retrievedResult.Result;
            if (deleteEntity != null)
            {
                TableOperation deleteOperation = TableOperation.Delete(deleteEntity);

                // Execute the operation.
                table.Execute(deleteOperation);

                Console.WriteLine("Entity deleted.");
            }

            else
                Console.WriteLine("Could not retrieve the entity.");
        }

        //delete a table
        public void deletetable()
        {
            table.DeleteIfExists();
            Console.WriteLine("Delete table successful!");
        }
    }

3.Queue

 public class QueueStorage
    {
        public CloudStorageAccount storageAccount;
        public CloudQueueClient queueClient;
        public CloudQueue queue;

        public void initial()
        {
            storageAccount = CloudStorageAccount.Parse("DefaultEndpointsProtocol=https;AccountName=mystoraget;AccountKey=mykey");

            queueClient = storageAccount.CreateCloudQueueClient();
            queue = queueClient.GetQueueReference("myqueue");
            queue.CreateIfNotExists();
        }

        //Inser a message into a queue
        public void InsertMessageToQueue()
        {
            CloudQueueMessage message = new CloudQueueMessage("Hello,World");
            CloudQueueMessage message2 = new CloudQueueMessage("Hello2,World2");
            queue.AddMessage(message2);
            queue.AddMessage(message);
            Console.WriteLine("Insert Message to queue succeed!");
        }

 
        //get message
        public void GetMessage()
        {
            CloudQueueMessage retrieveMessage = queue.GetMessage();
            Console.WriteLine("Retrieved message with content'{0}'", retrieveMessage.AsString); 
        }


        //update the content of a queued message
        public void UpdateMessage()
        {
            CloudQueueMessage message = queue.GetMessage();
            Console.WriteLine("Retrieved message with content'{0}'", message.AsString);
            message.SetMessageContent("Updated.");
            queue.UpdateMessage(message, TimeSpan.FromSeconds(10.0), MessageUpdateFields.Content | MessageUpdateFields.Visibility);
            Console.WriteLine("Update Message complete, I will appear after 10s");
        }

        //test async
        public async Task AsyncPattern()
        {
            if (await queue.CreateIfNotExistsAsync())
            {
                Console.WriteLine("Queue '{0}' Created", queue.Name);
            }
            else
            {
                Console.WriteLine("Queue '{0}' Exists", queue.Name);
            }

            CloudQueueMessage cloudQueueMessage = new CloudQueueMessage("My message");

            await queue.AddMessageAsync(cloudQueueMessage);
            Console.WriteLine("Message added");

            CloudQueueMessage retrievedMessage = await queue.GetMessageAsync();
            Console.WriteLine("Retrieved message with content'{0}'", retrievedMessage.AsString);

            await queue.DeleteMessageAsync(retrievedMessage);
            Console.WriteLine("Deleted message");


        }
    }

4.File

public class FileStorage
    {
        public CloudStorageAccount storageAccount;
        public CloudFileClient fileClient;
        public CloudFileShare share;
        public CloudFileDirectory rootDir;
        public CloudFileDirectory sampleDir;

        //Create a table
        public void initial()
        {
            storageAccount = CloudStorageAccount.Parse("DefaultEndpointsProtocol=https;AccountName=mystoraget;AccountKey=mykey");

            fileClient = storageAccount.CreateCloudFileClient();
            share = fileClient.GetShareReference("testfiledemo");
            share.CreateIfNotExists();

            rootDir = share.GetRootDirectoryReference();
            sampleDir = rootDir.GetDirectoryReference("Images");
            sampleDir.CreateIfNotExists();
        }

        //upload file to directory in file share
        public void UploadFile()
        {
            CloudFile sourceFile = sampleDir.GetFileReference("sample-file.txt");
            sourceFile.Create(2);
            using (var filestream = System.IO.File.OpenRead(@"C:aa.txt"))
            {
                sourceFile.UploadFromStream(filestream);
            }
            Console.WriteLine("Upload file to directory succeed!");
        }
        //Download the file
        public void DownloadFile()
        {
            CloudFile file = sampleDir.GetFileReference("sample-file.txt");
            Console.WriteLine(file.DownloadTextAsync().Result);
        }


        //Copy file to a blob
        public void CopyFileToBlob()
        {
            CloudFileShare share = fileClient.GetShareReference("sample-share");
            share.CreateIfNotExists();
            

            CloudFile sourceFile = share.GetRootDirectoryReference().GetFileReference("sample-file.txt");

            sourceFile.UploadText("A sample file in the root directory.");

            CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
            CloudBlobContainer container = blobClient.GetContainerReference("sample-container");
            container.CreateIfNotExists();
            CloudBlockBlob desBlob = container.GetBlockBlobReference("sample-container");

            string fileSas = sourceFile.GetSharedAccessSignature(new SharedAccessFilePolicy()
            {
                Permissions =SharedAccessFilePermissions.Read,
                SharedAccessExpiryTime=DateTime.UtcNow.AddHours(24)
            });

            Uri fileSasUri = new Uri(sourceFile.StorageUri.PrimaryUri.ToString()+fileSas);

            desBlob.StartCopy(fileSasUri);

            Console.WriteLine("source file contents:{0}", sourceFile.DownloadText());
            Console.WriteLine("destination blob contents:{0}",desBlob.DownloadText());
        }

        //delete file share
        public void DeleteFileShare()
        {
            share.Delete();

            Console.WriteLine("Delete file share success!");
        }
    }
}