Implementar O Cache De Memória Na API Do .NET Core

Vamos discutir o cache no .NET Core e como ele funciona. Então, vamos olhar para as seguintes coisas, uma por uma.

• Introdução ao cache
• O que é Cache
• Tipos de cache
• Implementação de cache

Então, vamos começar um por um.

Introdução

O cache é muito popular hoje em dia na indústria de software porque melhorará o desempenho e a escalabilidade do aplicativo, pois usamos e vemos muitos aplicativos da Web como G-mail e Facebook e como eles são responsivos e ótima experiência do usuário enquanto usamos isso. Há muitos usuários usando a internet e se um aplicativo tem grande tráfego de rede e demanda e por isso precisamos cuidar de muitas coisas que nos ajudam a melhorar o desempenho e a capacidade de resposta do aplicativo. Então, por causa disso, uma das soluções é o cache e é por isso que o cache entra em cena.

O que é cache?

O cache é o armazenamento de memória que é usado para armazenar os dados de acesso frequente no armazenamento temporário, melhorará drasticamente o desempenho e evitará o acerto desnecessário do banco de dados e armazenará os dados usados ​​com frequência no buffer sempre que precisarmos.

Como você vê na imagem acima existem dois cenários um é sem usar cache e outro é com cache e como funciona. Então aqui quando não usamos o cache, nesse caso, suponha que os usuários queiram dados, então eles acessarão o banco de dados a cada vez e isso aumentará a complexidade do tempo e reduzirá o desempenho. Caso haja alguns dados estáticos que os usuários desejam e é o mesmo para todos os usuários, nesse caso, quando não usamos o cache, cada um atinge o banco de dados desnecessário para buscar dados. E por outro lado, como você pode ver, se usarmos cache e, nesse caso, se houver os mesmos dados estáticos e iguais para todos os usuários, apenas o primeiro usuário acessará o banco de dados e buscará os dados e os armazenará na memória cache e depois outros dois usuários usam isso do cache sem acessar desnecessariamente o banco de dados para buscar dados.

Tipos de cache

Basicamente, existem dois tipos de suporte a cache do .NET Core

1. Cache na memória
2. Cache distribuído

Quando usamos o In-Memory Cache, nesse caso, os dados são armazenados na memória do servidor de aplicativos e, sempre que precisamos, buscamos os dados e os usamos onde quer que precisemos. E no Distributed Caching existem muitos mecanismos de terceiros como Redis e muitos outros. Mas nesta seção, examinamos o Cache de Memória em detalhes e como ele funciona no .NET Core.

Cache na memória

Basicamente, o In-Memory Cache é usado para aplicativos leves e pequenos e funcionará bem nisso. Ele armazena dados na memória do servidor no lado do aplicativo e os usuários os usam sempre que necessário.

Vantagens do cache na memória

• Os usuários buscam dados rapidamente quando usamos o In-Memory Cache.
• Isso aumentará o desempenho do aplicativo.
• Mais adequado para pequenos aplicativos implantados em um único servidor.

Desvantagens do cache na memória

• Às vezes, o cache na memória aumenta a manutenção do aplicativo
• No In-Memory Cache, os dados são mantidos em um único servidor e, se o servidor travar, os dados serão perdidos. Também é difícil dimensionar o aplicativo em alguns cenários.

Agora vamos criar uma API .NET Core, implementar o cache nela e entender como as coisas vão funcionar.

Passo 1

Criar o aplicativo Web da API do .NET Core

Passo 2

Instale os seguintes pacotes NuGet que precisam passo a passo em nosso aplicativo

• Microsoft.EntityFrameworkCore
• Microsoft.EntityFrameworkCore.Design
• Microsoft.EntityFrameworkCore.SqlServer
• Microsoft.EntityFrameworkCore.Tools
• Swashbuckle.AspNetCore
• System.Runtime.Caching

etapa 3

Crie a pasta Model e crie uma classe de produto dentro dela com detalhes

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

Passo 4

Em seguida, crie a classe DbContextClass para operações relacionadas ao banco de dados como mostrei abaixo

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

Etapa 5

Agora, vamos criar a Interface ICacheService e a Classe CacheService para uso relacionado ao Cache In-Memory.

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

Etapa 6

Crie a classe ProductController, crie o seguinte método conforme mostrado abaixo

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

Etapa 7

Adicione a string de conexão do 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=***;"
  }
}

Etapa 8

Em seguida, registre o ICacheService dentro do método Configure Service da Startup Class e também adicione algumas configurações relacionadas ao Swagger para testar nossos endpoints da 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();
            });
        }
    }
}

Etapa 9

Execute migração e atualização de banco de dados para criação de banco de dados usando os comandos a seguir no console do gerenciador de pacotes.

add-migration “FirstMigration”

atualizar o banco de dados

Então, quando você inserir e executar este comando, ele gerará algumas coisas relacionadas à migração e criará o banco de dados dentro do SQL Server conforme você coloca dentro da Connection String no appsetting.json

Etapa 10

Por fim, execute o aplicativo e adicione os dados usando a interface do usuário do swagger e, em seguida, verifique como o armazenamento em cache funciona nos produtos e no endpoint do produto.

Basicamente, adicionei cache nos endpoints do produto e produtos no controlador, como você vê quando o usuário deseja buscar dados de todos os produtos, primeiro ele verificará se os dados estão presentes dentro do Cache In-Memory ou não e se estão presentes dentro do cache, em seguida, retorne esses dados para o usuário e, se os dados não estiverem presentes dentro do cache, ele buscará os dados do banco de dados e também os definirá no cache. Então, da próxima vez, o usuário obterá isso apenas do cache e evitará acessar o banco de dados desnecessariamente 

Além disso, quando o usuário deseja buscar dados usando o ID do produto como você vê no controlador no segundo endpoint do produto, buscamos dados do cache de todos os produtos e filtramos usando o ID do produto e, se estiver presente, retornamos ao usuário do cache e se não buscar no banco de dados e retornar ao usuário após aplicar o filtro.

Então, como você vê dentro de update, delete e post endpoint do Product Controller, então usamos o método remove para remover os dados da chave do produto que está presente dentro do cache. Portanto, existem muitos cenários e uso de caches de memória que você pode usar de acordo com sua necessidade e requisitos. Eu só quero apresentar o básico do Cache de Memória e como ele funciona dentro do .NET Core que eu abordei aqui.

Além disso, há um cenário que você precisa cuidar ao usar o cache, como suponha, há dois usuários usando seu aplicativo, então os seguintes cenários virão

• Quando o primeiro usuário envia a requisição para buscar os dados de todos os produtos então vem a primeira requisição e então ele vai checar se os dados estão presentes dentro do cache ou não e se os dados estão presentes dentro do cache, então ele vai buscar os dados do banco de dados e também configurá-lo para o cache.
• Enquanto isso, o segundo usuário envia a solicitação para obter os detalhes do produto, então a solicitação também atinge o banco de dados antes de concluir a solicitação do primeiro usuário e, por causa desse segundo usuário, também acessa o banco de dados para buscar os detalhes do produto.
• Portanto, existe uma solução para isso usar o mecanismo de bloqueio, conforme mostrado abaixo

Adicione crie um objeto de bloqueio no topo da classe e depois no método como mostrei abaixo

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

Então aqui, como você vê primeiro, verificamos se os dados estão presentes dentro do cache ou não, se os dados estão disponíveis e retornamos isso. Em seguida, se o valor não estiver presente no cache de memória, aplicamos o bloqueio ali e, em seguida, a solicitação é bloqueada e inserida na seção e buscamos os detalhes do produto no banco de dados, e também configuramos para o cache e, em seguida, retornar os dados. Portanto, quando o segundo usuário envia uma solicitação antes que a solicitação do usuário seja concluída. Então, nesse caso, a segunda solicitação está na fila e depois de concluir a primeira solicitação do usuário, a segunda solicitação entra em cena

Isso é tudo sobre Cache de Memória no .NET Core. Espero que você entenda as coisas relacionadas a isso.

Boa Codificação!

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

  #aspdotnet #api #csharp #dotnet 

What is GEEK

Buddha Community

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_._

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.

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.

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

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.

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.

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.

#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

AllowAnonymous in asp.net core

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

Authorization in asp.net core

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