Implementar Caché En Memoria En La API De .NET Core

Vamos a discutir el almacenamiento en caché en .NET Core y cómo funciona. Entonces, miramos las siguientes cosas una por una.

  • Introducción del almacenamiento en caché
  • ¿Qué es el caché?
  • Tipos de caché
  • Implementación de caché

Entonces, comencemos uno por uno.

Introducción

El almacenamiento en caché es muy popular hoy en día en la industria del software porque mejorará el rendimiento y la escalabilidad de la aplicación, ya que usamos y vemos muchas aplicaciones web como G-mail y Facebook y cuán receptivas son y una gran experiencia de usuario mientras las usamos. Hay muchos usuarios que usan Internet y si una aplicación tiene un gran tráfico y demanda en la red, debemos ocuparnos de muchas cosas que nos ayudan a mejorar el rendimiento y la capacidad de respuesta de la aplicación. Entonces, debido a eso, una de las soluciones es el almacenamiento en caché y es por eso que el almacenamiento en caché entra en escena.

¿Qué es el almacenamiento en caché?

El caché es el almacenamiento de memoria que se utiliza para almacenar los datos de acceso frecuente en el almacenamiento temporal, mejorará drásticamente el rendimiento y evitará el acceso innecesario a la base de datos y almacenará los datos de uso frecuente en el búfer cuando lo necesitemos.

Como puede ver en la imagen de arriba, hay dos escenarios, uno sin usar caché y otro con caché y cómo funciona. Entonces, aquí, cuando no usamos el caché, en ese caso, supongamos que los usuarios quieren datos, entonces accederán cada vez a la base de datos y aumentará la complejidad del tiempo y reducirá el rendimiento. En caso de que haya algunos datos estáticos que los usuarios deseen y sea lo mismo para todos los usuarios, en ese caso, cuando no usamos el caché, cada uno accede a la base de datos innecesaria para obtener datos. Y por otro lado, como puede ver, si usamos caché y, en ese caso, si hay los mismos datos estáticos y los mismos para todos los usuarios, solo el primer usuario accederá a la base de datos y obtendrá datos y los almacenará en la memoria caché y luego otro dos usuarios usan eso desde el caché sin presionar innecesariamente la base de datos para obtener datos.

Tipos de caché

Básicamente, hay dos tipos de almacenamiento en caché compatibles con .NET Core

  1. Almacenamiento en caché en memoria
  2. Almacenamiento en caché distribuido

Cuando usamos In-Memory Cache, en ese caso, los datos se almacenan en la memoria del servidor de aplicaciones y, siempre que los necesitamos, extraemos datos de eso y los usamos donde los necesitemos. Y en el almacenamiento en caché distribuido hay muchos mecanismos de terceros como Redis y muchos otros. Pero en esta sección, analizamos en detalle la memoria caché en memoria y cómo funciona en .NET Core.

Caché en memoria

Básicamente, In-Memory Cache se usa para aplicaciones ligeras y pequeñas y funcionará bien en eso. Almacena datos en la memoria del servidor en el lado de la aplicación y los usuarios los usan cuando surge la necesidad.

Ventajas de la memoria caché en memoria

  • Los usuarios obtienen datos rápidamente cuando usamos In-Memory Cache.
  • Aumentará el rendimiento de la aplicación.
  • Ideal para aplicaciones pequeñas que se implementan en un solo servidor.

Desventajas de la memoria caché en memoria

  • En ocasiones, la memoria caché en memoria aumenta el mantenimiento de la aplicación
  • En In-Memory Cache, los datos se conservan en un solo servidor y, si el servidor falla, los datos se pierden. Además, es difícil escalar la aplicación en algunos escenarios.

Ahora vamos a crear una API de .NET Core, implementar el almacenamiento en caché y comprender cómo funcionarán las cosas.

Paso 1

Crear la aplicación web de la API de .NET Core

Paso 2

Instale los siguientes paquetes NuGet que necesitan paso a paso en nuestra aplicación

  • Microsoft.EntityFrameworkCore
  • Microsoft.EntityFrameworkCore.Diseño
  • Microsoft.EntityFrameworkCore.SqlServer
  • Microsoft.EntityFrameworkCore.Herramientas
  • Swashbuckle.AspNetCore
  • System.Runtime.Caching

Paso 3

Cree la carpeta Modelo y cree una Clase de producto dentro con detalles

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; }
    }
}

Paso 4

A continuación, cree la clase DbContextClass para las operaciones relacionadas con la base de datos como se muestra a continuación

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;
        }
    }
}

Paso 5

Ahora, vamos a crear la interfaz ICacheService y la clase CacheService para el uso relacionado con In-Memory Cache.

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;
        }
    }
}

Paso 6

Cree la clase ProductController, cree el siguiente método como se muestra a continuación

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();
        }
    }
}

Paso 7

Agregue la cadena de conexión de SQL Server dentro de appsetting.json

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*",
  "ConnectionStrings": {
    "DefaultConnection": "Data Source=server;Initial Catalog=MemoryCache;User Id=****;Password=***;"
  }
}

Paso 8

A continuación, registre ICacheService dentro del método Configure Service de Startup Class y también agregue alguna configuración relacionada con Swagger para probar nuestros puntos finales de 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();
            });
        }
    }
}

Paso 9

Realice la migración y la actualización de la base de datos para la creación de la base de datos mediante los siguientes comandos en la consola del administrador de paquetes.

agregar-migración "Primera migración"

actualizar base de datos

Entonces, cuando ingrese y ejecute este comando, generará algunas cosas relacionadas con la migración y creará la base de datos dentro de SQL Server a medida que ingresa la Cadena de conexión en appsetting.json

Paso 10

Finalmente, ejecute la aplicación y agregue los datos usando la interfaz de usuario de Swagger y luego verifique cómo funciona el almacenamiento en caché dentro de los productos y el punto final del producto.

Básicamente, agregué caché en el producto y los puntos finales de los productos en el controlador, como puede ver cuando el usuario desea obtener datos de todos los productos, primero verificará si los datos están presentes dentro del In-Memory Cache o no y si está presente dentro del caché, luego devuelva esos datos al usuario y, si los datos no están presentes dentro del caché, obtendrá los datos de la base de datos y también los configurará en el caché. Entonces, la próxima vez, el usuario obtendrá eso solo del caché y evitará acceder a la base de datos innecesariamente. 

Además, cuando el usuario desea obtener datos utilizando la identificación del producto como se ve en el controlador en el segundo punto final del producto, obtenemos datos de la memoria caché de todos los productos, luego filtramos usando la identificación del producto y, si está presente, regresamos al usuario desde la memoria caché y si luego no obtener de la base de datos y regresar al usuario después de aplicar el filtro.

Entonces, como puede ver en el interior, actualice, elimine y publique el punto final del controlador del producto, luego usamos el método de eliminación para eliminar los datos de la clave del producto que está presente dentro del caché. Por lo tanto, hay muchos escenarios y usos de cachés de memoria que puede usar según sus necesidades y requisitos. Solo quiero presentar los conceptos básicos de Memory Cache y cómo funciona dentro de .NET Core que cubrí aquí.

Además, hay un escenario del que debe ocuparse al usar el almacenamiento en caché como supongamos, hay dos usuarios que usan su aplicación, luego vendrán los siguientes escenarios

  • Cuando el primer usuario envía la solicitud para obtener los datos de todos los productos, llega la primera solicitud y luego verificará si los datos están presentes dentro del caché o no y si los datos están presentes dentro del caché, luego obtendrá los datos. de la base de datos y también configurarlo en el caché.
  • Mientras tanto, el segundo usuario envía la solicitud para obtener los detalles del producto, luego la solicitud también ingresa a la base de datos antes de completar la solicitud del primer usuario y debido a que el segundo usuario también ingresa a la base de datos para obtener los detalles del producto.
  • Entonces, hay una solución para esto para usar el mecanismo de bloqueo como se muestra a continuación

Agregue crear un objeto de bloqueo en la parte superior de la clase y luego en el método como se muestra a continuación

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;
}

Entonces, como puede ver primero, verificamos si los datos están presentes dentro del caché o no, si los datos están disponibles y luego los devolvemos. A continuación, si el valor no está presente en la caché de memoria, aplicamos el bloqueo allí y luego la solicitud se bloquea y se ingresa en la sección y se obtienen los detalles del producto de la base de datos, y luego también se establece en la memoria caché y luego devolver los datos. Entonces, cuando el segundo usuario envía una solicitud antes de que la solicitud del usuario esté completa. Entonces, en ese caso, la segunda solicitud está en la cola y después de completar la primera solicitud del usuario, la segunda solicitud aparece en la imagen.

Esto es todo acerca de In-Memory Cache en .NET Core. Espero que entiendas cosas relacionadas con eso.

¡Feliz codificación!

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

  #aspdotnet #api #csharp #dotnet 

What is GEEK

Buddha Community

Implementar Caché En Memoria En La API De .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

Create Asp Net Web API for CRUD operation | CRUD Using Asp Net Api

#api #api 2 #restful api #asp.net api #asp.net core api

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