Implémentation du cache REDIS dans l’API .NET Core

Dans cet article, j’aborde la mise en cache et son fonctionnement dans .NET Core. Donc, nous regardons les choses suivantes une par une :

Présentation de la mise en cache
C’est quoi Cache ?
Installation du cache REDIS
Implémentation du cache

Alors, commençons!

Introduction

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. . De nombreux utilisateurs utilisent Internet, et 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. Ces choses ont besoin de solutions, c’est là que la mise en cache entre en scène.

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 :

Sans utiliser de cache.
Utiliser le cache et voir comment cela fonctionne.

Donc, si nous n’utilisons pas le cache, si les utilisateurs veulent des données, ils accéderont à la base de données à chaque fois, ce qui augmentera la complexité temporelle et réduira les performances s’il y a des données statiques que les utilisateurs veulent, et c’est la même chose pour tous les utilisateurs. Par contre, comme vous pouvez le voir, nous utilisons le cache. Dans ce cas, s’il y a le même statique et la même donnée, chaque utilisateur frappera la base de données inutile pour récupérer les données.

Types de cache

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. Il existe également de nombreux mécanismes tiers pour la mise en cache distribuée, tels que REDIS et autres. Mais dans cette section, nous examinons en détail le cache REDIS et son fonctionnement dans .NET Core.

Mise en cache distribuée

Dans la mise en cache distribuée, les données sont stockées et partagées entre plusieurs serveurs.
De plus, il est facile d’améliorer l’évolutivité et les performances de l’application après avoir géré la charge entre plusieurs serveurs lorsque nous utilisons une application multi-tenant.
Supposons qu’à l’avenir, si un serveur tombe en panne et redémarre, l’application n’a aucun impact car plusieurs serveurs répondent à nos besoins si nous le souhaitons.

REDIS est le cache le plus populaire, utilisé par de nombreuses entreprises de nos jours pour améliorer les performances et l’évolutivité de l’application. Nous allons donc discuter de REDIS et de son utilisation un par un.

Cache REDIS :

REDIS est un magasin de structure de données en mémoire open source (sous licence BSD) utilisé comme base de données.
Il est utilisé pour stocker les données fréquemment utilisées et certaines données statiques dans le cache et les utiliser et les réserver selon les besoins de l’utilisateur.
Il existe de nombreuses structures de données présentes dans le REDIS, que nous pouvons utiliser, comme la liste, l’ensemble, le hachage, le flux, et bien d’autres, pour stocker les données.

Installation du cache REDIS

Étape 1

Téléchargez le serveur REDIS à l’aide de l’URL suivante.

Étape 2

Extrayez le fichier zip et, plus tard, ouvrez le serveur REDIS et la CLI REDIS :

Implémentation du cache REDIS à l’aide de l’API .NET Core

Étape 1

Créez l’application Web de l’API .NET Core.

Étape 2

Installez les « paquets NuGet » suivants, qui doivent être intégrés étape par étape dans notre application :

Microsoft.EntityFrameworkCore
Microsoft.EntityFrameworkCore.Design
Microsoft.EntityFrameworkCore.SqlServer
Microsoft.EntityFrameworkCore.Tools
Swashbuckle.AspNetCore
StackExchange.Redis

Étape 3

Créez le « Modèle” dossier et créez-en un classe de produit à l’intérieur avec les détails suivants :

namespace RedisCacheDemo.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 le DbContextClass class pour les opérations liées à la base de données comme je le montre ci-dessous:

using Microsoft.EntityFrameworkCore;
using RedisCacheDemo.Model;
namespace RedisCacheDemo.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 un ICacheService interfaces et CacheService classe pour l’utilisation liée au cache REDIS :

using System;
namespace RedisCacheDemo.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 le CacheService classe:

using Newtonsoft.Json;
using StackExchange.Redis;
using System;
namespace RedisCacheDemo.Cache
{
    public class CacheService : ICacheService
    {
        private IDatabase _db;
        public CacheService()
        {
            ConfigureRedis();
        }
        private void ConfigureRedis()
        {
            _db = ConnectionHelper.Connection.GetDatabase();
        }
        public T GetData<T>(string key)
        {
            var value = _db.StringGet(key);
            if (!string.IsNullOrEmpty(value))
            {
                return JsonConvert.DeserializeObject<T>(value);
            }
            return default;
        }
        public bool SetData<T>(string key, T value, DateTimeOffset expirationTime)
        {
            TimeSpan expiryTime = expirationTime.DateTime.Subtract(DateTime.Now);
            var isSet =_db.StringSet(key, JsonConvert.SerializeObject(value), expiryTime);
            return isSet;
        }
        public object RemoveData(string key)
        {
            bool _isKeyExist = _db.KeyExists(key);
            if (_isKeyExist == true)
            {
                return _db.KeyDelete(key);
            }
            return false;
        }
    }
}

Étape 6

Créer le ProductController classe. Créez la méthode suivante comme indiqué ci-dessous :

using Microsoft.AspNetCore.Mvc;
using RedisCacheDemo.Cache;
using RedisCacheDemo.Data;
using RedisCacheDemo.Model;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
namespace RedisCacheDemo.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 au serveur SQL et l’URL REDIS dans le appsetting.json:

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*",
  "RedisURL": "127.0.0.1:6379",
  "ConnectionStrings": {
    "DefaultConnection": "Data Source=Server;Initial Catalog=RedisCache;User Id=sa;Password=***;"
  }
}

Étape 8

Ensuite, enregistrez le ICacheService à l’intérieur de la méthode de service configure de la classe de démarrage et ajoutez quelques …

Implémentation du cache REDIS dans l’API .NET Core

Introduction

Qu’est-ce que la mise en cache ?

Types de cache

Mise en cache distribuée

Installation du cache REDIS

Étape 1

Étape 2

Implémentation du cache REDIS à l’aide de l’API .NET Core

Étape 1

Étape 2

Étape 3

Étape 4

Étape 5

Étape 6

Étape 7

Étape 8

Leave A Reply Cancel Reply