Um cache não tem utilidade sem operações básicas de CRUD. Como o cache é um armazenamento de valor-chave, você precisa adicionar, recuperar e remover dados em cache o tempo todo. Portanto, esses CRUD (Criar, Remover, Atualizar, Excluir) baseados em chave ou operações básicas facilitam o acesso e o uso do cache.
NCache tem sido amplamente adotado para cache de dados distribuído em aplicações devido à sua escalabilidade linear e alta disponibilidade. NCache fornece várias APIs CRUD para realizar operações básicas no armazenamento de dados em cache. Veremos com que facilidade você pode usar essas operações em seu aplicativo de e-commerce usando NCache para armazenar dados usados com frequência.
NCache Adicionar ao carrinho Operações básicas de cache Chaves e dados de cache
Operações básicas de CRUD
O objetivo básico de um cache é agir como um armazenamento de dados temporário para seu aplicativo, portanto, quaisquer dados necessários, você pinga o cache em vez de fazer uma viagem completa ao banco de dados. Vamos fazer um tour pelas operações básicas de CRUD que NCache apoia. Aqui está uma breve lista do que NCache oferece:
API | Descrição | Sintaxe |
Adicionar | Adiciona novos dados ao cache | Adicionar(chave, valor) |
inserção | Atualiza o valor se a chave já existir no cache ou adiciona o item como novo caso contrário | Inserir(chave, valor) |
Eliminar | Remove a chave especificada do cache e retorna o valor | Remover(chave) |
Get | Recupera o valor da chave fornecida | Obter(chave) |
Mas espere, não é apenas um simples armazenamento de valor-chave. Além do mais, NCache também permite armazenar em cache objetos personalizados, Objetos JSON, estruturas de dados e realizar operações neles. Assim, você tem armazenamento completo e uma plataforma de replicação para realizar operações básicas de CRUD em todos os tipos de dados com a máxima flexibilidade usando NCache.
NCache suporta operações síncronas e assíncronas. Operações síncronas são cruciais para atualizações confidenciais em que você precisa garantir que a operação executada ocorreu antes de prosseguir. Em outras palavras, tais operações são sequenciais. Por outro lado, Operações assíncronas são mais flexíveis e executados em segundo plano enquanto o controle é enviado de volta ao cliente imediatamente.
É importante notar que, todos NCache Objetos de cliente SDK e APIs são thread-safe e independentes uns dos outros. Isso garante que a reutilização de instâncias de cliente seja sempre segura, mesmo entre threads.
Vamos nos aprofundar um pouco nos diferentes tipos de operações NCache suporta para você executar em seus dados sem problemas. Aqui, mostrarei como brincar com operações básicas em objetos personalizados.
NCache Adicionar ao carrinho Operações básicas de cache Chaves e dados de cache
Tipos de operações em NCache
NCache permite operações CRUD em um único item ou em um lote de itens. Enquanto isso, os modos de operação suportados são síncronos e assíncronos. NCache suporta operações síncronas e assíncronas. Vamos discutir diferentes tipos de operações com pouca profundidade que NCache suporta, para que você possa executar em seus dados sem problemas.
Operações Atômicas
Todas as operações executadas em um único par chave-valor são categorizadas como operações atômicas. Portanto, tais operações requerem uma chamada de cache por item. Supondo que você tenha um aplicativo de comércio eletrônico e queira adicionar um novo produto ao estoque armazenado em cache, busque e atualize seu valor e, em seguida, remova-o do cache com NCache APIs CRUD.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
// Pre-condition: Cache is already connected // Get product from database var product = GetProductFromDB(1001); string key = $"Product:{product.ProductID}"; // Add item in the cache. Add can be replaced with Insert depending on your requirement. CacheItemVersion version = cache.Add(key, product); // Retrieve cached item from the cache var retrievedItem = cache.Get(key); // Update the price of retrieved product retrievedItem.Price = 500; cache.Insert(key, retrievedItem); // Remove item from the cache cache.Remove(key); |
É importante observar que a mesma chave não pode ser adicionada novamente se já existir no cache. Para isso, você pode usar Insert que substitui o valor da chave existente.
NCache Adicionar ao carrinho Operações básicas de cache Chaves e dados de cache
Operações em Massa
Como você pode precisar executar várias operações simultaneamente em seu aplicativo, NCache permite que você execute operações CRUD em um bloco de dados em uma chamada. Essas operações são projetadas para obter melhor desempenho, pois reduzem as chamadas de rede para o servidor remoto, obtendo o máximo em uma única chamada de cache.
Por exemplo, se você deseja adicionar, atualizar ou excluir 100 itens de produto no cache, você pode fazer isso por meio de uma única chamada em massa para adicionar, atualizar or remover esses itens em vez de chamar as APIs relevantes 100 vezes. Vamos ver como você pode usar uma única chamada em massa para conseguir isso.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
// Pre-condition: Cache is already connected // Get products from database Product[] products = FetchProductsFromDB(); IDictionary<string, CacheItem> dictionary = new Dictionary<string, CacheItem>(); foreach (var prod in products) { string key = $"Product:{prod.ProductID}"; var cacheItem = new CacheItem(prod); dictionary.Add(key, cacheItem); } // Inserting items in the cache IDictionary result = cache.InsertBulk(dictionary); // Retrieve items in bulk IDictionary<string, Product> retrievedItems = cache.GetBulk(keys); // Perform business logic here // Remove a chunk of keys from the cache cache.RemoveBulk(keys); |
NCache Adicionar ao carrinho Operações básicas de cache Chaves e dados de cache
Operações síncronas
As operações síncronas são significativas para atualizações confidenciais em que você precisa garantir que a operação executada ocorreu antes de prosseguir. Em outras palavras, tais operações são sequenciais. Por exemplo, você usaria operações síncronas para atualizar os preços de seu estoque antes de uma grande venda para garantir que os preços fossem atualizados com sucesso.
Essas operações funcionam como uma chamada de bloqueio, onde o cliente deve aguardar a resposta do servidor sobre a operação realizada antes de prosseguir com o processamento. O que acontece é que, até o momento em que o item é adicionado (ou uma exceção é lançada), sua aplicação espera que a operação seja executada para que ela recupere o controle. As operações CRUD básicas são síncronas por padrão, se não houver indicação em contrário.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
// Pre-condition: Cache is already connected // Get product from database var product = GetProductFromDB(1001); string key = $"Product:{product.ProductID}"; // Add CacheItem to cache CacheItemVersion version = cache.Add(key, cacheItem); // Retrieve the cached item from the cache CacheItem retrievedItem = cache.GetCacheItem(key); // Update the price of retrieved product product.Price = 500; retrievedItem = new CacheItem(product); cache.Insert(key, retrievedItem); // Remove item from the cache cache.Remove(key); |
Operações assíncronas
As operações assíncronas são mais flexíveis e executadas em segundo plano enquanto o controle é enviado de volta ao cliente imediatamente. Você pode usar essa funcionalidade em seu aplicativo de comércio eletrônico ao máximo, onde operações menos críticas, como atualizar a descrição de um produto, precisam ser executadas. A alteração das informações básicas não precisa necessariamente ser rastreada, pelo menos não em alta prioridade.
NCache oferece suporte a várias sobrecargas assíncronas para executar operações atômicas. Vamos ver como você pode usar AddAsync
, InsertAsync
e RemoveAsync
APIs para adicionar, atualizar e remover os dados do seu aplicativo de forma assíncrona.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
// Pre-condition: Cache is already connected // Get product from database var product = GetProductFromDB(1001); string key = $"Product:{product.ProductID}"; // Add item in the cache. AddAsync can be replaced with InsertAsync depending on your requirement. Task task = cache.AddAsync(key, product); // Wait before fetching data // Retrieve cached item from the cache var retrievedItem = cache.Get(key); // Update the price of retrieved product retrievedItem.Price = 500; // Add Product object to cache cache.InsertAsync(key, retrievedItem); // Remove item from the cache cache.RemoveAsync(key); |
Conclusão
Como agora você está familiarizado com as operações básicas do CRUD, NCache, você pode facilmente começar a usá-los para aprimorar o desempenho de seus aplicativos distribuídos. O que você estava fazendo com seu banco de dados agora pode ser replicado para seu cache de forma simples e o resultado é uma experiência de usuário aprimorada devido ao tempo de resposta significativamente reduzido. Você pode ver o recursos avançados de NCache para uso extensivo em seus aplicativos web, microsserviços, bibliotecas e aplicativos de console. Então, baixe NCache agora com seu teste gratuito para explorar mais!
NCache Adicionar ao carrinho NCache Baixar Comparação de edições