Méthodes d'extension de base EF
NCache fournit des méthodes d’extension synchrones et asynchrones pour la mise en cache des requêtes dans EF Core. Les API de synchronisation sont des méthodes d'extension pour le IQueryable
interface, tandis que les API asynchrones renvoient une instance de tâche pour ces méthodes.
Notes
Cette fonctionnalité est également disponible dans NCache Professional.
Pour utiliser les API suivantes, incluez l'espace de noms suivant dans votre application :
Alachisoft.NCache.EntityFrameworkCore
NCacheLe fournisseur de mise en cache principal Entity Framework contient les API suivantes pour la mise en cache des requêtes :
API synchrones | API asynchrones |
---|---|
FromCache |
FromCacheAsync |
LoadIntoCache |
LoadIntoCacheAsync |
FromCacheOnly |
FromCacheOnlyAsync |
FromCache
La méthode d'extension est idéale à utiliser lors de la gestion de données transactionnelles (avec des opérations de lecture et d'écriture fréquentes). Par exemple, la tenue des dossiers de vol, où chaque vol unique nécessite un enregistrement continu des nouvelles entrées dans la base de données. Alternativement, pour les données de référence (où les lectures sont plus fréquentes que les écritures), utilisez LoadIntoCache
ainsi que le FromCacheOnly
méthodes d'extension. Tout comme dans un catalogue de produits, où les produits sont traités comme des données de référence, car ils sont rarement modifiés et lus de manière cohérente à partir de la base de données. Pour utiliser ces méthodes d'extension de données de référence, vous devez définir les index de requête au sein de votre application. Cela peut être fait dynamiquement en ajoutant le [QueryIndexable]
Étiquette.
Stockage des données de cache avec EFCore
In FromCache
, LoadIntoCache
, FromCacheOnly
, et leurs homologues asynchrones, vous pouvez utiliser les requêtes de mise en cache EF Core pour stocker des données dans le cache pour les requêtes ultérieures.
Vous pouvez stocker les données dans le cache de deux manières : stocker l'intégralité de l'ensemble de données sous forme de collection sur une seule clé dans le magasin de données à l'aide de l'appel d'insertion. Vous pouvez également ajouter chaque entité séparément sur plusieurs clés en masse. Vous pouvez faire ce choix en utilisant CachingOption StoreAs
ajuster à StoreAs.Collection
or StoreAs.SeperateEntities
. Vous pouvez spécifier et activer bulkInsertChunkSize
lorsqu'il s'agit d'un nombre considérable d'entités, par exemple 100,000 XNUMX. Cela garantit que les données sont chargées dans le cache morceau par morceau, quelle que soit la taille de l'ensemble de données, ce qui rend le processus de stockage des données plus efficace et plus gérable.
Notes
Les bulkInsertChunkSize
La propriété divise la majeure partie des entités en morceaux plus petits et met à jour le cache morceau par morceau. En tant que tel, il permet à l'opération de contourner le délai d'expiration de la connexion en mettant en cache une partie des entités dans la limite de 90 secondes, l'empêchant ainsi de déclencher le jeton d'annulation. Par défaut, le bulkInsertChunkSize
est 1000.
Important
Étant donné que l'application ne reçoit une réponse qu'une fois que l'ensemble du volume est mis en cache, il est préférable d'utiliser une méthode d'extension asynchrone pour éviter tout retard important lors du traitement d'un ensemble de données volumineux.
DeCache
Les FromCache
La méthode met en cache les données du jeu de résultats générées par la requête LINQ et les renvoie à l'application. Si les données n'existent pas dans le cache, elles seront extraites de la source de données et stockées dans le cache. Si l'application refait la même requête, elle obtiendra les données nécessaires du cache, évitant ainsi un déplacement inutile vers la source de données.
Cependant, étant donné que cette méthode s'effectue à deux niveaux (obtention des données du jeu de résultats et mise à jour du cache), le risque d'échec est accru, en particulier dans ce dernier cas. Vous pouvez ne pas mettre à jour le cache pour diverses raisons. Par exemple, un échec de connexion à la base de données, une erreur réseau, le cache/le serveur est en panne, un échec de sérialisation des données, un scénario de transfert d'état, etc.
Par conséquent, NCache offre aux utilisateurs employant FromCache
des errorEnabled
indicateur qui leur permet de déterminer s’ils souhaitent arrêter l’application pour des problèmes non liés à l’ensemble de résultats. Généralement, si la mise en cache et les performances du système sont une priorité, les utilisateurs définiront cet indicateur sur True (car la requête traite la source de données à chaque fois, sinon). Cependant, si leur priorité est d’empêcher l’arrêt de l’application, les utilisateurs définiront cet indicateur sur False.
Notes
Par défaut, le errorEnabled
l’indicateur est défini sur False.
Notes
Même si l' errorEnabled
est False, ces exceptions liées à la mise à jour du cache seront enregistrées dans les journaux de cache disponibles sur %NCHome%/log-files
.
Exemples
- L'exemple suivant récupère les détails du client en fonction d'un ID client spécifié dans la base de données et les stocke en tant qu'entité distincte dans le cache avec les options de mise en cache spécifiées.
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();
}
Notes
Vous pouvez également surveiller l'activité de votre cache à l'aide du NCache Moniteur.
- L'exemple suivant renvoie la clé de cache générée en interne par rapport aux données du jeu de résultats de requête stockées en tant que collection dans le cache. Cette clé peut être enregistrée pour une utilisation future, comme la suppression de l'ensemble d'entités/résultats du 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);
}
Notes
En utilisant Exporter-CacheKeys dans l'outil de votre choix, vous pouvez visualiser les clés de cache d'un cache particulier.
Considérations relatives à FromCache
FromCache
prend en charge les fonctions suivantes :
Group By
Order By Ascending
Order By Descending
Sum
Min
Max
Average
Count
Contains
Like
FirstOrDefault
Les fonctions peuvent être implémentées en utilisant LINQ avec FromCache
, comme suit :
- Les
Like
L’opérateur dans EF Core effectue une correspondance de modèles dans les chaînes de caractères. Habituellement, il est employé avecWhere
inSELECT
instructions pour filtrer les lignes en fonction de modèles ou de sous-chaînes spécifiques dans la valeur d'une colonne. De plus, il permet l'utilisation de caractères génériques pour faire correspondre un ou plusieurs caractères dans une chaîne :
using (var context = new NorthwindContext())
{
var result = context.Customers
.Where(c => EF.Functions.Like(c.CompanyName, "Alfreds Futterkiste"))
.FromCache(options)
.ToList();
}
- Les
Contains
L'opérateur peut être utilisé de la même manière que l'opérateurLike
opérateur pour utiliser des recherches basées sur des modèles dans le cadre d'un critère donné.
using (var context = new NorthwindContext())
{
var result = context.Customers
.Where(b => (b.CompanyName.Contains("Alfreds Futterkist")))
.FromCache(out cacheKey, options)
}
- Les
FirstOrDefault
L’opérateur peut être implémenté comme démontré ci-dessous.
using (var context = new NorthwindContext())
{
var result = context.Products
.Where(b => b.UnitPrice > 1)
.FromCache(out cacheKey, options)
.FirstOrDefault();
}
- Les
GroupBy
peut être utilisé avec la projection pour FromCache comme implémenté ci-dessous.
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();
}
Charger dans le cache
Les LoadIntoCache
L'API récupère les données du jeu de résultats à partir de la source et les met en cache sans les renvoyer à l'application. Cette API permet ultérieurement FromCache
appels pour produire de nouvelles données. Le LoadIntoCache
La méthode est particulièrement adaptée aux données fréquemment mises à jour telles que les commandes des clients ou aux données sensibles telles que les détails de paiement. Dans de tels scénarios, l’utilisation de données obsolètes peut entraîner des transactions commerciales incorrectes. Par conséquent, une nouvelle copie des données doit être présente dans le cache à tout moment. Cette méthode d'extension charge votre ensemble complet de données de travail dans le cache. Ensuite, cette méthode interroge la base de données, stocke le résultat dans le cache et le renvoie à l'application.
Exemples
- L'exemple suivant récupère les commandes client de la base de données et charge les données du jeu de résultats dans le cache en tant que collection. Il renvoie également la clé de cache générée en interne qui peut être enregistrée pour une utilisation ultérieure.
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);
}
- L'exemple suivant charge les détails de commande spécifiques de la base de données dans le cache en tant qu'entités distinctes avec des options de mise en cache spécifiées.
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);
}
- Les
GroupBy
peut être utilisé avec une projection pourLoadIntoCache
tel que mis en œuvre ci-dessous.
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();
}
Vous pouvez exécuter cette méthode à intervalles réguliers chaque fois que vous prévoyez que ces données changent. Par exemple, si vous prévoyez des modifications de données d’ici une semaine, le fait de l’exécuter à nouveau après cette période garantit que les données du cache sont mises à jour.
À partir du cache uniquement
Pour les données moins fréquemment mises à jour, comme les détails des clients, les récupérer régulièrement à partir de la source de données est coûteux. FromCacheOnly
interroge les entités présentes dans le cache et n'approche en aucun cas la source de données. Essentiellement, si l'entité n'existe pas dans le cache, elle ne sera toujours pas extraite de la source de données.
Notes
Cette API ne fonctionne que lorsque les entités sont stockées séparément, c'est-à-dire l'option de mise en cache. StoreAs
est fixé à SeperateEntities
.
Important
Les entités doivent être indexées dans le NCache Management Center avant leur utilisation avec FromCacheOnly
.
- L'exemple suivant extrait les informations client du cache si le Témoignages entité existe. Sinon, le jeu de résultats renvoyé sera vide.
using (var context = new NorthwindContext())
{
var resultSet = (from cust in context.Customers
where cust.CustomerId == someCustomerId
select cust).FromCacheOnly();
}
Considérations relatives à FromCacheOnly
FromCacheOnly
prend en charge les fonctions d'agrégation. Cependant, ces fonctions mettent uniquement en cache le résultat et non les entités elles-mêmes. Ainsi, NCache Fournit le QueryDeferred
méthode qui diffère la requête afin que les entités du cache obtiennent le résultat en réponse à une requête. Pour plus de détails sur les API différées, veuillez vous référer au chapitre Interroger les API différées. FromCacheOnly
prend en charge les fonctions suivantes :
Group By
Order By Ascending
Order By Descending
Sum
Min
Max
Average
Count
Contains
Like
Gardez à l’esprit les considérations suivantes lors de l’utilisation de LINQ avec FromCacheOnly
:
À l'exception de
Count
, toutes les fonctions d'agrégation doivent avoir des valeurs entières.Count
doit être fourni avec une entité à compter.Une seule expression LINQ pour
FromCacheOnly
ne peut pas utiliser plus d’une fonction d’agrégation.Les projections dans les expressions LINQ ne peuvent être effectuées que si un
GroupBy
L'opérateur et une fonction d'agrégation sont utilisés pourFromCacheOnly
.Les projections multiples ne sont pas prises en charge. Un seul attribut peut être projeté dans une expression LINQ (qui est reporté).
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
est principalement utilisé pour les fonctions d'agrégation (regroupement du résultat des requêtes à l'aide de colonnes) et ne peut être utilisé que si la projection est terminée au préalable et qu'une fonction d'agrégation est utilisée.GroupBy
doit être le dernier opérateur de l'expression LINQ sauf siOrderBy
est utilisé. Dans de tels cas, leGroupBy
fonction peut être déplacée vers l'avant (aprèsOrderBy
) ou en arrière (avantOrderBy
).
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
(à la fois ascendant et décroissant) ne peut être utilisé que dans une expression LINQ pourFromCacheOnly
, SiGroupBy
est utilisé.Plus d'un
GroupBy
ainsi que leOrderBy
les opérateurs ne peuvent pas être utilisés dans une seule expression LINQ pourFromCacheOnly
.Les jointures ne sont pas prises en charge.
Include()
méthode ne fonctionnera pas.Pour les expressions LINQ contenant le
DateTime
instances, tous les nœuds d'un cluster de cache doivent avoir le mêmeDateTime
format mis en place. Sinon, cela entraînera une exception de format. Ce problème se pose lorsque leDateTime.Now
ainsi que leDateTime.Parse()
les méthodes sont utilisées dans un cluster de cache multi-nœuds. Pour l'éviter, synchronisez leDateTime
formater sur les deux machines. De plus, utilisezDateTime.ParseExact()
plus deDateTime.Parse()
, Que l'ParseExact()
L'API empêche l'utilisateur de spécifier un format pourDateTime
.Les
Like
L’opérateur dans EF Core effectue une correspondance de modèles dans les chaînes de caractères. Habituellement, il est employé avecWhere
inSELECT
instructions pour filtrer les lignes en fonction de modèles ou de sous-chaînes spécifiques dans la valeur d'une colonne. De plus, il permet l'utilisation de caractères génériques pour faire correspondre un ou plusieurs caractères dans une chaîne :
using (var context = new NorthwindContext())
{
var result = context.Customers
.Where(c => EF.Functions.Like(c.CompanyName, "Alfreds Futterkiste"))
.FromCacheOnly()
.ToList();
}
- Les
Contains
L'opérateur peut être utilisé de la même manière que l'opérateurLike
opérateur pour utiliser des recherches basées sur des modèles dans le cadre d'un critère donné.
using (var context = new NorthwindContext())
{
var result = context.Customers
.Where(b => (b.CompanyName.Contains("Alfreds Futterkist")))
.FromCacheOnly()
}
- Les
Contains
L’opérateur peut également être utilisé pour effectuer une recherche dans un dictionnaire.
using (var context = new NorthwindContext())
{
var customerList = new List<string> { "CustomerId", "Alfreds Futterkiste" };
var result = context.Customers
.Where(b => customerList.Contains(b.CompanyName))
.FromCacheOnly();
}
API LINQ asynchrones
Les API asynchrones ont les mêmes fonctionnalités que leurs homologues synchrones, mais avec un comportement asynchrone. Les paramètres transmis à ces méthodes sont également les mêmes.
Important
En raison de sa nature asynchrone, cacheKey
n'est renvoyé dans aucun des appels asynchrones comme FromCacheAsync
ainsi que le LoadIntoCacheAsync
- comme out
les paramètres ne sont pas autorisés avec les méthodes avec une signature asynchrone.
DeCacheAsync
Les données sont directement extraites de la base de données si l'établissement de la connexion au cache échoue. Cependant, toutes les 60 secondes après la demande, la connexion au cache est réessayée. Les requêtes suivantes tenteront de réinitialiser le cache 60 secondes après la dernière requête. Chaque fois qu'une connexion est établie avec succès, les données sont récupérées du cache.
L'exemple suivant récupère les détails du client en fonction d'un N ° de client de la base de données de manière asynchrone et les stocke en tant qu'entité distincte dans le cache avec les options de mise en cache spécifiées.
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
L'exemple suivant charge les détails de commande spécifiques de la base de données dans le cache en tant qu'entités distinctes avec les options de mise en cache spécifiées.
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
L'exemple suivant récupère les informations client uniquement à partir du cache si le Témoignages l'entité existe. Sinon, le jeu de résultats renvoyé sera vide, car la base de données est ignorée.
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();
}
Voir aussi
.RAPPORTER: Alachisoft.NCache.EntityFrameworkCore espace de noms.
.RAPPORTER: Alachisoft.NCache.Runtime.Caching espace de noms.