utilização NCache no EF Core com Oracle
Olá a todos, meu nome é Sean e hoje vou mostrar como vocês podem integrar NCache em seu existente Aplicativos principais do Entity Framework que estão configurados com um banco de dados Oracle. Faremos isso como uma demonstração prática onde trabalharemos com um aplicativo de exemplo que já configurei para esta demonstração e integraremos NCache afim disso. Então, são coisas muito interessantes que preparamos. Deixe-me mostrar como faremos isso.
Exemplo de aplicativo EF Core
Então, a primeira coisa que tenho aqui é o próprio aplicativo de exemplo. Então, vocês podem ver aqui, eu tenho o aplicativo de exemplo e estou buscando alguns pedidos, clientes e produtos aqui. E eu tenho isso configurado para funcionar com um banco de dados Oracle, que posso mostrar aqui. Se formos ao contexto, vocês podem ver que tenho aqui esse método UseOracle para trabalhar com meu banco de dados Oracle.
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
optionsBuilder.UseOracle("Data Source=(DESCRIPTION =(ADDRESS = (PROTOCOL = TCP)(HOST = 20.200.20.112)(PORT = 1521))(CONNECT_DATA =(SERVER = DEDICATED)(SERVICE_NAME = NorthWindDB)));User Id=SYS;Password=MyPassword;DBA Privilege=SYSDBA;");
}Então, antes de realmente executarmos este programa, deixe-me levá-lo ao banco de dados e mostrar com o que estamos trabalhando. Então, estou trabalhando com o banco de dados Northwind no Oracle. E como temos muitas tabelas, abri aqui as que estou trabalhando para que possamos vê-las. O primeiro é PEDIDOS, e podemos ver aqui essas propriedades para os pedidos com os quais trabalharemos. Então, vamos dar uma olhada em nossos PRODUTOS. Então, essas são as propriedades do produto que iremos obter ou buscar em nossa aplicação. E então, a terceira tabela é CLIENTES, e podemos ver os imóveis dos nossos clientes aqui mesmo. E essas são basicamente todas as tabelas com as quais trabalharemos.
Agora, vamos consultar essas tabelas e dar uma olhada no que temos dentro delas. Então, você pode ver que tenho 77 produtos em meu banco de dados Northwind, e esses são todos os produtos aqui. Então, está tudo muito bem. Agora, vamos dar uma olhada nos CLIENTES, clientes e entrar, e se eu rolar até o fim - perfeito! Assim, podemos ver que tenho 89 clientes em meu banco de dados Northwind, e todos esses clientes estão aqui, como você pode ver na sua frente.
Agora, vamos dar uma olhada em nossos pedidos. Agora, vão ter muitos pedidos, vamos rolar até o final – perfeito! Assim, podemos verificar que temos 830 pedidos em nosso banco de dados. São muitos pedidos, e podemos ver todos esses pedidos aqui. Então, vamos buscar alguns critérios no aplicativo, e vamos passar por isso agora.
Agora que o aplicativo foi executado, podemos ver perfeitamente. Agora deixe-me rolar aqui para ver que podemos buscar esses produtos entre ID 25 e 50. Portanto, temos 26 produtos; clientes que são do Reino Unido, então temos sete clientes; e pedidos entre 10280 e 10300, então temos esses 21 pedidos — perfeito!
NCache Configuração do EF Core
Então, agora que sabemos que o exemplo está funcionando, podemos prosseguir para a configuração NCache em nosso aplicativo Entity Framework Core. Então, configurando nosso aplicativo para funcionar com NCache é tão simples quanto cinco etapas que executaremos nesta demonstração.
- 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, vamos começar com o primeiro passo aqui, que é instalar o NCache Entity Framework Core NuGet Package em nosso aplicativo. Portanto, se eu for para os pacotes NuGet em meu aplicativo, estaremos procurando o EntityFrameworkCore.NCache Pacote NuGet, que está bem aqui. Eu tenho isso instalado em meu aplicativo, então podemos ver isso aqui. E estou executando a versão 5.3.2.1, que corresponde a NCache versão 5.3 SP2. Então, isso é perfeito. Agora, vamos fechar esta guia e passar para a próxima etapa.
Adicionar NCache Namespace EntityFrameworkCore
Então, o próximo passo é adicionar o NCache Namespace do Entity Framework Core no aplicativo. Então, vamos abrir o código novamente e entrar no nosso programa aqui. E só vou acrescentar:
using Alachisoft.NCache.EntityFrameworkCorePerfeito! Então, vou apenas salvar isso, passar para o contexto do modelo e colar aqui - perfeito! Feito isso, podemos passar para o próximo passo, que é especificar as configurações de cache no contexto do banco de dados.
Especifique configurações de cache no contexto do banco de dados
Então, vou rolar para baixo até meu método de configuração e adicionarei o nome do cache com o qual trabalharemos e passarei o NCache configuração. Então, esse vai ser o meu 'efcoreoraclecache' — perfeito! E eu tenho que adicionar o NCacheConfiguração.Configurar o nome do cache junto com o DependencyType, que será Oracle — perfeito! E isso é praticamente tudo que tenho que fazer aqui.
...
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
string cache = "efcoreoraclecache";
NCacheConfiguration.Configure(cache, DependencyType.Oracle);
optionsBuilder.UseOracle("Data Source=(DESCRIPTION =(ADDRESS = (PROTOCOL = TCP)(HOST = 20.200.20.112)(PORT = 1521))(CONNECT_DATA =(SERVER = DEDICATED)(SERVICE_NAME = NorthWindDB)));User Id=SYS;Password=MyPassword;DBA Privilege=SYSDBA;");
}
...Agora vamos dar uma olhada no cache com o qual trabalharemos. Então você pode ver que tenho meu EFCoreOracleCache configurado aqui mesmo nessas duas máquinas de demonstração. E vamos dar uma olhada nos detalhes desse cache. Então, a partir daqui, se quisermos monitorar esse cache, podemos clicar neste botão monitor. Isso nos levará ao monitor aqui que nos mostra a integridade do nosso cache, e podemos ver que está bom, limpo e que temos um cache íntegro para trabalhar.
Se voltarmos aos nossos dados e clicarmos nas estatísticas, isso nos levará a esta página aqui que nos mostra as estatísticas do nosso cache. Agora, se voltarmos ao nosso monitor, voltemos ao nosso aplicativo e abramos a próxima etapa.
Torne os modelos serializáveis
Então, o próximo passo é tornar nossos modelos serializáveis. Perfeito. Agora vou passar para o meu modelo de cliente. Então isso vai ficar por aí. Perfeito. E vou apenas adicionar [Serializável] por aqui. Perfeito. Agora que isso está feito, posso passar para o meu pedido. E você pode ver que já está marcado como [Serializável]. E meu produto, que novamente já está marcado como [Serializável]. Portanto, todos os meus modelos são serializáveis e estamos prontos para prosseguir aqui. Então agora podemos passar para a próxima etapa.
Use NCache Métodos de extensão do EF Core
A próxima etapa é usar o NCache Métodos de extensão do Entity Framework Core dentro do nosso aplicativo. E vou apenas fazer uma pausa aqui porque os métodos de extensão que escolhemos usar dependerão do tipo de dados que estamos armazenando em cache.
Portanto, existem dois tipos de dados que podemos armazenar em cache: o primeiro tipo é transacional e o segundo tipo é referência. O que são esses tipos e como você deve lidar com eles é algo que abordaremos em breve. Então vamos falar sobre o primeiro. Perfeito.
Tratamento de dados transacionais
Portanto, o primeiro tipo de dados que você pode manipular são os dados transacionais. Agora, dados transacionais são dados que possuem um caso de uso intensivo de leitura e gravação. Portanto, um bom exemplo disso seriam os dados de voo, onde todos os dias você tem tantos voos e esses dados são gravados no banco de dados todos os dias, e também são buscados no banco de dados todos os dias. Portanto, esse é um caso de uso intensivo de leitura e gravação que qualifica esses dados como transacionais. No nosso caso, um caso de uso semelhante pode ser mapeado para nossos pedidos. Portanto, podemos considerar nossos pedidos como nossos dados transacionais. Então, quando falamos sobre como lidar com dados transacionais no Entity Framework Core com NCache, usaremos o DoCache() método de extensão.
Agora, quando você associar esse método de extensão antes de suas consultas existentes, na primeira vez que você executá-lo, ele será executado como uma consulta padrão. Seu aplicativo irá para o banco de dados e buscará as entidades de lá. No entanto, desta vez seu aplicativo irá armazená-las em cache em seu cache clusterizado e, portanto, na próxima vez que seu aplicativo tentar buscar essas entidades, ele não fará essa viagem até o banco de dados back-end e, em vez disso, irá para trazer essas entidades do cache clusterizado de volta para seu aplicativo. Então, vamos dar uma olhada em como esse método funciona.
Então, se eu for até meu aplicativo, aqui estou pegando meus pedidos. Então, vou apenas adicionar algumas opções de cache de pedidos. Então, vou adicionar order_caching_options aqui, e estes serão 'novos CachingOptions'. Então, vou especificar meu tipo de loja aqui para dizer que quero buscar uma única coleção de todos os meus pedidos. Então StoreAs.Collection e preencha isso em meu cache. Além disso, adicionarei uma expiração absoluta de 10 minutos a esses dados, porque quando você está lidando com dados transacionais, esses dados mudam com frequência, então você deseja atualizá-los com a maior regularidade possível. Então vou apenas colocar essa expiração para 10 minutos para que depois de 10 minutos esse conjunto de dados seja atualizado dentro do cache. Então agora vou adicionar o .FromCache() método de extensão e adicione meu order_caching_options dentro, e isso é perfeito. Isto é absolutamente perfeito e é tudo o que precisamos fazer.
using OracleEFCore.Models;
using Alachisoft.NCache.EntityFrameworkCore;
namespace OracleEFCore
{
internal class Program
{
static void Main(string[] args)
{
using (var context = new Models.ModelContext())
{
//-----Orders-----
var order_caching_options = new CachingOptions()
{
StoreAs = StoreAs.Collection
};
order_caching_options.SetAbsoluteExpiration(DateTime.Now.AddMinutes(10));
int upper_orderid = 10300;
int lower_orderid = 10280;
var order_resultset = context.Orders
.Where(o => o.Orderid >= lower_orderid && o.Orderid <= upper_orderid)
.FromCache(order_caching_options)
.ToList();
...Agora, vamos executar a amostra e dar uma olhada no que obtemos. Perfeito. Então a amostra foi executada, não há alterações aqui, então posso fechar aqui, e agora podemos dar uma olhada nessas solicitações que recebemos em nosso cache. E podemos ver que essa contagem também aumentou. Agora vamos exportar as chaves de cache desse cache e dar uma olhada na coleção que acabamos de adicionar ao nosso cache clusterizado. Perfeito. Então você pode ver esta coleção que foi adicionada ao cache. Fantástico.
Mas digamos agora que eu não queria colocar uma única coleção no cache e, em vez disso, queria cada pedido como uma entidade separada. Bem, nesse caso, posso apenas especificar a loja como tipo para serem entidades separadas.
//-----Orders-----
var order_caching_options = new CachingOptions()
{
StoreAs = StoreAs.SeparateEntities
};Agora, quando eu executar este aplicativo novamente, ele colocará todos os meus pedidos como entidades separadas no cache. Agora que o aplicativo foi executado, vamos fechá-lo. Podemos ver que a contagem aumentou totalmente e podemos ver essas adições que foram realizadas e essas solicitações. Se eu for para as estatísticas, podemos ver essa contagem de 7 e essa contagem de 15. Perfeito.
Agora, vamos exportar as chaves do cache e dar uma olhada nas chaves que temos em nosso cache. Perfeito. Portanto, temos essas 22 chaves ou itens em nosso cache e todos os nossos pedidos são armazenados em cache separadamente. Isso resume muito bem como o método de extensão 'FromCache()' é usado.
Tratamento de dados de referência
Agora vamos falar sobre como você pode lidar com dados de referência. Portanto, dados de referência são dados que possuem um caso de uso de leitura intensa, mas não são atualizados com tanta frequência quanto os dados transacionais. Um bom exemplo disso seria um catálogo de produtos. Portanto, quando você tem produtos em estoque ou um catálogo de produtos, você não atualiza esse catálogo com muita frequência. Seus produtos mudariam talvez uma ou duas vezes por mês. Portanto, é mais provável que você esteja apenas lendo os dados do banco de dados e não atualizando esses dados no banco de dados com extrema frequência. Portanto, faz sentido trazer esses dados do banco de dados para um cache clusterizado e, em seguida, ler esses dados de um cache clusterizado na memória de alta velocidade ou de um armazenamento de dados, em vez de ir para o banco de dados. E isso fornecerá ao seu aplicativo alto desempenho e escalabilidade de cache distribuído na memória.
Então, quando você estiver trabalhando com dados de referência, o primeiro método que você usaria é o CarregarIntoCache() método. Agora, o método load into cache simplesmente pega os resultados da consulta que você executou no Entity Framework Core e armazena em cache esses resultados no cache do cluster. Agora, o método de carregamento no cache pode ser configurado para ser executado em um intervalo quando você espera que os dados sejam atualizados.
Digamos, por exemplo, o catálogo de produtos que atualizamos toda semana. Podemos configurar esse método para ser executado todas as semanas para que ele continue atualizando os dados no cache e você sempre tenha dados novos presentes no cache.
Agora que você tem todo o seu conjunto de dados no cache, vamos dar uma olhada no terceiro método de extensão, que é o FromCacheOnly() método de extensão. Agora o FromCacheOnly() O método de extensão é um método de extensão muito legal que faz com que você só vá do seu aplicativo para o cache clusterizado para buscar seus dados, em vez de ir para o banco de dados back-end. Você nunca irá para o banco de dados de backup quando estiver usando o FromCacheOnly() método de extensão.
Então, quando você usa esse método em conjunto com o CarregarIntoCache() método, você tem um conjunto realmente poderoso de ferramentas que garantem que seu cache clusterizado permaneça atualizado e sincronizado com seu banco de dados, e que você esteja buscando seus dados apenas de dentro de seu cache clusterizado.
Agora, vamos dar uma olhada em como usaríamos esses métodos. Então, quando você estiver trabalhando com esses métodos, a primeira coisa que precisamos fazer é fazer com que nossa consulta indexe esses modelos aqui. Se entrarmos no cliente, uma maneira de fazer isso é adicionar o [ConsultaIndexável] tag em cima do 'Cliente' aqui. Então, podemos ver esta tag 'QueryIndexable[]' aqui, e isso traz esta biblioteca. Porém, no meu caso, não preciso fazer isso, então vou apenas comentar. A razão é que se eu for para meu cache clusterizado e para os detalhes, vamos rolar para baixo até a guia de índices de consulta aqui e você poderá ver que já adicionei todos os meus índices de consulta ao cache. Então, como os adicionei, não preciso defini-los dinamicamente.
Agora que nossos índices de consulta estão prontos, tenho este trecho de código aqui que está carregando todos os meus produtos no cache do banco de dados. Então, vou prosseguir e descomentar esse trecho de código. Perfeito!
// ------------------------Load ALL Products Into Cache------------------------
...
var products_caching_option = new CachingOptions
{
StoreAs = StoreAs.SeparateEntities
};
products_caching_option.SetAbsoluteExpiration(DateTime.Now.AddDays(10));
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}"));
});
...E tudo o que esse código está fazendo é definir que desejo colocar meus produtos em entidades separadas e adicioná-los com validade de 10 dias. Então isso CarregarIntoCache() método está carregando os produtos no cache. Agora, vamos executar isso e dar uma olhada nos resultados que ele obtém. Perfeito! Então agora, se rolarmos aqui, vamos lá! Podemos ver que carregamos todos os produtos no cache, esses 77 produtos.
E então, se pudermos ver essas solicitações que entraram no cache, essas adições que foram realizadas e essa contagem que aumentou. Se abrirmos nossas estatísticas, veremos que temos 59 itens em uma partição e 41 na outra.
Agora, vamos exportar as chaves de cache e ver os dados que temos. Perfeito! Portanto, temos 100 chaves em nosso cache e todos os produtos foram colocados nele. Perfeito! Portanto, agora que todo o nosso conjunto de dados está disponível, não preciso executar esse método novamente. Vou apenas prosseguir e comentar isso.
E agora, vamos executar o FromCacheOnly() método de extensão em nossa consulta de produtos que executamos antes. Então, eu apenas adiciono '. FromCacheOnly(). Perfeito! E agora, vamos executar a amostra e dar uma olhada nos resultados dessas buscas para nós. Perfeito! Então vamos lá, 26 resultados, os mesmos que obtivemos quando rodamos esta aplicação sem nenhum cache, o que significa um resultado completo, e podemos ver as buscas que foram realizadas e as solicitações que obtivemos no cache.
Específico do núcleo EF NCache APIs
E isso resume muito bem como você pode usar o FromCacheOnly() com o CarregarIntoCache() método de extensão. E isso nos leva ao específico do EF Core NCache APIs que você pode usar. Então, digamos, por exemplo, você não queria usar os métodos de extensão e queria trabalhar com entidades independentes onde você está criando uma entidade, persistindo-a no contexto e, em seguida, enviando-a para o cache. Bem, NCache permite que você faça isso com o Específico do EF Core NCache APIs. Portanto, a maneira como isso funciona é buscar o contexto de cache do contexto do EF Core em seu aplicativo. E então, depois de ter esse contexto de cache, você poderá usá-lo para inserir entidades no cache ou para remover entidades do cache.
Agora, isso não deve ser confundido com as APIs fornecidas no NCache SDK. Eles são específicos do Entity Framework Core e se comportam da maneira que deveriam com o Entity Framework Core. Assim, nos dados de inserção, você pode ver que inseriremos um cliente com uma chave de cache de string de saída. E esta é uma chave de cache fornecida pela API Entity Framework Core.
Agora, vamos ver como isso funciona e então poderemos ver como os itens ou entidades são persistentes no cache. Então, se rolarmos até aqui, podemos ver que posso adicionar um cliente ao cache usando o identificador de cache. Então, vou apenas descomentar este trecho de código aqui. Perfeito!
//-------------------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
};
options.SetAbsoluteExpiration(DateTime.Now.AddMinutes(10));
context.Customers.Add(cust);
context.SaveChanges(true);
cache.Insert(cust, out string cacheKey, options);
Console.WriteLine($"\n\nCustomer ID: {cust.Customerid} -> Added to Cache");Agora, se você perceber que estou simplesmente obtendo o contexto do cache, estou criando este cliente aqui. Digo que quero armazená-lo como uma entidade separada com validade de 10 minutos, aqui. Estou apenas persistindo isso dentro do meu contexto, salvando as alterações e depois realizando essa inserção de cache aqui. E então, imprimindo que adicionei esse cliente ao cache.
Agora, vamos executar o código e dar uma olhada em como isso funciona. Perfeito! Assim, podemos ver que o cliente foi adicionado ao cache. Eu só vou fechar isso. Podemos ver essa adição de 1 que foi realizada e esse aumento em nossa contagem. Então, vamos às estatísticas. Aqui vamos nós! Então podemos ver 41, e a contagem passou de 59 para 60.
Agora, vamos exportar as chaves de cache. Perfeito! Então, vamos lá! Podemos ver o cliente que foi adicionado ao cache e você pode ver que a API atribuiu a chave de cache a este item. Não precisamos especificar uma chave para adicioná-lo. Então isso é perfeito!
Agora, vamos em frente, deixe-me esclarecer isso e vamos remover esse cliente que colocamos no cache. Agora, vou apenas comentar esse trecho de código mais uma vez. Vou apenas comentar isso, vamos rolar para baixo e remover o cliente usando o identificador de cache. Então, eu tenho esse código aqui. Então, vou selecionar tudo e descomentar aqui.
//-------------------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($"\n\nCustomer ID: {customerToRemove.Customerid} -> Removed from Cache");
}
else
{
Console.WriteLine("\n\ncould not find the customer within the cache");
}E o que esse código está fazendo é obter o cache do contexto novamente e encontrar esse cliente dentro do contexto. E se esse cliente for realmente encontrado, então o que ele fará é removê-lo do contexto, salvar as alterações e, em seguida, executar este cache.Remove() para remover o cliente e, em seguida, imprimirá que é Feito assim. Caso contrário, se não conseguir encontrá-lo, apenas nos dirá que não conseguiu encontrar o cliente no cache.
Agora, vamos salvar isso, executar este aplicativo e dar uma olhada no que acontece. Perfeito! Então, encontrei o cliente e retirei-o do cache. Incrível!
Agora, vamos fechar isso e dar uma olhada na contagem, e vemos que ela caiu de 60 para 59. As estatísticas também mostram que a contagem caiu de 60 para 59. Agora, vamos exportar as chaves de cache. Devemos ver 100 chaves agora. Perfeito! Portanto, não podemos ver que o cliente que adicionamos anteriormente na contagem voltou para 100. E isso praticamente nos leva ao final desta demonstração. Muito obrigado por assistir.
Próximos Passos
Baixar NCache
Agora, como parte das próximas etapas, o que você pode fazer é, se quiser baixar NCache, você poderá obter uma avaliação gratuita de 30 dias, que fornecerá um produto totalmente funcional. Você pode fazer isso indo até alachisoft.com aqui e depois indo para o download seção daqui, e aqui você tem as ofertas que pode baixar com base em seus requisitos em sua versão .NET.
Experimente o Playground
Você pode tente o NCache recreio por 30 minutos. Isso fornece uma espécie de sessão sandbox completa, onde você pode brincar com o código e ver como os exemplos seriam executados e ter uma ideia do produto em geral.
Agende um Personalizado NCache Demo
Por último, você também pode agende um personalizado NCache demonstração onde forneceremos a você um despejo de uma hora do NCache características e quão bem funciona. Também podemos mapear o tipo de caso de uso de acordo com seus pontos problemáticos e ver como o cache funcionaria bem em seu ambiente. Então, você pode simplesmente preencher este formulário aqui e envie a solicitação. Você pode ter certeza de que conseguiremos e agendaremos a demonstração de acordo.
E isso nos leva ao final desta demonstração. Muito obrigado por assistir. Tenha um dia maravilhoso. Adeus.