Métodos de extensão do EF Core
NCache fornece métodos de extensão síncronos e assíncronos para armazenar consultas em cache no EF Core. As APIs de sincronização são métodos de extensão para o IQueryable
interface, enquanto as APIs assíncronas retornam uma instância de tarefa para esses métodos.
Note
Este recurso também está disponível em NCache Professional.
Para utilizar as seguintes APIs, inclua o seguinte namespace em seu aplicativo:
Alachisoft.NCache.EntityFrameworkCore
NCacheO Entity Framework Core Caching Provider do contém as seguintes APIs para consultas de cache:
APIs síncronas | APIs assíncronas |
---|---|
FromCache |
FromCacheAsync |
LoadIntoCache |
LoadIntoCacheAsync |
FromCacheOnly |
FromCacheOnlyAsync |
FromCache
O método de extensão é ideal para usar ao lidar com dados transacionais (com operações frequentes de leitura e gravação). Por exemplo, manter registros de voo, onde cada voo único requer registro contínuo de novas entradas no banco de dados. Alternativamente, para dados de referência (onde as leituras são mais frequentes que as gravações), use LoadIntoCache
e FromCacheOnly
métodos de extensão. Assim como em um catálogo de produtos, onde os produtos são tratados como dados de referência, pois raramente são modificados e lidos de forma consistente no banco de dados. Para usar esses métodos de extensão de dados de referência, você precisa definir os índices de consulta em seu aplicativo. Isso pode ser feito dinamicamente adicionando o [QueryIndexable]
tag.
Armazenando dados de cache com EFCore
In FromCache
, LoadIntoCache
, FromCacheOnly
, e suas contrapartes Async, você pode usar as consultas de cache do EF Core para armazenar dados no cache para consultas subsequentes.
Você pode armazenar os dados no cache de duas maneiras: armazenar todo o conjunto de dados como uma coleção em uma única chave no armazenamento de dados usando a chamada insert. Ou você pode adicionar cada entidade separadamente em várias chaves em massa. Você pode fazer essa escolha usando CachingOption StoreAs
definido para StoreAs.Collection
or StoreAs.SeperateEntities
. Você pode especificar e ativar bulkInsertChunkSize
ao lidar com uma quantidade considerável de entidades, por exemplo, 100,000. Isso garante que os dados sejam carregados no cache pedaço por pedaço, independentemente do tamanho do conjunto de dados, tornando o processo de armazenamento de dados mais eficiente e gerenciável.
Note
A bulkInsertChunkSize
A propriedade divide a maior parte das entidades em pedaços menores e atualiza o cache pedaço por pedaço. Como tal, permite que a operação contorne o tempo limite da conexão armazenando em cache um pedaço de entidades dentro do limite de 90 segundos, evitando que acione o token de cancelamento. Por padrão, o bulkInsertChunkSize
é 1000.
importante
Como o aplicativo só recebe uma resposta quando todo o volume é armazenado em cache, é melhor usar um método de extensão Async para evitar atrasos significativos ao lidar com um grande conjunto de dados.
Do cache
A FromCache
O método armazena em cache os dados do conjunto de resultados gerados na consulta LINQ e os retorna ao aplicativo. Se os dados não existirem no cache, eles serão buscados na fonte de dados e armazenados no cache. Se a aplicação fizer a mesma consulta novamente, ela obterá os dados necessários do cache, evitando uma viagem desnecessária à fonte de dados.
Entretanto, como esse método ocorre em dois níveis (obtenção dos dados do conjunto de resultados e atualização do cache), há uma chance maior de falha, especialmente no último caso. Você pode não conseguir atualizar o cache por vários motivos. Por exemplo, falha na conexão do banco de dados, erro de rede, cache/servidor inativo, falha na serialização dos dados, cenário de transferência de estado, etc.
Portanto, NCache fornece aos usuários que empregam FromCache
com o errorEnabled
sinalizador que permite determinar se desejam interromper o aplicativo devido a quaisquer problemas não relacionados ao conjunto de resultados. Geralmente, se o cache e o desempenho do sistema forem uma prioridade, os usuários definirão esse sinalizador como True (caso contrário, a consulta sempre lida com a fonte de dados). No entanto, se a prioridade for impedir a parada do aplicativo, os usuários definirão esse sinalizador como Falso.
Note
Por padrão, o errorEnabled
flag está definido como False.
Note
Mesmo se o errorEnabled
flag for False, essas exceções relacionadas ao cache de atualização serão registradas nos logs de cache disponíveis em %NCHome%/log-files
.
Exemplos
- O exemplo a seguir busca detalhes do cliente com base em um ID de cliente especificado do banco de dados e os armazena como uma entidade separada no cache com opções de cache especificadas.
using (var context = new NorthwindContext())
{
var options = new CachingOptions
{
StoreAs = StoreAs.SeperateEntities
};
var resultSet = (from cust in context.Customers
where cust.CustomerId == someCustomerId
select cust).FromCache(options).ToList();
}
Note
Você também pode monitorar a atividade do seu cache usando o NCache Monitor.
- O exemplo a seguir retorna a chave de cache gerada internamente em relação aos dados do conjunto de resultados da consulta armazenados como uma coleção no cache. Essa chave pode ser salva para uso futuro, como remover o conjunto de entidades/resultados do cache.
using (var context = new NorthwindContext())
{
var options = new CachingOptions
{
StoreAs = StoreAs.Collection
};
var resultSet = (from cust in context.Customers
where cust.CustomerId == someCustomerId
select cust).FromCache(out string cacheKey, options);
}
Note
Usando Exportar-CacheKeys na ferramenta de sua escolha, você pode visualizar as chaves de cache de um determinado cache.
Considerações sobre FromCache
FromCache
suporta as seguintes funções:
Group By
Order By Ascending
Order By Descending
Sum
Min
Max
Average
Count
Contains
Like
FirstOrDefault
As funções podem ser implementadas ao usar LINQ com FromCache
, do seguinte modo:
- A
Like
O operador no EF Core executa a correspondência de padrões em cadeias de caracteres. Geralmente é empregado comWhere
inSELECT
instruções para filtrar linhas com base em padrões ou substrings específicos dentro do valor de uma coluna. Além disso, permite o uso de curingas para corresponder a um ou mais caracteres em uma string:
using (var context = new NorthwindContext())
{
var result = context.Customers
.Where(c => EF.Functions.Like(c.CompanyName, "Alfreds Futterkiste"))
.FromCache(options)
.ToList();
}
- A
Contains
operador pode ser usado de forma semelhante aoLike
operador para empregar pesquisas baseadas em padrões dentro de um determinado critério.
using (var context = new NorthwindContext())
{
var result = context.Customers
.Where(b => (b.CompanyName.Contains("Alfreds Futterkist")))
.FromCache(out cacheKey, options)
}
- A
FirstOrDefault
operador pode ser implementado conforme demonstrado abaixo.
using (var context = new NorthwindContext())
{
var result = context.Products
.Where(b => b.UnitPrice > 1)
.FromCache(out cacheKey, options)
.FirstOrDefault();
}
- A
GroupBy
pode ser usado com projeção para FromCache conforme implementado abaixo.
using (var context = new NorthwindContext())
{
var resultSet = context.Products
.Where(p => p.UnitPrice == 10)
.GroupBy(p => p.ProductName)
.Select(group => group.Key)
.FromCache(out cacheKey, options)
.ToList();
}
CarregarIntoCache
A LoadIntoCache
A API busca os dados do conjunto de resultados da origem e os armazena em cache sem retorná-los ao aplicativo. Esta API permite subseqüentes FromCache
chamadas para produzir dados novos. O LoadIntoCache
O método é particularmente adequado para dados atualizados com frequência, como pedidos de clientes, ou dados confidenciais, como detalhes de pagamento. Nesses cenários, o uso de dados obsoletos pode resultar em transações comerciais incorretas; portanto, uma nova cópia dos dados deve estar sempre presente no cache. Este método de extensão carrega seu conjunto completo de dados de trabalho no cache. Em seguida, esse método consulta o banco de dados, armazena o resultado no cache e o retorna para a aplicação.
Exemplos
- O exemplo a seguir busca os pedidos dos clientes no banco de dados e carrega os dados do conjunto de resultados no cache como uma coleção. Ele também retorna a chave de cache gerada internamente, que pode ser salva para uso futuro.
using (var context = new NorthwindContext())
{
var options = new CachingOptions
{
StoreAs = StoreAs.Collection
};
var resultSet = (from custOrder in context.Orders
where custOrder.Customer.CustomerId == someCustomerId
select custOrder).LoadIntoCache(out string cacheKey, options);
}
- O exemplo a seguir carrega os detalhes específicos do pedido do banco de dados no cache como entidades separadas com opções de cache especificadas.
using (var context = new NorthwindContext())
{
var options = new CachingOptions
{
StoreAs = StoreAs.SeperateEntities
};
var resultSet = (from custOrder in context.Orders
where custOrder.Customer.CustomerId == someCustomerId
select custOrder).LoadIntoCache(options);
}
- A
GroupBy
pode ser usado com projeção paraLoadIntoCache
conforme implementado abaixo.
using (var context = new NorthwindContext())
{
var resultSet = context.Products
.Where(p => p.UnitPrice == 10)
.GroupBy(p => p.ProductName)
.Select(group => group.Key)
.LoadIntoCache(out cacheKey, options)
.ToList();
}
Você pode executar esse método em intervalos regulares sempre que esperar que os dados sejam alterados. Por exemplo, se você prevê modificações nos dados dentro de uma semana, executá-lo novamente após esse período garante que os dados no cache sejam atualizados.
Somente do Cache
Para dados que são atualizados com menos frequência, como detalhes do cliente, buscá-los regularmente na fonte de dados é caro. FromCacheOnly
consulta as entidades presentes no cache e em nenhum caso se aproxima da fonte de dados. Essencialmente, se a entidade não existir no cache, ela ainda não será buscada na fonte de dados.
Note
Esta API só funciona quando as entidades são armazenadas separadamente, ou seja, a opção de cache StoreAs
está definido para SeperateEntities
.
importante
As entidades devem ser indexadas no NCache Management Center antes de serem usados com FromCacheOnly
.
- O exemplo a seguir busca as informações do cliente do cache se o Experiência e dinâmica de loja entidade existe. Caso contrário, o conjunto de resultados retornado estará vazio.
using (var context = new NorthwindContext())
{
var resultSet = (from cust in context.Customers
where cust.CustomerId == someCustomerId
select cust).FromCacheOnly();
}
Considerações sobre FromCacheOnly
FromCacheOnly
suporta funções agregadas. No entanto, essas funções armazenam em cache apenas o resultado e não as próprias entidades. Por isso, NCache fornece o QueryDeferred
método que adia a consulta para que as entidades no cache obtenham o resultado em resposta a uma consulta. Para mais detalhes sobre APIs diferidas, consulte o capítulo APIs adiadas de consulta. FromCacheOnly
suporta as seguintes funções:
Group By
Order By Ascending
Order By Descending
Sum
Min
Max
Average
Count
Contains
Like
Tenha em mente as seguintes considerações ao usar o LINQ com FromCacheOnly
:
Exceto por
Count
, todas as funções agregadas devem ter valores inteiros.Count
precisa ser fornecido com uma entidade para contar.Uma única expressão LINQ para
FromCacheOnly
não pode usar mais de uma função agregada.Projeções em expressões LINQ só podem ser realizadas se um
GroupBy
operador e uma função agregada são usados paraFromCacheOnly
.Múltiplas projeções não são suportadas. Apenas um atributo pode ser projetado em uma expressão LINQ (que é transportado).
using (var context = new NorthwindContext())
{
var result = context.Employees
.Select(e => e.EmployeeId) // Multiple projections have not been performed
.GroupBy(eid => eid) // eId was projected so GroupBy had to be used
.DeferredMin() // MIN provided with a numeric attribute
.FromCacheOnly();
}
GroupBy
é usado principalmente para agregar funções (agrupando o resultado de consultas usando colunas) e só pode ser usado se a projeção for concluída previamente e uma função agregada for usada.GroupBy
tem que ser o último operador na expressão LINQ, exceto seOrderBy
é usado. Nesses casos, oGroupBy
função pode ser deslocada para a frente (apósOrderBy
) ou para trás (antesOrderBy
).
using (var context = new NorthwindContext())
{
var result = context.Products
.Where(data => data.ProductName == "Tofu")
.GroupBy(data => new { data.ProductName})
.Select(group => new
{
_String = group.Key.ProductName,
Count = group.Count()
})
.FromCacheOnly();
}
OrderBy
(crescente e decrescente) só pode ser usado em uma expressão LINQ paraFromCacheOnly
, SeGroupBy
é usado.Mais de um
GroupBy
eOrderBy
operadores não podem ser usados em uma única expressão LINQ paraFromCacheOnly
.As junções não são suportadas, então o
Include()
método não funcionará.Para expressões LINQ contendo o
DateTime
instâncias, todos os nós em um cluster de cache devem ter o mesmoDateTime
formato configurado. Caso contrário, resultará em uma exceção de formato. Este problema surge quando oDateTime.Now
eDateTime.Parse()
métodos são usados em um cluster de cache de vários nós. Para evitá-lo, sincronize oDateTime
formato em ambas as máquinas. Além disso, useDateTime.ParseExact()
Acima deDateTime.Parse()
, Como oParseExact()
A API restringe o usuário de especificar um formato paraDateTime
.A
Like
O operador no EF Core executa a correspondência de padrões em cadeias de caracteres. Geralmente é empregado comWhere
inSELECT
instruções para filtrar linhas com base em padrões ou substrings específicos dentro do valor de uma coluna. Além disso, permite o uso de curingas para corresponder a um ou mais caracteres em uma string:
using (var context = new NorthwindContext())
{
var result = context.Customers
.Where(c => EF.Functions.Like(c.CompanyName, "Alfreds Futterkiste"))
.FromCacheOnly()
.ToList();
}
- A
Contains
operador pode ser usado de forma semelhante aoLike
operador para empregar pesquisas baseadas em padrões dentro de um determinado critério.
using (var context = new NorthwindContext())
{
var result = context.Customers
.Where(b => (b.CompanyName.Contains("Alfreds Futterkist")))
.FromCacheOnly()
}
- A
Contains
O operador também pode ser usado para pesquisar em um dicionário.
using (var context = new NorthwindContext())
{
var customerList = new List<string> { "CustomerId", "Alfreds Futterkiste" };
var result = context.Customers
.Where(b => customerList.Contains(b.CompanyName))
.FromCacheOnly();
}
APIs LINQ assíncronas
As APIs assíncronas possuem a mesma funcionalidade que suas contrapartes síncronas, mas com comportamento assíncrono. Os parâmetros passados para esses métodos também são os mesmos.
importante
Devido à sua natureza assíncrona, cacheKey
não é retornado em nenhuma das chamadas assíncronas como FromCacheAsync
e LoadIntoCacheAsync
- Como out
parâmetros não são permitidos com métodos com assinatura assíncrona.
FromCacheAsync
Os dados serão obtidos diretamente do banco de dados se o estabelecimento da conexão de cache falhar. No entanto, a cada 60 segundos após a solicitação ser feita, a conexão do cache é tentada novamente. As solicitações subsequentes tentarão reinicializar o cache após 60 segundos da última solicitação. Sempre que uma conexão é estabelecida com sucesso, os dados são obtidos do cache.
O exemplo a seguir busca detalhes do cliente com base em um determinado Identificação do Cliente do banco de dados de forma assíncrona e os armazena como uma entidade separada no cache com opções de cache especificadas.
using (var context = new NorthwindContext())
{
var options = new CachingOptions
{
StoreAs = StoreAs.SeperateEntities
};
var task = (from cust in context.Customers
where cust.CustomerId == someCustomerId
select cust).FromCacheAsync(options);
task.Wait();
var resultSet = task.Result.ToList();
}
LoadIntoCacheAsync
O exemplo a seguir carrega detalhes específicos do pedido do banco de dados no cache como entidades separadas com as opções de cache especificadas.
using (var context = new NorthwindContext())
{
var options = new CachingOptions
{
StoreAs = StoreAs.SeperateEntities
};
var task = (from custOrder in context.Orders
where custOrder.Customer.CustomerId == someCustomerId
select custOrder).LoadIntoCacheAsync(options);
task.Wait();
var resultSet = task.Result.ToList();
}
FromCacheOnlyAsync
O exemplo a seguir busca as informações do cliente somente no cache se o Experiência e dinâmica de loja entidade existe. Caso contrário, o conjunto de resultados retornado estará vazio, pois o banco de dados será ignorado.
using (var context = new NorthwindContext())
{
var options = new CachingOptions
{
StoreAs = StoreAs.SeperateEntities
};
var task = (from cust in context.Customers
where cust.CustomerId == someCustomerId
select cust).FromCacheOnlyAsync();
task.Wait();
var resultSet = task.Result.ToList();
}
Veja também
.INTERNET: Alachisoft.NCache.EntityFrameworkCore espaço para nome.
.INTERNET: Alachisoft.NCache.Runtime.Cache espaço para nome.