Implémenter Le Cache En Mémoire Dans L'API .NET Core

Nous allons discuter de la mise en cache dans .NET Core et de son fonctionnement. Donc, nous regardons les choses suivantes une par une.

  • Présentation de la mise en cache
  • Qu'est-ce que le cache
  • Types de cache
  • Implémentation du cache

Alors, commençons un par un.

Introduction

La mise en cache est très populaire de nos jours dans l'industrie du logiciel car elle améliorera les performances et l'évolutivité de l'application, car nous utilisons et voyons de nombreuses applications Web comme G-mail et Facebook et leur réactivité et une excellente expérience utilisateur lorsque nous les utilisons. 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. 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équentes dans le stockage temporaire, il améliorera considérablement les performances et évitera les accès inutiles à la base de données et stockera les données fréquemment utilisées dans le tampon chaque fois que nous en aurons besoin.

Comme vous le voyez dans l'image ci-dessus, il existe deux scénarios, l'un sans utiliser de cache et l'autre avec cache et son fonctionnement. Donc, ici, lorsque nous n'utilisons pas le cache, dans ce cas, supposons que les utilisateurs veulent des données, ils accéderont à chaque fois à la base de données, ce qui augmentera la complexité temporelle et réduira les performances. Dans le cas où les utilisateurs veulent des données statiques et que c'est la même chose 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 des données. Et de l'autre côté, comme vous pouvez le voir si nous utilisons le cache et 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, puis autre deux utilisateurs l'utilisent à partir du cache sans accéder inutilement à la base de données pour récupérer des données.

Types de cache

Fondamentalement, il existe deux types de prise en charge de la mise en cache de .NET Core

  1. Mise en cache en mémoire
  2. Mise en cache distribuée

Lorsque nous utilisons le cache en mémoire, dans ce cas, les données sont stockées dans la mémoire du serveur d'applications et chaque fois que nous en avons besoin, nous récupérons les données et les utilisons partout 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 que le besoin s'en fait sentir.

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 perdues. Il est également 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éer 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.EntityFrameworkCoreMicrosoft.EntityFrameworkCore
  • Microsoft.EntityFrameworkCore.DesignMicrosoft.EntityFrameworkCore.Design
  • Microsoft.EntityFrameworkCore.SqlServerMicrosoft.EntityFrameworkCore.SqlServer
  • Microsoft.EntityFrameworkCore.Tools
  • Swashbuckle.AspNetCore
  • Système.Runtime.CachingSystem.Runtime.CachingSystem.Runtime.CachingSystem.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);
    }
}
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, 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 Startup Class 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 Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.OpenApi.Models;
namespace MemoryCacheDemo {
    public class Startup {
        public Startup(IConfiguration configuration) {
            Configuration = configuration;
        }
        public IConfiguration Configuration {
            get;
        }
        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services) {
            services.AddControllers();
            services.AddScoped < ICacheService, CacheService > ();
            services.AddDbContext < DbContextClass > (options => options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
            services.AddSwaggerGen(c => {
                c.SwaggerDoc("v1", new OpenApiInfo {
                    Title = "MemoryCacheDemo", Version = "v1"
                });
            });
        }
        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env) {
            if (env.IsDevelopment()) {
                app.UseDeveloperExceptionPage();
                app.UseSwagger();
                app.UseSwaggerUI(c => c.SwaggerEndpoint("/swagger/v1/swagger.json", "MemoryCacheDemo v1"));
            }
            app.UseHttpsRedirection();
            app.UseRouting();
            app.UseAuthorization();
            app.UseEndpoints(endpoints => {
                endpoints.MapControllers();
            });
        }
    }
}

Étape 9

Effectuez la migration et la mise à jour de la base de données pour la création de la base de données à l'aide des commandes suivantes dans la console du gestionnaire de packages.

add-migration "FirstMigration"

mise à jour de la base de données

Ainsi, lorsque vous entrez et exécutez cette commande, elle génère peu de choses liées à la migration et crée la base de données à l'intérieur de SQL Server comme vous l'avez mis à l'intérieur de la chaîne de connexion dans le appsetting.json

Étape 10

Enfin, exécutez l'application et ajoutez les données à l'aide de l'interface utilisateur swagger, puis vérifiez le fonctionnement de la mise en cache dans les produits et le point de terminaison du produit.

Fondamentalement, j'ai ajouté du cache dans les points de terminaison du produit et des produits dans le contrôleur, comme vous le voyez lorsque l'utilisateur veut récupérer les données de tous les produits, puis il vérifiera d'abord si les données sont présentes dans le cache en mémoire ou non et si c'est présent à l'intérieur du cache, puis renvoyez ces données à l'utilisateur et si les données ne sont pas présentes dans le cache, il récupérera les données de la base de données et les placera également dans le cache. Ainsi, la prochaine fois, l'utilisateur obtiendra cela uniquement à partir du cache et évitera d'accéder inutilement à la base de données 

De plus, lorsque l'utilisateur souhaite récupérer des données à l'aide de l'identifiant du produit, comme vous le voyez dans le contrôleur du deuxième point de terminaison du produit, nous récupérons les données du cache de tous les produits, puis les filtrons à l'aide de l'identifiant du produit et, si celui-ci est présent, revenons à l'utilisateur à partir du cache et si pas ensuite récupérer de la base de données et revenir à l'utilisateur après avoir appliqué le filtre.

Ainsi, comme vous le voyez à l'intérieur de la mise à jour, de la suppression et de la publication du point de terminaison du contrôleur de produit, nous utilisons la méthode de suppression pour supprimer les données de la clé de produit qui sont présentes dans le cache. Ainsi, il existe de nombreux scénarios et utilisations de caches mémoire que vous pouvez utiliser selon vos besoins et vos exigences. Je veux juste présenter les bases du cache mémoire et son fonctionnement à l'intérieur du .NET Core que j'ai couvert ici.

De plus, il y a un scénario dont vous devez vous occuper lors de l'utilisation de la mise en cache comme supposons, il y a deux utilisateurs qui utilisent votre application, alors les scénarios suivants viendront

  • Lorsque le premier utilisateur envoie la demande pour récupérer les données de tous les produits, la première demande arrive, puis il vérifiera si les données sont présentes dans le cache ou non et si les données sont présentes dans le cache, alors il récupérera les données de la base de données et définissez-le également dans le cache.
  • Pendant ce temps, le deuxième utilisateur envoie la demande pour obtenir les détails du produit, puis la demande accède également à la base de données avant de terminer la demande du premier utilisateur et, à cause de ce deuxième utilisateur, accède également à la base de données pour récupérer les détails du produit.
  • Donc, il existe une solution pour cela d'utiliser le mécanisme de verrouillage comme indiqué ci-dessous

Ajoutez créer un objet de verrouillage en haut de la classe puis dans la méthode comme je l'ai montré ci-dessous

private static object _lock = new object();
public IEnumerable < Product > Get() {
    var cacheData = _cacheService.GetData < IEnumerable < Product >> ("product");
    if (cacheData != null) {
        return cacheData;
    }
    lock(_lock) {
        var expirationTime = DateTimeOffset.Now.AddMinutes(5.0);
        cacheData = _dbContext.Products.ToList();
        _cacheService.SetData < IEnumerable < Product >> ("product", cacheData, expirationTime);
    }
    return cacheData;
}

Donc, ici, comme vous le voyez d'abord, nous vérifions si les données sont présentes dans le cache ou non si les données sont disponibles, puis nous les renvoyons. Ensuite, si la valeur n'est pas présente dans le cache mémoire, nous appliquons le verrou là-bas, puis la demande est verrouillée et entrée dans la section et récupère les détails du produit dans la base de données, puis la définit également dans le cache, puis retourner les données. Ainsi, lorsque le deuxième utilisateur envoie une demande avant que la demande de l'utilisateur ne soit terminée. Ainsi, dans ce cas, la deuxième demande est dans la file d'attente et après avoir terminé la première demande de l'utilisateur, la deuxième demande entre en ligne de compte

Il s'agit du cache en mémoire dans .NET Core. J'espère que vous comprenez les choses liées à cela.

Bon codage !

Source : https://www.c-sharpcorner.com/article/implement-in-memory-cache-in-the-net-core-api/

  #aspdotnet #api #csharp #dotnet 

What is GEEK

Buddha Community

Implémenter Le Cache En Mémoire Dans L'API .NET Core
Einar  Hintz

Einar Hintz

1602560783

jQuery Ajax CRUD in ASP.NET Core MVC with Modal Popup

In this article, we’ll discuss how to use jQuery Ajax for ASP.NET Core MVC CRUD Operations using Bootstrap Modal. With jQuery Ajax, we can make HTTP request to controller action methods without reloading the entire page, like a single page application.

To demonstrate CRUD operations – insert, update, delete and retrieve, the project will be dealing with details of a normal bank transaction. GitHub repository for this demo project : https://bit.ly/33KTJAu.

Sub-topics discussed :

  • Form design for insert and update operation.
  • Display forms in modal popup dialog.
  • Form post using jQuery Ajax.
  • Implement MVC CRUD operations with jQuery Ajax.
  • Loading spinner in .NET Core MVC.
  • Prevent direct access to MVC action method.

Create ASP.NET Core MVC Project

In Visual Studio 2019, Go to File > New > Project (Ctrl + Shift + N).

From new project window, Select Asp.Net Core Web Application_._

Image showing how to create ASP.NET Core Web API project in Visual Studio.

Once you provide the project name and location. Select Web Application(Model-View-Controller) and uncheck HTTPS Configuration. Above steps will create a brand new ASP.NET Core MVC project.

Showing project template selection for .NET Core MVC.

Setup a Database

Let’s create a database for this application using Entity Framework Core. For that we’ve to install corresponding NuGet Packages. Right click on project from solution explorer, select Manage NuGet Packages_,_ From browse tab, install following 3 packages.

Showing list of NuGet Packages for Entity Framework Core

Now let’s define DB model class file – /Models/TransactionModel.cs.

public class TransactionModel
{
    [Key]
    public int TransactionId { get; set; }

    [Column(TypeName ="nvarchar(12)")]
    [DisplayName("Account Number")]
    [Required(ErrorMessage ="This Field is required.")]
    [MaxLength(12,ErrorMessage ="Maximum 12 characters only")]
    public string AccountNumber { get; set; }

    [Column(TypeName ="nvarchar(100)")]
    [DisplayName("Beneficiary Name")]
    [Required(ErrorMessage = "This Field is required.")]
    public string BeneficiaryName { get; set; }

    [Column(TypeName ="nvarchar(100)")]
    [DisplayName("Bank Name")]
    [Required(ErrorMessage = "This Field is required.")]
    public string BankName { get; set; }

    [Column(TypeName ="nvarchar(11)")]
    [DisplayName("SWIFT Code")]
    [Required(ErrorMessage = "This Field is required.")]
    [MaxLength(11)]
    public string SWIFTCode { get; set; }

    [DisplayName("Amount")]
    [Required(ErrorMessage = "This Field is required.")]
    public int Amount { get; set; }

    [DisplayFormat(DataFormatString = "{0:MM/dd/yyyy}")]
    public DateTime Date { get; set; }
}

C#Copy

Here we’ve defined model properties for the transaction with proper validation. Now let’s define  DbContextclass for EF Core.

#asp.net core article #asp.net core #add loading spinner in asp.net core #asp.net core crud without reloading #asp.net core jquery ajax form #asp.net core modal dialog #asp.net core mvc crud using jquery ajax #asp.net core mvc with jquery and ajax #asp.net core popup window #bootstrap modal popup in asp.net core mvc. bootstrap modal popup in asp.net core #delete and viewall in asp.net core #jquery ajax - insert #jquery ajax form post #modal popup dialog in asp.net core #no direct access action method #update #validation in modal popup

Einar  Hintz

Einar Hintz

1602564619

MVC User Registration & Login with ASP.NET Core Identity

User registration and authentication are mandatory in any application when you have little concern about privacy. Hence all most all application development starts with an authentication module. In this article, we will discuss the quickest way to use **ASP.NET Core Identity for User Login and Registration **in a new or existing MVC application.

Sub-topics discussed :

  • How to add ASP.NET Core Identity to MVC application.
  • Customize ASP.NET Core Identity.
  • Identity.UI Design Customization.
  • Next step.

Background

ASP.NET Core Identity is an API, which provides both user interface(UI) and functions for user authentication, registration, authorization, etc. Modules/ APIs like this will really be helpful and fasten the development process. It comes with ASP.NET Core Framework and used in many applications before. Which makes the API more dependable and trustworthy.

ASP.NET Core MVC with user authentication can easily be accomplished using Identity.UI. While creating the MVC project, you just need to select Authentication as Individual User Accounts.

Showing how to create an MVC application with ASP.NET Core Identity API

The rest will be handled by ASP.NET Core Identity UI. It already contains razor view pages and backend codes for an authentication system. But that’s not what we want in most of the cases. we want to customize ASP.NET Core Identity as per our requirement. That’s what we do here.

Create an ASP.NET Core MVC Project

First of all, I will create a brand new ASP.NET Core MVC application without any authentication selected. We could add ASP.NET Core Identity later into the project.

In Visual Studio 2019, Go to File > New > Project (Ctrl + Shift + N). From new project window, select ASP.NET Core Web Application.

Create an ASP.NET Core Web application

Once you provide the project name and location. A new window will be opened as follows, Select _Web Application(Model-View-Controller), _uncheck _HTTPS Configuration _and DO NOT select any authentication method. Above steps will create a brand new ASP.NET Core MVC project.

Select Model View Controller templet under .NET Core

#asp.net core article #asp.net core #add asp.net core identity to existing project #asp.net core identity in mvc #asp.net core mvc login and registration #login and logout in asp.net core

Authorization in asp.net core

#Asp.net core #Asp.net core mvc #Core #Asp.net core tutorials #Asp.net core with entity framework

AllowAnonymous in asp.net core

#Asp.net core #Asp.net core mvc #Core #Asp.net core tutorials #Asp.net core with entity framework

Creating roles in asp net core

#Asp.net core #Asp.net core mvc #Core #Asp.net core tutorials #Asp.net core with entity framework