NCache como sabemos até agora, armazena dados no cache para melhor desempenho e alcançar alto desempenho e escalabilidade. Nós vimos NCache fazendo maravilhas quando se trata de acesso rápido de dados para aumentar o desempenho do seu aplicativo, no entanto, ainda precisamos aprender que tipo de dados NCache armazenar no cache. Assim como os bancos de dados, NCache permite adicionar dados seguindo etapas simples e é muito flexível quando se trata de adição de dados e fornece vários tipos de dados que atendem a quase todos os tipos de necessidades de aplicativos. Este blog é sobre as formas em que NCache armazena seus dados no armazenamento em cache, proporcionando a máxima facilidade para você.
Pares de valores-chave
Para começar, NCache é um armazenamento de valor-chave que afirma claramente que NCache armazena dados de forma que haja uma chave para esse valor. UMA chave é um identificador baseado em string e tem a seguinte lista de propriedades:
- Uma chave deve ser única e não há duplicação de chave permitida por NCache.
- Uma chave não pode ser nula.
- A chave diferencia maiúsculas de minúsculas.
A valor é o valor do objeto armazenado no cache. Veremos todos os tipos suportados no blog mais tarde. Isso explica o par chave-valor em que a chave é usada como o atributo de identificação para o valor armazenado em relação a ela. A Figura 1 ilustra como os dados são adicionados e armazenados no cache:
Tipos de dados suportados em NCache
NCache suporta os dados na forma de objetos. Esses objetos podem estar em qualquer uma das seguintes formas:
- Tipos primitivos
- Objeto de classe personalizada
- Estruturas de dados
- Dados JSON
Chaves de cache e visão geral dos dados Adicionando dados ao cache NCache Clustering dinâmico
Tipos de dados primitivos
NCache suporta todos os tipos de dados primitivos .NET. Você pode adicionar uma string como um valor em uma chave. A seguir estão os tipos suportados por NCache:
byte/sbyte | curto/curto | objeto | corda | duplo | bool | Intervalo de tempo |
int/uint | longo/longo | carbonizar | flutuar | decimal | DateTime |
Vamos percorrer rapidamente um breve exemplo de código mostrando a adição de uma string na chave no cache:
1 2 3 4 5 6 7 8 |
// Specify the customer name as string string customerName = "John Wick"; // Generate a unique cache key string key = "Customer"; // Add the string to cache cache.Add(key, customerName); |
Objeto de classe personalizada
Objeto de classe personalizado refere-se a um objeto de classe .NET ou Java, por exemplo, Produtos ou Pedidos ou Clientes etc. A única e muito importante condição para adicionar um objeto de classe personalizado ao seu cache é marcar os dados serializável. Você pode serializar a classe no cache:
- Adicionando o atributo .NET Serializable em sua classe personalizada ou
- utilização Serialização Compacta Dinâmica que é uma estrutura fornecida por NCache fornecendo serialização econômica para classes registradas dinamicamente.
No entanto, dados não serializados não podem ser adicionados ao cache. Olhe para a Serialização seção para obter mais detalhes sobre a serialização de dados de cache.
Vamos adicionar um objeto de classe personalizado no cache no código abaixo. Antes de adicionar os dados ao cache, marque-os serializados como mostrado:
1 2 3 4 5 6 7 8 |
[Serializable] public class Product { public int ProductID { get; set; } public string ProductName { get; set; } public string Category { get; set; } public int Price { get; set; } } |
1 2 3 4 5 6 7 8 |
// Get product from database against given product ID Product product = FetchProductFromDB(1001); // Generate a unique cache key for this product string key = $"Product:{product.ProductID}"; // Add Product object to cache CacheItemVersion version = cache.Add(key, product); |
Estruturas de dados
NCache sendo distribuído na natureza oferece a funcionalidade de estruturas de dados convencionais que permite a adição, remoção e recuperação de dados sem afetar a consistência dos dados. A seguir estão as estruturas de dados suportadas por NCache:
- Lista Distribuída: Implementação nativa .NET da interface IList. Por exemplo, em uma plataforma de e-commerce, os clientes que adicionam/removem itens podem ser feitos usando um lista distribuída.
1 |
IDistributedList list = cache.DataTypeManager.CreateList(key, dataTypeAttributes); |
- Fila Distribuída: A implementação first-in-first-out (FIFO) para itens conhecidos como Fila Distribuída. Por exemplo, a análise de sentimentos feita por uma agência de inteligência para filtrar tweets ameaçadores pode usar um fila distribuída para armazenar os tweets nele.
1 |
IDistributedQueue queue = cache.DataTypeManager.CreateQueue(key); |
- Hashset distribuído: Uma implementação de tipo de dados não ordenado onde os valores de um conjunto são únicos e distintos. Por exemplo, se você tem uma livraria online, Conjuntos de hash pode ajudá-lo a identificar qual usuário está interessado em quais livros ou comprou quantos livros.
1 |
IDistributedHashSet userSetMonday = cache.DataTypeManager.CreateHashSet(mondayUsersIds); |
- Dicionário distribuído: Um par chave-valor que é uma implementação .NET nativa da interface IDictionary. Um valor é mantido em uma determinada chave, por exemplo, você pode armazenar credenciais de login, ou seja, o nome de usuário e a senha na forma de um dicionário distribuído em um ambiente de cache distribuído.
1 |
IDistributedDictionary<string, Product> dictionary = cache.DataTypeManager.CreateDictionary<string, Product>(key); |
- Contador Distribuído: Uma estrutura de dados usada para aumentar ou diminuir o valor facilmente. Por exemplo, para manter a contagem das visualizações que uma página da Web obtém por hora ou por dia, pode ser facilmente implementado usando contador distribuído.
1 |
ICounter counter = cache.DataTypeManager.CreateCounter(key, initialValue); |
Veja o código abaixo para ter uma ideia de como usar a lista distribuída em NCache onde uma lista de produtos é adicionada ao cache:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
// Specify unique cache key for list string key = "ProductList"; // Create list of Product type in cache IDistributedList list = cache.DataTypeManager .CreateList(key); // Get products to add to list Product[] products = FetchProducts(); foreach (var product in products) { // Add products to list list.Add(product); } |
Dados JSON em NCache
JSON é uma linguagem leve e legível utilizada pelos aplicativos por ser extremamente rápida e suportada por todos os principais frameworks JavaScript. NCache permite que você adicione seus dados JSON facilmente no armazenamento de cache fornecendo algumas classes derivadas de uma classe base JsonValueBase. Vejamos as aulas fornecidas por NCache:
- JsonObject: Esta classe é para pares nome-valor não ordenados em que name é o nome do objeto e value é o valor do objeto JSON que pode ser de qualquer tipo primitivo.
- Valor Json: Esta classe representa os tipos de dados primitivos nas convenções do JSON, como string, integer ou DateTime.
- JsonArray: Esta classe representa uma coleção de itens e representa JArray em NCachedomínio de.
- JsonNulo: Esta classe representa o valor NULL nos padrões do JSON.
O código abaixo mostra o uso de JSON em NCache com exemplo de código. O exemplo de código mostra um JsonObject formado a partir de uma string e inserido no cache.
1 2 3 4 5 6 7 8 9 10 11 12 |
var product = GetProductFromDB(); string jsonString = $@"{{ 'ProductID': { product.ProductID}, 'ProductName': '{product.ProductName}', 'Category': '{product.Category}', 'UnitsAvailable' : { product.UnitsAvailable} }}"; JsonObject jsonObject = new JsonObject(jsonString); cache.Insert(key, jsonObject); // Fetch the jsonObject previously added var jsonObject = cache.Get(key); |
Suporte JSON em NCache Estruturas de dados distribuídos Adicionando dados ao cache
Afinidade de local
Um recurso adicional de NCache para fornecer maior desempenho é Afinidade de local. Para obter maior desempenho e melhores resultados para sua aplicação, NCache dá a você o controle de manter os dados de duas classes diferentes no mesmo nó. Isso cria uma afinidade entre diferentes itens pertencentes a diferentes classes, economizando o custo correspondente ao buscar esses itens. Tudo o que você precisa fazer é adicionar os itens que tenham afinidade com chaves semelhantes {} garantindo que os itens existam no mesmo nó. Por exemplo, Order_{Product:1001}” mostra a afinidade entre os pedidos pertencentes ao objeto do produto com a chave do produto 1001.
Deixe-me mostrar um exemplo de código onde Produtos e Encomendas são adicionados no mesmo nó usando afinidade de local.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
Product product = FetchProductFromDB(1001); string productKey = "Product:1001"; var productCacheItem = new CacheItem(product); // Add CacheItem to cache CacheItemVersion version = cache.Add(key, productCacheItem); Order order = FetchOrderFromDB(17); // Unique order key for this order using Location Affinity syntax // This will create an affinity for this orderKey with the respective productKey string orderKey = "Order_{Product:1001}"; var orderCacheItem = new CacheItem(order); // Add order with Location Affinity to cache CacheItemVersion version = cache.Add(key, orderCacheItem); |
Conclusão
Em conclusão, NCache fornece maneiras flexíveis de adicionar dados ao cache, acomodando os requisitos do seu aplicativo. Tudo o que você precisa fazer é usar uma API simples para adicionar os dados no cache. A melhor parte sobre NCache é que a cada nova versão, a adição de dados se torna mais fácil e eficiente com o suporte de novos recursos. Você pode conferir outros recursos interessantes do NCache SUA PARTICIPAÇÃO FAZ A DIFERENÇA.
NCache Adicionar ao carrinho Baixar NCache Comparação de edições