Skip to main content

Dotnet Core MVC Cookie Login Sample From Scratch(Part 1)

Introduction:


In general ASP.NET Core applications(MVC, RazorPages, WebAPI, Blazor Server Side) use login libraries like ASP.NET Core Identity, IdentityServer4, OAuth 2.0, etc. But ASP.NET Core can simply implement login with using Cookie-Based Authentication without any login libraries.

ASP.NET Core Identity is a membership program that helps to create a login functionality. Its rich library with all default login functionalities, creating users, adding roles, password encryption, and support to social logins like Google, Facebook, Outlook, Twitter, etc.

IdentityServer4 Or OAuth 2.0 is the latest login technology. It also gives all login functionalities and support to social logins as well additionally Single Sign-On and Token-Based user login.

Cookie-Based Authentication is a default login mechanism provided by ASP.NET Core applications.
But user creation, adding roles need to be done manually which is not hard to do. In this approach, we don't get too many pre-build methods or functionality available like in the login library.


Create ASP.NET Core MVC Project:

Let us create a sample MVC application in ASP.NET Core 3.0 using VisualStudio 2019 latest version. Make sure to uncheck the authentication checkbox while selecting the MVC project template. Click to see steps for project creation.

Create User And Roles Tables:

Create a "User" table with following SQL-Query

  CREATE TABLE [dbo].[User]
  (
    [Id] INT NOT NULL PRIMARY KEY IDENTITY, 
    [FirstName] VARCHAR(500) NULL, 
    [LastName] VARCHAR(500) NULL, 
    [Email] VARCHAR(MAX) NOT NULL, 
    [Password] VARCHAR(MAX) NOT NULL, 
    [LastLoginTime] DATETIME NULL
  )

Create  a "Roles" table with following SQL-Query
CREATE TABLE [dbo].[Roles]
(
    [Id] INT NOT NULL PRIMARY KEY IDENTITY, 
    [RoleName] VARCHAR(500) NOT NULL
)

Create a "UserRoles" mapping table with following SQL-Query
CREATE TABLE [dbo].[UserRole]
(
    [Id] INT NOT NULL PRIMARY KEY IDENTITY, 
    [UserId] INT NOT NULL, 
    [RoleId] INT NOT NULL
)

CodeFirst With Existing DataBase:

To communicate with a database we implement the Code-First approach click here to know more.
In this approach, the database is represented by DbContext and tables are represented by Model Classes. 
Install below to packages that help in creating DbContext

Install-Package Microsoft.EntityFrameworkCore -Version 3.0.0
Install-Package Microsoft.EntityFrameworkCore.Relational -Version 3.0.0 

In the model, folder create files like 'User.cs', 'Roles.cs', 'UserRole.cs' which represent database tables

User.cs:
  using System;

namespace CookieAuth.Web.Models
{
    public class User
    {
        public int Id { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public string Email { get; set; }
        public string Password { get; set; }
        public DateTime? LastLoginTime { get; set; }
    }
}

Roles.cs:
namespace CookieAuth.Web.Models
{
    public class Roles
    {
        public int Id { get; set; }
        public string RoleName { get; set; }
    }
}

UserRole.cs:
namespace CookieAuth.Web.Models
{
    public class UserRole
    {
        public int Id { get; set; }
        public int UserId { get; set; }
        public int RoleId { get; set; }
    }
}

Now add new folder 'DAL', in that create a class name as 'UserContext.cs'.
UserContext.cs:
using CookieAuth.Web.Models;
using Microsoft.EntityFrameworkCore;

namespace CookieAuth.Web.DAL
{
    public class UserContext : DbContext
    {
        public UserContext(DbContextOptions context):base(context)
        {

        }

        public DbSet<User> User { get; set; }
        public DbSet<Roles> Roles { get; set; }
        public DbSet<UserRole> UserRole { get; set; }
        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<User>(entity =>
            {
                entity.ToTable("User");
            });

            modelBuilder.Entity<Roles>(entity =>
            {
                entity.ToTable("Roles");
            });

            modelBuilder.Entity<UserRole>(entity =>
            {
                entity.ToTable("UserRole");
            });
        }
    }
}

ConnectionString:

Add Database ConnectionString in 'appSettings.json'

Register Database Context:

Need to install below NuGet package to register DbContext with some SQL options
Install-Package Microsoft.EntityFrameworkCore.SqlServer -Version 3.0.0

Now we need to register our DbContext in 'Startup.cs' file, inside it we have a method 'ConfigureServices' to register any service throughout the application.

 services.AddDbContext<usercontext>(options =>
 {
   options.UseSqlServer(Configuration.GetConnectionString("SportsDbContext"));
 });

Create An Account Controller:

This controller generally contains user action methods like 'Sign-up', 'Sign-in' and 'logout', etc. Now add a new controller and name it as 'AccountController.cs'.

Create UserViewModel For SignUp Form:

In the model, folder add filename as 'UserViewModel.cs', which is used user registration. Using 'System.ComponentModel.DataAnnotations' for ASP.NET Core MVC Model validation
Validation Attributes:
.[Required] mandatory filed 
.[Compare('otherPropertyName')] compare and check matches with other property

using System.ComponentModel.DataAnnotations;

namespace CookieAuth.Web.Models
{
    public class UserViewModel
    {
        [Required]
        public string FirstName { get; set; }
        [Required]
        public string LastName { get; set; }

        [Required]
        public string Email { get; set; }

        [Required]
        public string Password { get; set; }

        [Required]
        [Compare("Password")]
        public string ConfirmPassword { get; set; }
    }
}
  

Http Get SignUp Action:

To register user add 'SignUp' HttpGet action method in the'AccountController.cs'. This HttpGet action method navigate user to application registration form
AccountController.cs:

[Route("sign-up")]
[HttpGet]
public IActionResult SignUp()
{
  return View(new UserViewModel());
}

SignUp Form:

Now create 'sign-up.cshtml' file in 'Views/Accounts' folder. Add the following Html to design sign-up from.

@model CookieAuth.Web.Models.UserViewModel
@{
    ViewData["Title"] = "SignUp";
}

<h1>SignUp Form</h1>

<div class="row">
    <div class="col col-sm-12">
        <form action="/account/sign-up" method="post">
            <div class="form-group row">
                <div asp-validation-summary="ModelOnly" class="text-danger"></div>
                <label for="FirstName" class="col-sm-2 col-form-label">First Name</label>
                <div class="col-sm-10">
                    <input type="text" class="form-control" id="FirstName" name="FirstName" placeholder="Enter First Name" asp-for="FirstName" />
                    <span asp-validation-for="FirstName" class="text-danger"></span>
                </div>
            </div>
            <div class="form-group row">
                <label for="LastName" class="col-sm-2 col-form-label">Second Name</label>
                <div class="col-sm-10">
                    <input type="text" class="form-control" id="LastName" name="LastName" placeholder="Enter Last Name" asp-for="LastName" />
                    <span asp-validation-for="LastName" class="text-danger"></span>
                </div>
            </div>
            <div class="form-group row">
                <label for="Email" class="col-sm-2 col-form-label">Email</label>
                <div class="col-sm-10">
                    <input type="text" class="form-control" id="Email" name="Email" placeholder="Enter Email Address" asp-for="Email" />
                    <span asp-validation-for="Email" class="text-danger"></span>
                </div>
            </div>
            <div class="form-group row">
                <label for="Password" class="col-sm-2 col-form-label">Password</label>
                <div class="col-sm-10">
                    <input type="password" class="form-control" id="Password" name="Password" placeholder="Enter Passwor" asp-for="Password" />
                    <span asp-validation-for="Password" class="text-danger"></span>
                </div>
            </div>
            <div class="form-group row">
                <label for="ConfirmPassword" class="col-sm-2 col-form-label">Confirm Password</label>
                <div class="col-sm-10">
                    <input type="password" class="form-control" id="ConfirmPassword" name="ConfirmPassword" placeholder="Enter Confirm Password" asp-for="ConfirmPassword" />
                    <span asp-validation-for="ConfirmPassword" class="text-danger"></span>
                </div>
            </div>
            <div class="form-group row">
                <div class="col-sm-offset-2 col-sm-10">
                    <button type="submit" class="btn btn-primary">Register</button>
                </div>
            </div>
        </form>
    </div>
</div>
@section Scripts {
    @{await Html.RenderPartialAsync("_ValidationScriptsPartial");}
}

'UserViewModel' is used for model binding.
. 'asp-validation-for' MVC attributes for form model validation.
. 'asp-for' data binding to the form fields from the view-model.

Http Post SignUp Action Method To Add Users:

Now add an overloaded SignUp method in 'AccountController.cs', in this method we are going to add a new user. This action method takes care to verify MVC model validation, takes responsibility to have a unique email address in the database, and saving new users to the database.

Inject UserContext into AccountController using Constructor Injection:

private readonly UserContext _userContext;
public AccountController(UserContext userContext)
{
  _userContext = userContext;
}
SignUp Post Action:
[Route("sign-up")]
[HttpPost]
public IActionResult SignUp(UserViewModel viewModel)
{
    if (ModelState.IsValid)
    {
        if(!_userContext.User.Any(_ => _.Email.ToLower() == viewModel.Email.ToLower()))
        {
            User newUser = new User
            {
                Email = viewModel.Email,
                FirstName = viewModel.FirstName,
                LastName = viewModel.LastName,
                Password = viewModel.Password
            };
            _userContext.User.Add(newUser);
            _userContext.SaveChanges();

            return Redirect("/login");
        }
    }
    return View(viewModel);
}
. 'HttpPost' accepts the post request
. 'Route' attribute matches the requested route.
. 'UserViewModel' MVC automatically inputs the data from the posted form to the inputting model
. 'ModelState' is a default property created by the controller, which helps to check and validate the request model.
. Linq extension method Any() queries the database to check if the email is already registered to avoid duplication user registration
. Map the values from 'UserViewModel' to 'User' model (Tabel Model), then using 'UserContext', saves the data to a database.
. After a user successfully registered, navigate to the login page (implemented in following steps)

Note: Here I'm not encrypting password while saving to the database, you need to do encryption before saving to the database, to encrypt CSharp has a lot of encryption algorithms like 'SHA 512'. Never, ever save plain text password to the database.

Create LoginViewModel:

In 'Model' folder add a new class name as 'LoginViewModel' with 'Data Annotation' attributes for login form validation
using System.ComponentModel.DataAnnotations;

namespace CookieAuth.Web.Models
{
    public class LoginViewModel
    {
        [Required]
        public string Email { get; set; }
        [Required]
        public string Password { get; set; }
        public bool IsPersistant { get; set; }
    }
}

Http Get Login Action Method:

To load the login form update the 'AccountController' with the login action method

[Route("login")]
[HttpGet]
public IActionResult Login()
{
   return View(new LoginViewModel());
}

Register Cookie And Authentication Middleware:

In 'Startup.cs' file register authentication cookie in the 'ConfigureServices' method.

services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
.AddCookie();
'CookieAuthenticationDefault' is provided by 'Microsoft.AspNetCore.Authentication.Cookies'.
'AuthenticationScheme' name is useful when there are multiple instances of cookie authentication supported by the application.

In 'Startup.cs' file configure authentication middleware in the 'Configure' method. From ASP.NET 3.0 endpoint routing was implemented, where most of the middleware should implement between 'app.UseRouting()' and 'app.UseEndpoints()' as below
app.UseRouting();
app.UseAuthentication();
app.UseAuthorization();

app.UseEndpoints(endpoints =>
{
    endpoints.MapControllerRoute(
          name: "default",
          pattern: "{controller=Home}/{action=Index}/{id?}");
    });

Login Form:

Now add 'Login.cshtml' in 'Views/Accounts' folder.

@model CookieAuth.Web.Models.LoginViewModel
@{
    ViewData["Title"] = "Login";
}

<h1>Login</h1>

<div class="row">
    <div class="col col-sm-6">
        <div asp-validation-summary="ModelOnly" class="text-danger"></div>
        <form action="/account/login" method="post">
            <div class="form-group row">
                <label for="Email" class="col-sm-2 col-form-label">Email</label>
                <div class="col-sm-10">
                    <input type="text" class="form-control" id="Email" name="Email" placeholder="Enter Email" />
                    <span asp-validation-for="Email" class="text-danger"></span>
                </div>
            </div>
            <div class="form-group row">
                <label for="Password" class="col-sm-2 col-form-label">Password</label>
                <div class="col-sm-10">
                    <input type="password" class="form-control" id="Password" name="Password" placeholder="Enter Password" />
                    <span asp-validation-for="Password"></span>
                </div>
            </div>
            <div class="form-group row">
                <div class="col-sm-offset-2 col-sm-10">
                    <button type="submit" class="btn btn-primary">Login</button>
                </div>
            </div>
        </form>
    </div>
</div>
@section Scripts {
    @{await Html.RenderPartialAsync("_ValidationScriptsPartial");}
}
. 'LoginViewModel' is the data binding object of this MVC view
. 'asp-validation-for' attribute to display the model validation error message

Http Post Login Action Method (User Login Method):

Now add user login logic in the login post action method in 'AccountController.cs'

[Route("login")]
[HttpPost]
public async Task<IActionResult> Login(LoginViewModel viewModel)
{
 if (ModelState.IsValid)
 {
  // note : real time we save password with encryption into the database
  // so to check that viewModel.Password also need to encrypt with same algorithm 
  // and then that encrypted password value need compare with database password value
  Models.User user = _userContext.User.Where(_ => _.Email.ToLower() == viewModel.Email.ToLower() && _.Password == viewModel.Password).FirstOrDefault();
  if(user != null)
  {
   user.LastLoginTime = DateTime.Now;
   _userContext.SaveChanges();
   var claims = new List<Claim>
    {
     new Claim(ClaimTypes.Name, user.Email),
     new Claim("FirstName",user.FirstName)
    };
   var claimsIdentity = new ClaimsIdentity(claims, CookieAuthenticationDefaults.AuthenticationScheme);
   var authProperties = new AuthenticationProperties() { IsPersistent = viewModel.IsPersistant };
   await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, new ClaimsPrincipal(claimsIdentity), authProperties);
   return Redirect("/");
  }
  else
  {
   ModelState.AddModelError("InvalidCredentials", "Either username or password is not correct");
  }
 }
 return View(viewModel);
}
'HttpPost' attribute represents the post-action MVC page, which expects data from the client browser.
. 'Route' represents the route of the page, this type of router configuration is called 'Attribute Routing'.
. If the user tries to login with invalid credentials, we can add custom error to the model by using 'ModelState.AddModelError()'. This message will be displayed to the user
. If the user exists, update the 'LastLoginTime' and save it to the database. This field represents how frequently user login to the application.
. Claims contain a minimum amount of information, which used to identify the user on login. Claims can store user roles and permissions as well.
. 'ClaimsIdentity(IEnumerable claims, string authenticationType)' instantiate claims identity with one of the overloaded constructors which accept all our user login claim collection and authentication schema type like 'CookieAuthenticationDefaults.AuthenticationScheme'.
. 'Microsoft.AspNetCore.AuthenticationSignInAsync(this HttpContext context, string scheme, ClaimsPrincipal principal, AuthenticationProperties properties).' this method makes the user to login to the application. SignInAsync() is an overloaded method with accepts 'authentication scheme', 'user claims' and 'authentication settings.
. 'SignAsync()' method creates the authentication cookie and it needs to be given to the client(browser). So always reload the page after login so that authentication cookie gets available to the client and it will be sent to the server for every next request. Here in this sample after login, I'm redirecting to the home page.

Change Application Menu On User Authentication:

To get the authenticated user information into MVC views we need to inject the 'HttpContext' into the '_Layout.cshtml' page. Using @inject directive we can inject the 'HttpContext'. Dotnet Core provided an interface 'IHttpContextAccessor' to inject HttpContext

@using Microsoft.AspNetCore.Http
@inject IHttpContextAccessor _httpHttpContextAccessor;
Now add menu links like 'Sign-up', 'Login' show them conditionally based on user authentication. Below 'Privacy' menu link tag add the following Html in '_Layout.cshtml'
Here we are getting the user name that was added as a claim while the user login to the application.

SignOut Action Method:

Now in 'AccountController' add the sign-out method

[HttpGet]
[Route("sign-out")]
public async Task<IActionResult> SignOut()
{
 await HttpContext.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
 return Redirect("/");
}
. 'HttpContext.SignOutAsync()' removes the login cookie to sign-out the user. This method only expects a login schema name.

Now run the application and navigate to sign-up form to register.
Now open login form and try to login into the application
After login your page looks:

Summary:

Here we created a simple login application using Cookie-Based Authentication, without any login libraries. We have created users, roles tables, we have implemented sign-in and sign-out methods. Model form validation did with the help of Data Annotations. Using this login cookie we going to implement Authorization in MVC application. Click here to Role-base Authorization
😀

Refer:

Comments

  1. Hi, Thanks for the post, but when i followed it to the end. After running the application, it gave me this error.

    InvalidOperationException: No service for type 'Microsoft.AspNetCore.Http.IHttpContextAccessor' has been registered

    ReplyDelete
    Replies
    1. Hi sam,
      need to register HttpContext, which i missed in article
      do as below:-
      public void ConfigureServices(IServiceCollection services)
      {

      services.AddHttpContextAccessor();
      // or use below both are same
      //services.TryAddSingleton();

      }

      Delete

Post a Comment

Popular posts from this blog

Endpoint Routing In Asp.Net Core

How Routing Works In  Core 2.1 And Below Versions?: In Asp.Net Core routing is configured using app.UseRouter() or app.UseMvc() middleware. app.UseMvc(routes => { routes.MapRoute( name: "default", template: "{controller=Home}/{action=Index}/{id?}"); }); Here in Dotnet Core version 2.1 or below versions on the execution of route middleware request will be navigated appropriate controller matched to the route.

An operation or functionality which is dependent on route URL or route values and that need to be implemented before the execution of route middleware can be done by accessing the route path from the current request context as below
app.Use(async (context, next) => { if(context.Request.Path.Value.IndexOf("oldvehicle") != -1) { context.Response.Redirect("vehicle"); } else { await next(); } }); app.UseMvc(routes => { routes.MapRoute( name: "vehicleRoute", template: "vehicle", defaults:new { …

GraphQL API Integration In Asp.Net Core Application

Introduction:
GraphQL is a query language for your API and a server-side runtime for executing queries by using a type system you define for your data. GraphQL can be integrated into any framework like ASP.NET, Java, NestJs, etc and it isn't tied to any specific database or storage engine and is instead backed by your existing code and data.
How GraphQL API Different From Rest API: GraphQL exposes a single end-point or route for the entire application, regardless of its responses or actions.HTTP-POST is the only Http verb recommended by the GraphQL.The client applications (consumers of API) can give instructions to GraphQL API about what type of properties to be returned in the response. Building Blocks Of GraphQL API:The main building blocks of GraphQL API is Schemas and Types. A 'Schema' in GrpahQL API describes the functionality available to the clients connect to API. Schema mostly consists of GraphQL Object Types, Queries, Mutations, etc.Types likely to be called Grap…

ASP.NET Core Web API Versioning

Introduction: An iteration and evolutionary changes of an ASP.NET Core Web API is handled by Versioning. Versioning of an API gives confidence to the clients which consumes API for a long time. Any changes or development of an API will be accessible using the new version and it won't cause issues to the clients consuming the old version of API.
When To Use Versioning:Any API response changes.Developing an API by implementing testing levels like 'Alpha', 'Beta', and 'RC' versions before releasing Production.Deprecating an API which means API going to be removed or upgraded by a version within a short period. Versioning Types:Query String VersioningUrl Path VersioningMedia Type Versioning API Version Nuget: To Configure versioning to AspNet Core Web API Microsoft provided a library(Microsoft.AspNetCore.Mvc.Versioning). So to use the versioning library please install NuGet below.
 Install-Package Microsoft.AspNetCore.Mvc.Versioning -version 4.0.0 Register API V…

.NET Core MVC Application File Upload To Physical Location With Buffered Technique

Buffering Technique In File Upload:The server will use its Memory(RAM) or Disk Storage to save the files on receiving a file upload request from the client. Usage of Memory(RAM) or Disk depends on the number of file requests and the size of the file. Any single buffered file exceeding 64KB is moved from Memory to a temp file on disk. If an application receives heavy traffic of uploading files there might be a chance of out of Disk or RAM memory which leads to crash application. So this Buffer technique used for small files uploading. In the following article, we create a sample for the file uploading using .NET Core MVC application.
Create The .NET Core MVC Project: Let's create a .NET Core MVC project, here for this sample I'm using Visual Studio Code as below.  Check the link to use the Visual Studio Code for .NET Core Application.
IFormFile: Microsoft.AspNetCore.Http.IFormFile used for file upload with buffered technique. On uploading files from the client, then the entire …

Ionic Picker Sample Code In Angular

Introduction: Ionic Picker(ion-picker) is a popup slides up from the bottom of the device screen, which contains rows with selectable column separated items.
The main building block of ion-picker as follows: PickerControllerPickerOptions PickerController: PickerController object helps in creating an ion-picker overlay. create(opts?: Opts): Promise<Overlay> PickerController create method helps in create the picker overlay with the picker options
PickerOptions: PickerOptions is a configuration object used by PickerController to display ion-picker.
Single Column Ionic Picker: single.item.picker.ts: import { Component } from "@angular/core"; import { PickerController } from "@ionic/angular"; import { PickerOptions } from "@ionic/core"; @Component({ selector: "single-column-picker", templateUrl:"single.item.picker.html" }) export class SingleItemPicker { animals: string[] = ["Tiger", "Lion", "Elephant"…

Blazor WebAssembly Dynamic Form Validation

Introduction: In Blazor WebAssembly(client-side framework) form validation can be done with Data Annotations. Using Data Annotations we can validate form either by default validation attributes or by creating custom validation attributes. Using this Data Annotation attribute we can dynamically add or remove validation on a specific field in a form.
Create Blazor WebAssembly Project: To create a Blazor WebAssembly template project need to install the latest version of VisualStudio 2019 for rich intelligence support or we can use VisualStudio code but less intelligence support from the editor. Click here to know about Blazor WebAssembly template creation. Blazor WebAssembly is in preview mode, not yet ready for production.
Create Razor Component: After creating a sample project using the Blazor WebAssembly template, in "Pages" folder add new Razor Component, name it as "UserForm.razor"
Add Route: In Blazor routing can be configured using @page  directive, and URL should b…

Asp.Net Core MVC Form Validation Techniques

Introduction: Form validations in any applications are like assures that a valid data is storing on servers. All programing frameworks have their own individual implementations for form validations. In Dotnet Core MVC application server-side validations carried on by the models with the help of Data Annotations and the client-side validations carried by the plugin jQuery Unobtrusive Validation. jQuery Unobtrusive Validation is a custom library developed by Microsoft based on the popular library jQuery Validate.
In this article, we are going to learn how the model validation and client-side validation works in Asp.Net Core MVC Application with sample examples.
Getting Started: Let's create an Asp.Net Core MVC application project using preferred editors like Microsoft Visual Studio or Microsoft Visual Studio Code. Here I'm using Visual Studio.
Let's create an MVC controller and name it as 'PersonController.cs' and add an action method as below.
PersonController.cs: us…

Blazor Server CRUD Operations

Introduction: Blazor Server is a web framework to develop server-side single-page applications. Blazor is made up of components with the combinations on C#, Html, CSS.  Blazor Server is production-ready from the .Net Core 3.0.  Blazor Server Working Mechanism:Blazor Server is a very light-weight web development framework. In Blazor Server, not all code gets downloaded to the client browsers. Blazor Server made of components these components can be a block of code or page with respective navigation. Blazor server application communicates with the server with a SignalR background connection which is inbuilt functionality. Application click,  form submission, change events, application page navigation every operation is carried out by the SignalR connection by communicating with the server. Blazor updates the Html DOM very gently on every data update without any overhead. Blazor Server application maintains a nice intelligent tree structure to update the required information or changed …

NestJS API CRUD Operations With MongoDB

Introduction: NestJS is a framework used to develop server-side applications. NestJS built on top of Node.js frameworks like Express. It is a combination of Progressive Javascript, Object-Oriented Programming, Functional Programming, and Functional Reactive Programming.
Nest CLI Installation: Using Nest CLI we are able to generate the NestJS starter project with the default template. To install Nest CLI globally over our system open command prompt and run the command
npm i -g @nestjs/cli Now create a sample project by using Nest CLI command  nest new your_project_name package.json: Now open the package.json file from the sample application created, you can observe few properties like "scripts", "dependencies", and "devDependencies".
"dependencies" contains all plugins to be installed and used them to run the application.
"devDependencies" contain all plugins to be installed and used them at the time of application development.
"scrip…

How Response Caching Works In Asp.Net Core

What Is Response Caching?: Response Caching means storing of response output and using stored response until it's under it's the expiration time. Response Caching approach cuts down some requests to the server and also reduces some workload on the server. Response Caching Headers: Response Caching carried out by the few Http based headers information between client and server.
Main Response Caching Headers are like below
Cache-ControlPragmaVary Cache-Control Header: Cache-Control header is the main header type for the response caching. Cache-Control will be decorated with the following directives. public - this directive indicates any cache may store the response.private - this directive allows to store response with respect to a single user and can't be stored with shared cache stores.max-age - this directive represents a time to hold a response in the cache.no-cache - this directive represents no storing of response and always fetch the fresh response from serverno-store…