utilização NCache no EF Core e no SQL Server
Hoje vou mostrar como você pode integrar NCache em seus aplicativos Entity Framework Core existentes para obter os benefícios de alto desempenho e escalabilidade. Há muito o que abordar, então vou direto ao assunto.
Exemplo de aplicativo EF Core
A primeira coisa que temos é isso exemplo de aplicativo Entity Framework Core que tenho usando bancos de dados SQL Northwind. Então, se viermos aqui, você pode ver que estou buscando esses pedidos entre os IDs de pedido 10249 e 10268, e podemos ver que estou buscando esses clientes dos EUA e esses produtos entre os IDs de produto 10 e 20. Isso é tudo o que esta amostra está fazendo. Vamos em frente e dar uma olhada nos resultados que isso vai buscar para nós no banco de dados. Perfeito. Então, podemos ver que buscamos esses produtos entre 10 e 20, esses 11 produtos, esses 13 clientes dos EUA e esses 20 pedidos entre esses IDs de pedido.
Então, agora que o exemplo foi executado, vamos dar uma olhada no banco de dados com o qual estamos trabalhando. Então, como você pode ver, estamos trabalhando com bancos de dados Northwind, e esses são os clientes que já existem em nossa tabela de clientes. Então, está tudo muito bem, vimos o exemplo funcionar.
Etapas de integração
Agora, vamos falar sobre como podemos integrar NCache neste aplicativo existente do Entity Framework Core. Faremos isso usando cinco etapas muito simples.
- Instale NCache Pacote EF Core Nuget
- Adicionar NCache Namespace EntityFrameworkCore
- Especifique configurações de cache em DbContext
- Torne os modelos serializáveis
- Use NCache Métodos de extensão do EF Core
Instale NCache Pacote EF Core Nuget
Então, o primeiro passo será instalar o NCache Pacote NuGet principal do Entity Framework no aplicativo. Então, se eu gerenciar os pacotes NuGet para esta aplicação, podemos ver que já tenho o EntityFrameworkCore instalado.NCache Pacote NuGet que corresponde a NCache 5.3 SP2. Perfeito. Então, vou apenas encerrar isso.
Adicionar NCache Namespace EntityFrameworkCore
Vamos dar uma olhada na próxima etapa. Então, o próximo passo é adicionar o NCache Namespace principal do Entity Framework em nosso aplicativo. Então, se eu chegar aqui, só preciso adicionar "usando Alachisoft.NCache.EntityFrameworkCore". Vou precisar fazer o mesmo para o meu contexto. Então, eu salvo aqui, passo para o contexto, vou colar lá também e salvar, perfeito.
Especifique configurações de cache no contexto do banco de dados
Agora, a próxima etapa é especificar as configurações de cache dentro do contexto do banco de dados. Agora, se eu rolar para baixo, procuro meu método 'OnConfigurando'. Então aí está o método OnConfigurando. E, aqui, o que vou fazer é adicionar o cache com o qual estou trabalhando, então esse é o 'efcorecache' aqui, e adiciono o 'NCacheConfiguration.Configure' e digo que esse cache e o tipo de dependência são SQL server já que estou trabalhando com um SQL server, perfeito.
Torne os modelos serializáveis
E agora que isso foi feito, o próximo passo é tornar nossos modelos serializáveis. Então, vou passar para meus modelos, ir até meu cliente e adicionar [Serializable], perfeito. Vou copiar isso vou até o pedido e colo lá, salvei, e no produto, e só vou colar lá, perfeito. Então, agora que fiz isso, vou apenas olhar para esse funcionário e mostrar que já marquei todos os outros modelos como serializáveis, então não preciso fazer isso para mais nenhum modelo.
Use NCache Métodos de extensão do EF Core
Então, agora que nossos modelos estão marcados como serializáveis, isso nos leva à quinta etapa. E a quinta etapa é a mais interessante, onde usaremos o real NCache Métodos de extensão principal do Entity Framework dentro do nosso aplicativo. Agora, isso vai depender do caso de uso dos dados existentes em nosso aplicativo, e esses podem ser um dos dois casos de uso. Poderíamos ter dados transacionais ou dados de referência em nosso aplicativo.
Tratamento de dados transacionais
Portanto, se falamos sobre dados transacionais e quando falamos sobre como lidar com dados transacionais, dados transacionais são os dados que se espera que sejam lidos e gravados com extrema frequência. Um bom exemplo desses dados seria manter um histórico de voos. Então, há muitos voos que acontecem em um dia, e todos eles têm algo diferente sobre eles, então se você os registrasse em um banco de dados, você escreveria constantemente novos voos, e isso pode ser considerado um caso de uso transacional . Então, quando temos esse tipo de caso de uso transacional em nossas aplicações, para esse tipo de dados dizemos que é ideal utilizar o método de extensão 'FromCache'.
Agora, o que o método de extensão FromCache faz é a primeira vez que o método de extensão FromCache funciona, ele funciona e se comporta como um aplicativo Entity Framework Core normal, onde suas entidades são recuperadas do banco de dados. No entanto, neste momento, o método FromCache preenche essas entidades no cache, e o benefício disso é que na próxima vez que você precisar chamar essas consultas ou precisar dessas entidades em seu aplicativo, você não retornará totalmente ao banco de dados para obter essas entidades e, em vez disso, você recupera rapidamente essas entidades do cache e recebe o benefício de alto desempenho e prepara rapidamente todos os seus dados para serem inseridos em seu aplicativo.
Agora, vamos em frente e realmente fazer essa implementação e dar uma olhada em como ela funciona. Então, voltando ao nosso aplicativo, o que vou fazer aqui é trabalhar com pedidos e adicionar algumas opções de cache de pedidos, lá vamos nós, e digo que tenho 'new CachingOptions() ' aqui, e vou apenas definir 'StoreAsType' como uma 'Coleção'. Então, quero que todos os pedidos sejam armazenados como uma única coleção no cache. Eu também quero que eles expirem, então vou adicionar uma expiração, então vou 'SetSlidingExpiration', vou adicionar um 'TimeSpan ()' de 10 minutos para que esses pedidos expirem após 10 minutos, perfeito . E, agora que isso foi feito, vou rolar para baixo aqui e adicionar o método de extensão '.FromCache' e adicionar o 'order_caching_options', perfeito. Isso é tudo que preciso fazer aqui.
var order_caching_options = new CachingOptions()
{
StoreAs = StoreAs.SeparateEntities
};
order_caching_options.SetSlidingExpiration(new TimeSpan(0, 10, 0));
//Orders
var order_resultset = context.Orders
.Where(o => o.OrderId >= 10249 && o.OrderId <= 10268)
.FromCache(order_caching_options)
.ToList();
Console.WriteLine($"Orders between 10249 and 10268 fetched: {order_resultset.Count}
\n--------------------------------------------------------------------------\n\n"
+ String.Format("{0,-25} {1,-40} {2,-10}", $"Order ID", $"Date", $"Shipper Name") + "\n");
order_resultset.ForEach(order =>
{
Console.WriteLine(String.Format("{0,-25} {1,-40} {2,-10}", $"{order.OrderId}", $"{order.OrderDate}", $"{order.ShipName}"));
});Agora, antes de executá-lo, vamos dar uma olhada em nosso cache. Agora, aqui tenho a configuração 'EFCoreCache' em meus dois nós que podemos ver aqui. Se você for ao Monitor, podemos ver que ele está totalmente conectado, saudável, funcionando e em bom estado, sem nada dentro. E, se formos para as estatísticas, isso nos conta a mesma história, é um cache saudável com zero itens prontos para uso, perfeito. Agora, vamos executar nosso aplicativo e dar uma olhada nos resultados que obtemos, perfeito.
Agora que o aplicativo está rodando vou apenas fechar esta janela do console aqui, e podemos ver essas solicitações que recebemos em nosso cache nesta adição que ocorreu, e se rolarmos para baixo podemos ver essa contagem, o que significa que nossa coleção foi preenchida no cache.
Agora, se eu executar o 'export-cachekeys', perfeito, podemos ver essa coleção que foi inserida no cache. Agora, digamos que eu queira adicionar cada pedido como uma entidade separada, então o que farei é adicionar 'SeparateEntities' ao meu tipo 'StoreAs' em vez de coleção. Vou executar este aplicativo novamente . E agora o que isso fará é, em vez dessa coleção única, adicionar esses pedidos como entidades separadas. Agora que os aplicativos estão em execução posso fechá-los e podemos ver toda essa atividade que aconteceu e, mais importante, essas adições. Essas 16 e 4 adições, e essa contagem que subiu.
Então, se formos para Estatísticas, podemos ver 16 e 5. Agora, vou exportar as chaves de cache novamente e podemos ver que temos uma contagem de cache de 21 e todos os nossos pedidos foram preenchidos como separados entidades no cache, bem como uma coleção. Então, isso é perfeito e resume como o método de extensão FromCache é usado.
Tratamento de dados de referência
Agora, vamos falar sobre como você lida com dados de referência e o que são dados de referência. Dados de referência são o tipo de dados que são lidos com muito mais frequência do que jamais foram gravados. Então, esses são dados que permanecem mais ou menos estáticos. Por exemplo, você tem um catálogo de produtos. Agora, não se espera que seus produtos mudem com muita frequência, de modo que possam ser dados de referência que estão sendo lidos consistentemente no banco de dados e raramente ou nunca sendo modificados. E, no caso de dados de referência, a recomendação é que você traga todo o seu conjunto de trabalho de dados de referência para o cache e, então, só leia o cache sempre que desejar buscar esses dados de referência. Deixe-me mostrar como você vai fazer isso.
Portanto, o primeiro método que temos, ou o segundo método de extensão que temos, é o método de extensão 'LoadIntoCache()'. Agora, o método de extensão LoadIntoCache() é extremamente poderoso para carregar seu conjunto completo de dados de trabalho no cache. Então, isso irá executar a consulta no banco de dados, obterá o resultado da consulta e preencherá todo o resultado da consulta no cache e, em seguida, retornará esse resultado ao aplicativo.
E isso é útil novamente para trazer os dados para o cache, e você pode executar isso em intervalos regulares sempre que esperar que os dados sejam alterados. Portanto, se você espera que os dados sejam alterados dentro de uma semana, poderá executá-los novamente após uma semana para continuar atualizando os dados no cache e para garantir que não receberá resultados parciais ao consultar essas entidades apenas no cache. Falando em consultar apenas a partir do cache, a maneira como você faria isso seria usando o método de extensão 'FromCacheOnly()'. Agora, o método de extensão FromCacheOnly() apenas procura dados no cache e nunca vai para o banco de dados back-end para obter esses resultados. Este é um método de extensão extremamente rápido e garante que você receba todos os benefícios de desempenho do cache na memória, pois recebe todas as entidades de um cache clusterizado e nunca examina seu banco de dados.
Agora, vamos implementar esses métodos de extensão em nosso aplicativo. Porém, há um pré-requisito que devemos cumprir antes de usá-los. Portanto, para usar esses métodos de extensão de dados de referência, teríamos que definir os índices de consulta em nossa aplicação, e isso pode ser feito de duas maneiras. Agora, posso criar dinamicamente esses índices de consulta aqui, adicionando a tag '[QueryIndexable]', que também trará o namespace 'NCache.Runtime.Caching' no aplicativo e agora fiz isso dinamicamente. Mas, vou fazer isso de outra maneira. Então, vou comentar isso aqui, e se for aos meus caches de cluster posso mostrar que já defini esses índices de consulta no meu cache como podemos ver aqui.
Então, como já fiz isso não preciso adicioná-los dinamicamente dentro da minha aplicação. Então, agora que está estabelecido, vou rolar para baixo aqui e tenho esse pedaço de código aqui, e tudo isso está acontecendo, só para descomentar, é buscar os produtos do banco de dados. Ele irá armazená-los como entidades separadas usando o método de extensão 'LoadIntoCache()', e isso é tudo que isso fará. Então, agora vou prosseguir e executar isso, e vamos dar uma olhada nos resultados que isso traz, perfeito.
//Load ALL Products Into Cache
var products_caching_option = new CachingOptions
{
StoreAs = StoreAs.SeparateEntities
};
var all_products = (from products in context.Products
select products)
.LoadIntoCache(products_caching_option)
.ToList();
Console.WriteLine($"\n\nAll Products Loaded into cache : {all_products.Count}\n\n");
all_products.ForEach(product =>
{
Console.WriteLine(String.Format("{0,-25} {1,-40} {2,-10}", $"{product.ProductId}", $"{product.ProductName}", $"{product.UnitPrice}"));
});Então, podemos ver que carregamos esses 77 produtos no cache, e podemos ver essa contagem que aumentou totalmente, essas adições que aconteceram e essas solicitações que chegaram. podemos ver 42 e 57.
Agora vou exportar as chaves do cache novamente, perfeito. Portanto, podemos ver esses 99 itens em nosso cache e todo o nosso conjunto funcional de produtos foi trazido para ele. Agora que temos todo o nosso conjunto de trabalho dentro do cache, é seguro voltar para onde estava consultando os produtos, então vou apenas comentar isso, e vamos subir e nós ' vou adicionar o método de extensão 'FromCacheOnly()' onde estava buscando meus produtos, perfeito. E, agora que isso foi feito, posso simplesmente executar o aplicativo novamente. E vamos dar uma olhada nos resultados que meu aplicativo busca no método de extensão 'FromCacheOnly ()'. Aqui vamos nós.
Então, podemos ver que obtivemos o mesmo número de produtos, esses 11 produtos, então sabemos que temos um resultado completo aqui e podemos ver que essa busca ocorreu dentro do nosso cache, e essa atividade significa que este FromCacheOnly( ) o método de extensão funcionou e buscou os resultados para nós no cache.
Específico do núcleo EF NCache APIs
Então, isso é tudo para os métodos de extensão FromCacheOnly() e LoadIntoCache(). Agora podemos falar sobre o Específico do EF Core NCache APIs. Assim, NCache oferece a capacidade de não precisar necessariamente usar um método de extensão para inserir ou remover dados do cache. Você também pode buscar o identificador de cache do contexto usando a biblioteca EF Core e, em seguida, usando esse identificador de cache, você pode inserir entidades independentes e remover entidades independentes do cache. Uma coisa que eu acrescentaria aqui é que isso não é o mesmo que o NCache APIs disponíveis no NCache SDK, e esta é a API dedicada ou específica do Entity Framework Core.
Então, se dermos uma olhada nessas APIs e como elas funcionam. Então, é assim que os usaríamos. Portanto, buscaríamos o cache do contexto e, em seguida, inseriríamos dados no cache simplesmente executando um cache.Insert no cliente e fornecendo uma chave de cache de string de saída. Essa chave de cache seria gerada pelas APIs do Entity Framework Core. E, então, quando você quiser remover dados ou remover algum item do cache usando o mesmo identificador de cache, você pode, por exemplo, encontrar esses dados dentro do cache usando context.find e simplesmente executar cache.Remove.
Agora, vamos fazer isso em nosso aplicativo. Então, se eu voltar ao meu aplicativo aqui e rolar para baixo, tenho esse trecho de código aqui que adiciona o cliente ao cache. Vou apenas descomentar esse código, e se você rolar para cima podemos ver que estou simplesmente obtendo o cache do contexto que cria esse cliente, e quero armazená-lo como uma entidade separada, quero salvar as alterações e execute este cache.Insert e, em seguida, escreva que adicionei esse cliente ao cache. Então, vamos executá-lo e dar uma olhada no que isso faz.
//Add Customer Using Cache Handle
Cache cache = context.GetCache();
var cust = new Customer
{
CustomerId = "HANIH",
ContactName = "Hanih Moos",
ContactTitle = "Sales Representative",
CompanyName = "Blauer See Delikatessen",
};
var options = new CachingOptions
{
StoreAs = StoreAs.SeparateEntities
};
context.Customers.Add(cust);
context.SaveChanges(true);
cache.Insert(cust, out string cacheKey, options);
Console.WriteLine($"Customer ID: {cust.CustomerId} -> Added to Cache");Assim, podemos ver que adicionamos este cliente ao cache. Então, se eu fechar esse aplicativo, podemos ver essa adição que foi realizada nessas solicitações, e podemos ver uma pequena queda, então passamos de 42 para 43. Se formos para as estatísticas, podemos ver 43 e 57 que completa 100. Então, se eu exportar as chaves de cache podemos ver aquele cliente independente, pronto. Assim, podemos ver aquela entidade independente e separada que adicionamos ao cache. Isso é perfeito.
Agora, vamos remover esse cliente. Então, vou apenas comentar esse trecho de código. Novamente, vou rolar para baixo aqui e descomentar esse trecho de código, e tudo o que esse trecho de código faz é procurar o cliente no cache do mesmo nome de cliente e, se encontrar esse cliente, ele é vou removê-lo do contexto, salvar as alterações e removê-lo do cache. E, então, será impresso que isso foi feito. Caso contrário, dirá que não conseguiu encontrar o cliente.
//Remove Customer Using Cache Handle
Cache cache = context.GetCache();
Customer customerToRemove = context.Customers.Find("HANIH");
if (customerToRemove != null)
{
context.Customers.Remove(customerToRemove);
context.SaveChanges(true);
cache.Remove(customerToRemove);
Console.WriteLine($"Customer ID: {customerToRemove.CustomerId} -> Removed from Cache");
}
else
{
Console.WriteLine("could not find the customer within the cache");
}
Console.ReadLine();Então, vamos rodar esse aplicativo e dar uma olhada nos resultados, perfeito. Então, podemos ver que o cliente foi retirado do cache, e podemos ver nas estatísticas que passamos de 43 para 42, e o monitor mostraria a mesma coisa, perfeito.
Então, agora, se voltarmos às estatísticas, vou apenas abrir o NCache PowerShell, e vou exportar as chaves de cache, perfeito. E podemos ver que não temos mais aquele cliente em nosso cache. E é assim que você pode adicionar e remover clientes ou quaisquer dados usando o NCache APIs específicas do EF Core.
Próximos Passos
Baixar NCache
E isso nos leva ao final desta demonstração, muito obrigado. Se você quiser download NCache você pode receber uma avaliação gratuita de 30 dias e um produto funcional completo com todos os recursos em nossa página de downloads. Deixe-me levá-lo até lá agora. Então, se viermos aqui você pode ver aqui que essas são as ofertas para .NET que você pode baixar para Windows e para Linux que NCache proporciona.
Experimente o Playground
Além disso, você pode tentar NCache fora no NCache Parque infantil. E você pode realmente ter uma ideia do produto para ver como os recursos funcionam. Então, se você for aqui para o Experimente o Playground você pode ver que pode iniciar esta sessão de sandbox por 30 minutos, o que permite executar alguns exemplos e ver como os exemplos .NET e Java seriam executados.
Agende um Personalizado NCache Demo
E por último, você pode reservar um personalizado NCache demonstração onde forneceríamos uma sessão técnica de uma hora onde discutiríamos NCache arquitetura e recursos, e mapeá-los de acordo com o caso de uso que encontramos em seus ambientes. E fazer isso é extremamente simples. Você simplesmente precisaria acessar nosso site aqui e agendar esta demonstração personalizada ao vivo de esta página aqui. E, uma vez aqui, você pode enviar aquela solicitação, nós receberemos e agendaremos alguma coisa. E isso nos leva ao final desta demonstração. Muito obrigado por assistir, tenha um dia maravilhoso. Adeus.