Azure Tables é o recurso do Windows Azure storage mais próximo dos bancos de dados NoSql.

O Windows Azure Tables fornece recursos para o armazenamento e manipulação de dados estruturados.

Uma Azure Table pode ser vista como um container que provê recursos para o armazenamento de dados. Uma grande diferença entre as Azure Tables e as tabelas de bancos de dados relacionais é que, podemos armazenar diferentes estruturas dentro de uma mesma Azure Table, algo impossível de ser feito com tabelas de bancos relacionais. Desta maneira, as Tables acabam se tornando um grande conjunto de entidades. Isso torna o Azure Table ideal para o armazenamento de grandes coleções de objetos.

Azure Tables são otimizadas para trabalhar com grandes quantidades de dados. Um detalhe importante é que Tables podem ser automaticamente escaladas para acomodarem até 100 terabytes de dados, a fim de garantir a melhor performance possível.

Indicação de Uso

Azure Tables são indicados em alguns cenários:

     – Quando bancos de dados relacionais deixam de ser escaláveis;

     – Quando bancos de dados não suportam relacionamentos muito complexos;

     – Quando for necessário gerenciar schemas de dados dinâmicos.

Se seu código exige forte semântica relacional, então Azure Tables não são apropriados. Azure Tables não suportam joins entre entidades. Devemos encarar os Azure Tables como coleções de objetos, onde um objeto "maior" contém outros objetos "menores", o mesmo conceito adotados ao trabalhar com bancos de dados NoSql.

Criando um Windows Azure storage account

Para criar um Windows Azure storage account leia a seção de nome "Criando um Windows Azure storage account" deste outro post: https://ferhenriquef.com/2013/06/09/windows-azure-storage-blob/

Antes de começar a programar

Antes de começar a programar leia a seção de nome "Antes de começar a programar" deste outro post: https://ferhenriquef.com/2013/06/09/windows-azure-storage-blob/

Conectando no Windows Azure storage

Para conectar ao Windows Azure storage leia a seção de nome "Conectando no Windows Azure storage", deste link: https://ferhenriquef.com/2013/06/09/windows-azure-storage-blob/

Nomenclatura

Tables: o nome das Azure Tables deve ser único dentro de seu Windows Azure storage account. O nome deve conter de 3 a 63 caracteres, o uso de seu nome é case-insensitive.

Programando

Uma entidade pode conter até 255 propriedades. Com a premissa de que três dessas propriedades são obrigatórias, sendo elas: PartitionKey, RowKey e Timestamp. A propriedade PartitionKey é utilizada para indicar em qual partição as entidades serão armazenadas. Uma partição corresponde a um conjunto consecutivo de entidades identificadas por um valor comum de uma PartitionKey. A propriedade RowKey corresponde a uma string que possibilita que uma entidade possa ser identificada individualmente dentro de uma partição. Quando a propriedade RowKey é combinada com a propriedade PartitionKey, é formada a chave primaria da entidade, que identifica exclusivamente uma entidade dentro de sua tabela. E por último, temo a propriedade Timestamp, que representa a versão de uma entidade e é utilizada para implementar rotinas de concorrências. O valor desta propriedade é gerenciado pelo Windows Azure e não precisa ser definido pelo usuário.

Abaixo segue um repositório com comando de inclusão, atualização, exclusão e consulta de dados. Vale ressaltar que abaixo foi criada uma classe chamada TableCloudEntity, que implementa a interface ITableEntity e já contém as três propriedades obrigatórias para as entidades a serem persistidas no Azure Table.

using Microsoft.WindowsAzure.Storage;
using Microsoft.WindowsAzure.Storage.Auth;
using Microsoft.WindowsAzure.Storage.Table;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ConsoleAzureTableTheMission {
    class Program {
        static void Main(string[] args) {
            string accountName = "your account name";
            string primaryKey = "your azure container key";
            string tableName = "Posts";
            Post newPostBlog = new Post();
            newPostBlog.Title = "Windows Azure - Table";
            newPostBlog.Content = "Hey Devs! Today we´ll talk about WZ Tables! \\o/";
            PostCloudRepository repository = new PostCloudRepository(accountName,
                                                                     primaryKey,
                                                                     tableName);
            // Inclusão
            repository.Insert(newPostBlog);
            // Atualização
            repository.Update(newPostBlog);
            // Consulta
            var posts = repository.GetAll();
            // Exclusão
            repository.Delete(newPostBlog);
        }
    }
    public abstract class TableCloudEntity : ITableEntity {
        public TableCloudEntity() {
            this.Properties = new Dictionary<string, EntityProperty>();
        }
        public IDictionary<string, EntityProperty> Properties { get; private set; }
        public string ETag {
            get;
            set;
        }
        public string PartitionKey {
            get;
            set;
        }
        public string RowKey {
            get;
            set;
        }
        public DateTimeOffset Timestamp {
            get;
            set;
        }
        public void ReadEntity(IDictionary<string, EntityProperty> properties, Microsoft.WindowsAzure.Storage.OperationContext operationContext) {
            this.Properties = properties;
        }
        public IDictionary<string, EntityProperty> WriteEntity(Microsoft.WindowsAzure.Storage.OperationContext operationContext) {
            return this.Properties;
        }   
    }
    public class Post : TableCloudEntity {
        public Guid Id { get; set; }
        public string Title { get; set; }
        public string Content { get; set; }
        public Post()
            : base() {
        }
    }
    public class PostCloudRepository {
        private string _accountName;
        private string _key;
        private string _tableReference;
        public PostCloudRepository(string accountName, string key, string tableReference) {
            this._accountName = accountName;
            this._key = key;
            this._tableReference = tableReference;
        }
        private CloudStorageAccount GetStorageAccount() {
            StorageCredentials credentials = new StorageCredentials(this._accountName, this._key);
            CloudStorageAccount storageAccount = new CloudStorageAccount(credentials, true);
            return storageAccount;
        }
        private CloudTable GetTableReference() {
            var client = GetStorageAccount().CreateCloudTableClient();
            CloudTable table = client.GetTableReference(this._tableReference);
            //var exists = table.CreateIfNotExists(null, null);
            return table;
        }
        public Post Insert(Post entity) {
            Insert(new Post[] { entity });
            return entity;
        }
        public IEnumerable<Post> Insert(IEnumerable<Post> entities) {
            var table = GetTableReference();
            foreach (var entity in entities) {
                TableOperation operation = TableOperation.Insert(entity);
                TableResult result = table.Execute(operation);
            }
            return entities;
        }
        public Post Update(Post entity) {
            Update(new Post[] { entity });
            return entity;
        }
        public IEnumerable<Post> Update(IEnumerable<Post> entities) {
            var table = GetTableReference();
            foreach (var entity in entities) {
                TableOperation operation = TableOperation.Replace(entity);
                TableResult result = table.Execute(operation);
            }
            return entities;
        }
        public void Delete(Post entity) {
            Delete(new Post[] { entity });
        }
        public void Delete(IEnumerable<Post> entities) {
            var table = GetTableReference();
            foreach (var entity in entities) {
                TableOperation operation = TableOperation.Delete(entity);
                TableResult result = table.Execute(operation);
            }
        }
        public IEnumerable<Post> GetAll() {
            TableQuery<Post> query = new TableQuery<Post>();
            var table = GetTableReference();
            var returnValue = table.ExecuteQuery(query);
            return returnValue;
        }
    }
}

Por

MSc. Fernando Henrique Inocêncio Borba Ferreira

Microsoft Most Valuable Professional – Visual C#

 

Referências

Developing Cloud Applications with Windows Azure Storage – Paul Mehner