As estruturas de dados nativas oferecem um método convencional de armazenamento e recuperação de dados. Por meio de sua implementação, eles fornecem simultaneidade para seus aplicativos independentes – o que é ótimo, exceto que eles são limitados apenas aos threads dentro de um processo de aplicativo. E com aplicativos escaláveis executados em mais de um servidor, surge a necessidade de compartilhar o estado das estruturas de dados entre os aplicativos.
É aqui que entram as estruturas de dados distribuídas. Embora ofereçam a funcionalidade das estruturas de dados convencionais, as estruturas de dados distribuídas permitem que vários processos e instâncias de aplicativos adicionem, busquem e removam dados simultaneamente sem comprometer a consistência dos dados. Essas estruturas de dados resolvem o problema que as estruturas de dados convencionais não conseguiam resolver; estes permitem a computação paralela.
Onde NCache caber?
NCache, sendo uma solução de cache na memória, aprimora todas as funcionalidades fornecidas pelas estruturas de dados distribuídas. Usando NCache como um cache distribuído permite que seus dados estruturados sejam acessados de threads fora do processo.
Você pode adicionar seus dados em uma estrutura de dados distribuídos, armazená-los em cache em qualquer um dos servidores e se maravilhar com a forma como os dados agora estão acessíveis a todos os aplicativos, processos e instâncias que fazem parte do seu sistema, independentemente de qual servidor armazenou esses dados.
Como se não bastasse, NCache fornece alta disponibilidade na forma de topologia de réplica particionada. Os dados que você mantém nos servidores de cache são compreensivelmente importantes para você. Perder esses dados devido a qualquer falha do servidor não é aceitável em nenhum caso. É exatamente por isso NCache permite que você mantenha réplicas de seus dados no servidor de armazenamento em cache para que, se um dos nós ficar inativo, sempre permaneça um conjunto replicado dos mesmos dados exatos que podem ser usados em tais cenários. Dessa forma, você nunca terá perda de dados em seu aplicativo .NET. Além de tudo isso, você terá autoridade para adicionar nós de servidor de cache em tempo de execução de acordo com seus requisitos.
NCache fornece a funcionalidade de replicação, particionamento e dimensionamento de dados encapsulados dentro das estruturas de dados. Portanto, os desenvolvedores que usam essas estruturas de dados não precisam se preocupar com a lógica de distribuição dentro de seus aplicativos .NET.
NCache Adicionar ao carrinho Estruturas de dados em NCache
Estruturas de dados distribuídos em NCache
NCache fornece várias estruturas de dados para obter escalabilidade, simultaneidade e precisão em seu aplicativo .NET. Vejamos essas estruturas de dados que aprimoram o desempenho geral do seu aplicativo.
Lista Distribuída
NCache fornece Lista Distribuída que é uma implementação .NET nativa da interface IList. NCache ser uma solução nativa de cache .NET por si só beneficia você onde seu aplicativo é baseado exclusivamente em .NET também. Que melhor coisa para seu aplicativo .NET ter do que tudo nativo e hospitaleiro.
Os trechos de código a seguir mostram como criar, preencher e despovoar uma lista distribuída em NCache.
Um aplicativo criando e preenchendo uma lista:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
// Specify unique cache key for list string key = "ExpensiveProducts"; DataTypeAttributes dataTypeAttributes = new DataTypeAttributes(); dataTypeAttributes.Expiration = new Expiration(ExpirationType.Sliding, new TimeSpan(0, 2, 0)); // Create list of Product type IDistributedList<Product> list = cache.DataTypeManager.CreateList<Product>(key, dataTypeAttributes); // Get products to add to list Product[] products = FetchProductsFromDB(); foreach (var product in products) { // Add products to list list.Add(product); } |
Outro aplicativo buscando e removendo produtos descontinuados da lista
1 2 3 4 5 6 |
// Get list of Product type IDistributedList<Product> list = IDistributedList <Customer> list = cache.DataTypeManager.GetList<Product>("ExpensiveProducts"); // Get range of discontinued products to be removed List<Product> itemsToRemove = FetchDiscontinuedProducts(); list.RemoveRange(itemsToRemove); |
Incorporar uma lista distribuída em aplicativos do dia a dia é muito simples. Abaixo estão alguns dos cenários que retratam aplicativos que precisam de uma implementação de lista distribuída.
Caso de uso: carrinho de compras
Vamos supor que seu aplicativo .NET seja uma plataforma de comércio eletrônico. Neste aplicativo, os clientes podem adicionar e remover itens do carrinho de compras. Para permitir que essas solicitações sejam processadas adequadamente, você precisa salvar os dados de cada cliente que contêm a identidade do cliente e os itens adicionados ou removidos com relação a esse ID. A melhor e mais organizada maneira de fazer isso é usando uma lista distribuída.
Uma lista distribuída, em ambiente multi-servidor, guarda os dados do seu cliente e disponibiliza-os em todos os servidores. Você pode fazer com que essa lista acompanhe todos os itens que um cliente comprou, mostrou interesse ou até mesmo aqueles que ele optou por ignorar. Isso não apenas melhora o valor geral de seu aplicativo, mantendo um registro sofisticado, mas também torna os dados altamente disponíveis para você.
Caso de uso: placar
Para as pessoas interessadas em jogos, o placar de líderes atua como uma fonte vital de informações, sejam jogos online ou partidas mundiais. Essas pessoas estão sempre interessadas em saber qual equipe está liderando e quem está ficando para trás. Informações como essa podem ser incorporadas em um aplicativo que usa uma estrutura de dados de lista para armazenar os dados necessários e transmiti-los a todos os usuários interessados.
NCache Adicionar ao carrinho Listas em NCache
Fila Distribuída
NCache fornece uma implementação First-in First-out conhecida como Fila Distribuída. As filas são usadas em tempo de execução para armazenar informações valiosas devido ao seu comportamento FIFO.
IDistributedQueue é uma estrutura de dados fácil de entender e implementar fornecida por NCache. Observe o código abaixo para se familiarizar com as operações básicas em uma fila, como criar uma fila, adicionar e remover dados dela.
Um aplicativo criando e preenchendo a fila
1 2 3 4 5 6 7 8 9 |
string key = "CandidateQueue"; // Create Queue of Candidate type IDistributedQueue<Candidate> queue = cache.DataTypeManager.CreateQueue<Candidate>(key); foreach(var candidate in candidates) { // Add candidates to queue queue.Enqueue(candidate); } |
Outro aplicativo buscando a fila do cache distribuído e desenfileirando o primeiro item
1 2 3 4 |
IDistributedQueue<Candidate> queue = cache.DataTypeManager.GetQueue<Candidate>("CandidateQueue"); // Remove first item of queue var firstCandidate = queue.Dequeue(); |
Mencionados abaixo estão alguns dos casos de uso de uma fila distribuída para lhe dar uma ideia aproximada de onde você pode usar uma fila e quais benefícios você obterá dela.
Caso de uso: fila de mensagens
Seu aplicativo .NET hospedado em vários servidores que atendem vários clientes ao mesmo tempo precisa enviar mensagens para um dos clientes que estão usando seu aplicativo. O que você faz aqui? Em um ambiente distribuído, você não controla a conexão entre seus servidores e os clientes, o que significa que você não sabe qual servidor está entretendo qual cliente.
Nesse cenário, você precisa de uma fila distribuída para acompanhar todas as mensagens que precisam ser entregues aos clientes. Essa lista é distribuída entre todos os servidores de cache para garantir que todos os clientes conectados ao seu aplicativo tenham sempre acesso aos mesmos dados. NCache cuida da replicação dos dados distribuídos para você. Portanto, usando uma fila distribuída em um cache distribuído, você pode obter simultaneidade de dados e alta disponibilidade.
Caso de uso: análise de sentimento
Um aplicativo usado por uma agência de inteligência para filtrar tweets ameaçadores ou confidenciais poderia se beneficiar totalmente de uma fila distribuída fornecida por NCache. Vamos supor que haja vários nós executando seu aplicativo da web. O que você deseja é processar esses tweets em um ambiente distribuído com tanta precisão que um tweet não seja processado mais de uma vez. A maneira de conseguir isso é se esse aplicativo usar uma fila distribuída para armazenar todos os tweets recebidos nela. Isso garantirá que nenhum tweet seja processado duas vezes, melhorando o desempenho geral e a precisão do seu aplicativo.
NCache Adicionar ao carrinho Filas em NCache
Conjunto de Hash Distribuído
NCache fornece uma implementação extremamente rápida e escalável de conjuntos chamados de DistribuídoHashSet. HashSet é um tipo de dados não ordenado cujos valores são únicos e distintos.
Vejamos o código abaixo para entender como você pode criar e preencher um HashSet.
Primeiro aplicativo preenchendo um hashset
1 2 3 4 5 6 7 8 9 10 |
// Create unique keys for hashSets string mondayUsersKey = "UsersLoggedInOnMonday"; // Create hashSets of object type IDistributedHashSet<string> userSetMonday = cache.DataTypeManager.CreateHashSet<string>(mondayUsersIds); // Add user IDs for Monday userSetMonday.Add("john_smith"); userSetMonday.Add("mike_cohn"); userSetMonday.Add("mike_ross"); |
Segundo aplicativo buscando hashset e modificando-o
1 2 3 4 5 6 |
// Getting hashset from cache IDistributedHashSet<string> userSetMonday = cache.DataTypeManager.GetHashSet<string>("UsersLoggedInOnMonday"); // Remove user with given ID from the set userSetMonday.Remove("mike_cohn"); userSetMonday.RemoveRandom(); |
Você pode usar HashSets distribuídos onde seu aplicativo precisa realizar operações em dados que são únicos em sua natureza. Aqui estão alguns dos cenários de aplicações cujo desempenho é melhorado com a implementação do DistributedHashSet.
Caso de uso: rastreamento de endereço IP
Como os hashsets não contêm nenhum valor duplicado, você pode usar NCacheimplementação de HashSets distribuídos para acompanhar todos os usuários e visitantes do site. Por exemplo, se você tem uma livraria online, o HashSets pode ajudá-lo a identificar, com bastante facilidade, qual usuário está interessado em quais livros e quantos livros comprou e outros enfeites.
Caso de uso: análise de vendas de comércio eletrônico
Você pode manter todas as informações necessárias dentro de um HashSet. Tudo o que um HashSet precisa é de um valor exclusivo para atribuir vários valores a ele. Por exemplo, você deseja acompanhar todos os usuários que compraram algo do seu aplicativo de loja online. Você deseja seus IDs e, em cada ID, deseja manter uma lista dos itens que o cliente comprou, itens que foram colocados na lista de desejos, itens que foram removidos da lista de desejos. Agora que você tem todas essas informações em um conjunto refinado, você pode realizar várias operações com a maior facilidade.
NCache Adicionar ao carrinho Conjuntos de hash em NCache
Dicionário distribuído
Dicionário distribuído fornecido por NCache é um par chave-valor que é uma implementação .NET nativa da interface IDictionary. Um dicionário contém um valor em relação a uma determinada chave e, se esse valor precisar ser alterado, você precisará substituí-lo.
Você pode usar IDistributedDictionary em NCache para manter um registro dos produtos. Você pode criar e adicionar/remover informações do produto de e para um dicionário das seguintes maneiras.
Primeiro aplicativo criando e preenchendo um dicionário
1 2 3 4 5 6 7 8 9 10 11 12 |
string key = "ExpensiveProducts"; // Create dictionary of Product type IDistributedDictionary<string, Product> dictionary = cache.DataTypeManager.CreateDictionary<string, Product>(key); // Adding products to dictionary Product[] products = FetchProducts(); foreach(var product in products) { string productKey = $"Product:{product.ProductID}"; dictionary.Add(productKey, product); } |
Segundo aplicativo buscando e modificando o dicionário
1 2 3 4 5 6 7 8 9 10 11 |
// Fetch dictionary of Product type from cache IDistributedDictionary<string, Product> dictionary = cache.DataTypeManager.GetDictionary<string, Product>("ExpensiveProducts"); // Create list of keys to remove List<string> keysToRemove = FetchDiscontinuedProducts(); // Get values from dictionary against the given keys ICollection<Product> values = dictionary.Get(keysToRemove); // Remove items from dictionary with given keys int itemsRemoved = dictionary.Remove(keysToRemove); |
Um dicionário distribuído pode ser utilizado em múltiplos casos, mostrando-se extremamente prático e eficiente em cada um deles. Exemplos de tais casos são fornecidos abaixo.
Caso de uso: armazenamento de valores criptografados no cache
Uma das muitas vantagens de usar um dicionário em um ambiente distribuído é quando você precisa armazenar chaves criptográficas. Essas chaves precisam estar disponíveis para todos os servidores que fazem parte desse sistema distribuído. Você armazena dados cifrados em um dos servidores de cache como um valor de dicionário junto com sua chave de descriptografia. Fazer isso permite que todos os servidores que possam precisar desses dados no futuro tenham acesso compartilhado não apenas aos dados, mas também à sua chave de descriptografia.
Caso de uso: armazenamento de credenciais de login
Um dicionário distribuído é a maneira mais eficiente de armazenar e acessar o ID de login e a senha de um usuário. Suponha que haja um aplicativo em execução em vários servidores que exija que seus usuários forneçam credenciais de segurança para que tenham acesso a dados confidenciais. Para garantir que todos os servidores que atendem ao seu aplicativo tenham acesso a essas informações importantes, você pode armazenar em cache esses valores como pares de valores-chave do Dicionário. Isso garante que, se um servidor adicionar um novo par de valores-chave ao dicionário, qualquer outro servidor possa pesquisar facilmente os dados necessários no dicionário.
NCache Adicionar ao carrinho Dicionário em NCache
Contador distribuído
NCache fornece Contador estrutura de dados que é usada para incrementar e decrementar o valor com facilidade. Para tornar sua vida muito melhor, NCache permite bloquear os dados colocados dentro de um contador para manter os dados consistentes.
Para seu aplicativo .NET, o código a seguir ajuda a entender como criar uma instância de ICounter, preenchê-la com dados e como incrementar/decrementar esse valor.
Primeira aplicação criando o contador com um valor inicial
1 2 3 4 5 6 7 8 |
string key = "SubscriptionCounter"; long initialValue = 15; // Create counter ICounter counter = cache.DataTypeManager.CreateCounter(key, initialValue); // Set the initial value of counter to 100 counter.SetValue(100); |
Segundo aplicativo buscando e modificando o contador
1 2 3 4 5 6 7 8 |
// Create counter ICounter counter = cache.DataTypeManager.GetCounter("SubscriptionCounter"); // Increment value of counter counter.Increment(); // Decrement value of counter counter.Decrement(); |
Você pode usar contadores em inúmeros cenários, basta olhar ao redor e quase todos os problemas encontrados podem ser resolvidos usando contadores distribuídos em um ambiente de cache. Alguns desses cenários são os seguintes.
Caso de uso: contagem de visualizações de página
Para ver quantas visualizações uma página da Web recebe por hora ou por dia, dependendo do que você deseja, pode ser facilmente implementado usando contadores distribuídos em NCache. A cada nova exibição, o contador no servidor de cache será incrementado de acordo. Este valor junto com todos os valores presentes em todos os servidores de cache serão atualizados no banco de dados após um determinado período de tempo. Fazendo isso, você evita muitas idas desnecessárias ao banco de dados, melhorando assim o desempenho geral do seu aplicativo .NET.
Caso de uso: análise de tweets
Digamos que você tenha um aplicativo que conta todos os tweets importantes de políticos e celebridades. Ele também acompanha o número de curtidas e desgostos, comentários e outras coisas que seus tweets recebem. Agora digamos que uma pessoa A tweets e curtidas em seu tweet vão de 0 a um milhão em menos de meia hora. Este é o tipo de dado que não é transitório, mas você ainda precisa persistir. Mas a velocidade na qual você precisa persistir é muito mais lenta do que a velocidade na qual os dados estão sendo atualizados.
Para registrar uma mudança tão abrupta e frequente, você definitivamente precisa de um componente secundário que não deixe seu banco de dados engasgar com a frequência dos dados. E é aqui que você precisa NCache. Ser um cache na memória é útil quando você precisa armazenar informações temporariamente e depois gravar tudo no banco de dados após um intervalo. Aqui, se você começar a armazenar em cache a contagem de curtidas Como tweets em vez de modificar diretamente o valor no banco de dados, você estará evitando muitas chamadas de rede desnecessárias.
NCache Adicionar ao carrinho Contadores em NCache
Resumindo tudo
Quando você tem uma arquitetura de camada única, não precisa de estruturas de dados distribuídas. Você pode manter e implementar qualquer estrutura de dados que precisar dentro de seu aplicativo. Mas, quando você muda para vários servidores e começa a lidar com dados transitórios que não precisam ser persistidos, ou dados cuja modificação é extremamente cara, seu banco de dados engasga e o desempenho fica comprometido. Para evitar que essa tragédia aconteça com seu aplicativo, você precisa de estruturas de dados distribuídas. E quando você fala sobre distribuído, você deve sempre ter NCache no fundo de sua mente.
NCache é extremamente escalável e o fato de ser uma solução in-memory a torna a melhor solução possível para todos os seus problemas de cache de dados.
NCache Adicionar ao carrinho Baixar NCache Comparação de edições