O Entity Framework (EF) Core é a versão reescrita e reescrita do mecanismo de mapeamento relacional de objetos do Entity Framework para .NET Core formulários. É muito leve, extensível e multiplataforma.
No entanto, alta transação .NET Core aplicativos usando Desempenho facial do EF Core e gargalos de escalabilidade na camada de banco de dados sob cargas de pico. Isso ocorre porque, embora você possa dimensionar linearmente a camada de aplicativo adicionando mais servidores de aplicativos, não é possível incluir mais servidores de banco de dados para dimensioná-la.
Mas, se você usar um cache distribuído como NCache na sua .NET Core aplicativos, você pode remover rapidamente esses gargalos de desempenho e escalabilidade e lidar com cargas de transações extremas.
Métodos de extensão é um recurso do C# que permite estender classes e tipos existentes sem criar classes derivadas. Um Método de Extensão é um tipo especial de método estático, mas é chamado como se fosse um método de instância na classe estendida.
NCache integrou seus recursos de cache no EF Core por meio de métodos de extensão. Isso faz com que o uso NCache de dentro de um Aplicativo EF Core muito simples e direto. Abaixo está uma lista de métodos de extensão do EF Core fornecidos por NCache.
Os dados mais comuns para armazenar em cache no EF Core são os dados transacionais. Esses são os dados frequentemente alterados que são criados em tempo de execução (por exemplo, cliente, contas, atividades, etc.) e você os armazena em cache apenas por um curto período durante o qual seu aplicativo os lê várias vezes.
O método de extensão FromCache() permite armazenar em cache dados transacionais armazenando em cache o conjunto de resultados do seu consultas LINQ. Veja o exemplo abaixo.
//Load suppliers into the cache with the expiration options
IEnumerable<Suppliers> suppliers = (from supplier in database.Suppliers
where supplier.SupplierId < 10
select supplier).FromCache(options);Aqui, antes de ir ao banco de dados para buscar esses dados, o método FromCache() verifica o cache desses dados. Se encontrado, ele o retorna do cache. Caso contrário, ele o busca no banco de dados, o armazena em cache primeiro para que esteja lá na próxima vez e, em seguida, retorna os resultados para o chamador.
Você tem a opção de armazenar em cache toda a coleção como um item no cache ou separar todas as suas entidades e armazená-las em cache separadamente. A quebra é útil se você também deseja buscar ou atualizar individualmente essas entidades. Abaixo está a versão assíncrona deste método.
//Load suppliers into the cache with the expiration options asynchronously
Task<IEnumerable><Suppliers> suppliersTask = (from supplier in database.Suppliers
where supplier.SupplierId < 10
select supplier).FromCacheAsync(options);
suppliersTask.Wait();
IEnumerable<Suppliers> suppliers = suppliersTask.Result.ToList();Dados de referência são algo que você deve armazenar em cache inteiramente. Isso permite que você execute consultas LINQ apenas no cache e nunca vá para o banco de dados para isso. Observe que, se você não tiver todo o conjunto de dados no cache, os resultados da consulta LINQ estarão incorretos porque eles apenas verificam o cache e assumem que todo o conjunto de dados está no cache.
Com o método de extensão LoadIntoCache(), você pode preencher o cache do EF Core com todos os seus dados de referência. Veja o exemplo abaixo para preencher seu cache.
//Load ALL products into the cache as reference data
IEnumerable<Products> products = (from product in database.Products
select product)
.LoadIntoCache(out string cacheKey, options);Depois de carregar o cache com todos os dados de referência, você pode executar consultas LINQ nele em vez do banco de dados. Isso reduz a pressão em seu banco de dados e melhora o desempenho e a escalabilidade de seu aplicativo. Veja o exemplo abaixo.
//Query for discontinued products from the reference data cache
IEnumerable<Products> products = (from product in database.Products
where product.Discontinued == true
select product).FromCacheOnly();Observe que o cache de dados de referência do EF Core deve conter todo o conjunto de dados (por exemplo, Produtos neste caso). Caso contrário, seu método de extensão FromCacheOnly() retornará apenas o que estiver no cache, pois não verifica o banco de dados. E, isso pode estar incorreto.
Sempre que fizer alterações em suas Entidades no EF Core, você poderá atualizar o EF Core Cache com elas obtendo o identificador “Cache” e fazendo a chamada de método de atualização apropriada. Abaixo está um exemplo.
// Initialize the database context
NorthwindContext database = new NorthwindContext();
...
// Add some new entities to the database
database.Shippers.Add(shipperPandaExpress);
database.Shippers.Add(shipperTitanic);
database.SaveChanges();
Cache cache = database.GetCache();
cache.Insert(shipperPandaExpress, out cacheKey, options);
cache.Insert(shipperTitanic, out cacheKey, options);
//By obtain a Cache class handle, you can directly add, update, or remove entities from EF Core. And, then updated data shows up in your LINQ queries. This gives you a lot more control over updating entities when your modifying data yourself. Below is the interface of Cache class.
namespace Alachisoft.NCache.EntityFrameworkCore
{
public class Cache
{
public void Insert(object entity, out string cacheKey, CachingOptions options);
public void Remove(object entity);
public void Remove(string cacheKey);
public void RemoveByQueryIdentifier(Tag tag);
}
}O Entity Framework Core não vem com sua estrutura de cache (como NHibernar faz). No entanto, NCache desenvolveu uma estrutura de cache muito flexível, poderosa e muito simples para você. Você deve usá-lo pelos seguintes motivos:
Por favor, veja os detalhes de todos NCache recursos em Comparação de edições página. Leia mais sobre NCache e baixe uma avaliação completa de 30 dias do NCache nos links abaixo.