La mise en cache est très populaire de nos jours dans l’industrie du logiciel car elle améliore les performances et l’évolutivité de l’application, comme nous le voyons avec de nombreuses applications Web telles que la messagerie électronique et Facebook, ainsi que leur réactivité et la qualité de l’expérience utilisateur lors de leur utilisation. . C’est parce qu’il y a beaucoup d’utilisateurs qui utilisent Internet. Donc, si une application a un trafic réseau et une demande énormes, nous devons nous occuper de beaucoup de choses qui nous aident à améliorer les performances et la réactivité de l’application. Donc, à cause de cela, l’une des solutions est la mise en cache, et c’est pourquoi la mise en cache entre en jeu.
Qu’est-ce que la mise en cache ?
Le cache est le stockage de mémoire utilisé pour stocker les données d’accès fréquent dans le stockage temporaire ; cela améliorera considérablement les performances, évitera les accès inutiles à la base de données et stockera les données fréquemment utilisées dans la mémoire tampon chaque fois que nous en aurons besoin.
Comme vous le voyez dans l’image ci-dessus, il existe deux scénarios : un sans utiliser de cache et un autre avec cache et son fonctionnement. Donc ici, quand on n’utilise pas le cache, dans ce cas, supposons que les utilisateurs veuillent des données. Ils frapperont chaque fois la base de données, augmentant la complexité temporelle et réduisant les performances au cas où les utilisateurs souhaiteraient des données statiques. C’est le même pour tous les utilisateurs ; dans ce cas, lorsque nous n’utilisons pas le cache, chacun accède à la base de données inutile pour récupérer les données de l’autre côté. Comme vous pouvez le voir, nous utilisons le cache. Dans ce cas, s’il existe les mêmes données statiques et identiques pour tous les utilisateurs, seul le premier utilisateur accédera à la base de données, récupérera les données et les stockera dans la mémoire cache. Ensuite, les deux autres utilisateurs l’utiliseront à partir du cache sans toucher inutilement à la base de données pour récupérer les données.
Types de cache
Fondamentalement, il existe deux types de mise en cache prises en charge par .NET Core :
- Mise en cache en mémoire
- Mise en cache distribuée
Lorsque nous utilisons la mise en cache en mémoire, les données sont stockées dans la mémoire du serveur d’application, et chaque fois que nous en avons besoin, nous les récupérons à partir de là et les utilisons là où nous en avons besoin. Et dans la mise en cache distribuée, il existe de nombreux mécanismes tiers comme REDIS et bien d’autres. Mais dans cette section, nous examinons en détail le cache en mémoire et son fonctionnement dans .NET Core.
Cache en mémoire
Fondamentalement, le cache en mémoire est utilisé pour les applications légères et petites, et cela fonctionnera bien dans ce domaine. Il stocke les données dans la mémoire du serveur côté application, et les utilisateurs l’utilisent chaque fois qu’ils en ont besoin.
Avantages du cache en mémoire
- Les utilisateurs récupèrent rapidement les données lorsque nous utilisons le cache en mémoire.
- Cela augmentera les performances de l’application.
- Idéal pour les petites applications déployées sur un seul serveur.
Inconvénients du cache en mémoire
- Parfois, le cache en mémoire augmente la maintenance de l’application
- Dans le cache en mémoire, les données sont conservées sur un seul serveur, et si le serveur tombe en panne, les données sont également perdues ; il est difficile de faire évoluer l’application dans certains scénarios.
Nous allons maintenant créer une API .NET Core, y implémenter la mise en cache et comprendre comment les choses vont fonctionner.
Étape 1
Créez l’application Web de l’API .NET Core.
Étape 2
Installez les packages NuGet suivants, qui nécessitent étape par étape dans notre application.
Microsoft.EntityFrameworkCore
Microsoft.EntityFrameworkCore.Design
Microsoft.EntityFrameworkCore.SqlServer
Microsoft.EntityFrameworkCore.Tools
Swashbuckle.AspNetCore
System.Runtime.CachingÉtape 3
Créez le dossier Modèle et créez une classe de produits à l’intérieur avec des détails.
namespace MemoryCacheDemo.Model
{
public class Product
{
public int ProductId { get; set; }
public string ProductName { get; set; }
public string ProductDescription { get; set; }
public int Stock { get; set; }
}
}Étape 4
Ensuite, créez la classe DbContextClass pour les opérations liées à la base de données, comme je l’ai montré ci-dessous.
using MemoryCacheDemo.Model;
using Microsoft.EntityFrameworkCore;
namespace MemoryCacheDemo.Data
{
public class DbContextClass: DbContext
{
public DbContextClass(DbContextOptions<DbContextClass> options) : base(options)
{
}
public DbSet<Product> Products { get; set; }
}
}Étape 5
Maintenant, nous allons créer l’interface ICacheService et la classe CacheService pour une utilisation liée au cache en mémoire.
using System;
using System.Collections.Generic;
namespace MemoryCacheDemo.Cache
{
public interface ICacheService
{
/// <summary>
/// Get Data using key
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <returns></returns>
T GetData<T>(string key);
/// <summary>
/// Set Data with Value and Expiration Time of Key
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="key"></param>
/// <param name="value"></param>
/// <param name="expirationTime"></param>
/// <returns></returns>
bool SetData<T>(string key, T value, DateTimeOffset expirationTime);
/// <summary>
/// Remove Data
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
object RemoveData(string key);
}
}Ensuite, créez un service de cache.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Caching;
namespace MemoryCacheDemo.Cache
{
public class CacheService : ICacheService
{
ObjectCache _memoryCache = MemoryCache.Default;
public T GetData<T>(string key)
{
try
{
T item = (T)_memoryCache.Get(key);
return item;
}
catch (Exception e)
{
throw;
}
}
public bool SetData<T>(string key, T value, DateTimeOffset expirationTime)
{
bool res = true;
try
{
if (!string.IsNullOrEmpty(key))
{
_memoryCache.Set(key, value, expirationTime);
}
}
catch (Exception e)
{
throw;
}
return res;
}
public object RemoveData(string key)
{
try
{
if (!string.IsNullOrEmpty(key))
{
return _memoryCache.Remove(key);
}
}
catch(Exception e)
{
throw;
}
return false;
}
}
}Étape 6
Créez la classe ProductController et créez la méthode suivante, comme indiqué ci-dessous.
using MemoryCacheDemo.Cache;
using MemoryCacheDemo.Data;
using MemoryCacheDemo.Model;
using Microsoft.AspNetCore.Mvc;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
namespace MemoryCacheDemo.Controllers
{
[Route("api/[controller]")]
[ApiController]
public class ProductController : ControllerBase
{
private readonly DbContextClass _dbContext;
private readonly ICacheService _cacheService;
public ProductController(DbContextClass dbContext, ICacheService cacheService)
{
_dbContext = dbContext;
_cacheService = cacheService;
}
[HttpGet("products")]
public IEnumerable<Product> Get()
{
var cacheData = _cacheService.GetData<IEnumerable<Product>>("product");
if (cacheData!=null)
{
return cacheData;
}
var expirationTime = DateTimeOffset.Now.AddMinutes(5.0);
cacheData = _dbContext.Products.ToList();
_cacheService.SetData<IEnumerable<Product>>("product", cacheData, expirationTime);
return cacheData;
}
[HttpGet("product")]
public Product Get(int id)
{
Product filteredData;
var cacheData = _cacheService.GetData<IEnumerable<Product>>("product");
if (cacheData != null)
{
filteredData = cacheData.Where(x => x.ProductId == id).FirstOrDefault();
return filteredData;
}
filteredData = _dbContext.Products.Where(x => x.ProductId == id).FirstOrDefault();
return filteredData;
}
[HttpPost("addproduct")]
public async Task<Product> Post(Product value)
{
var obj = await _dbContext.Products.AddAsync(value);
_cacheService.RemoveData("product");
_dbContext.SaveChanges();
return obj.Entity;
}
[HttpPut("updateproduct")]
public void Put(Product product)
{
_dbContext.Products.Update(product);
_cacheService.RemoveData("product");
_dbContext.SaveChanges();
}
[HttpDelete("deleteproduct")]
public void Delete(int Id)
{
var filteredData = _dbContext.Products.Where(x => x.ProductId == Id).FirstOrDefault();
_dbContext.Remove(filteredData);
_cacheService.RemoveData("product");
_dbContext.SaveChanges();
}
}
}Étape 7
Ajoutez la chaîne de connexion SQL Server dans appsetting.json.
{
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft": "Warning",
"Microsoft.Hosting.Lifetime": "Information"
}
},
"AllowedHosts": "*",
"ConnectionStrings": {
"DefaultConnection": "Data Source=server;Initial Catalog=MemoryCache;User Id=****;Password=***;"
}
}Étape 8
Ensuite, enregistrez ICacheService dans la méthode Configure Service de la classe de démarrage et ajoutez également une configuration liée à Swagger pour tester nos points de terminaison API.
using MemoryCacheDemo.Cache;
using MemoryCacheDemo.Data;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.EntityFrameworkCore;
using...