Identity In Asp.Net Core Complete Guide

Prerequisites

• .NET SDK installed (preferably the latest LTS version).
• Visual Studio or Visual Studio Code with C# development tools installed.

Step-by-Step Guide to Setting Up ASP.NET Core Identity

Step 1: Create a New ASP.NET Core MVC Project

1. Open a terminal or command prompt.
2. Run the following command to create a new ASP.NET Core MVC project:

   dotnet new mvc -n IdentityApp
   

3. Navigate to the project directory:

   cd IdentityApp
   

Step 2: Install ASP.NET Core Identity NuGet Packages

1. Run the following command to add the necessary Identity packages:

   dotnet add package Microsoft.AspNetCore.Identity.EntityFrameworkCore
   dotnet add package Microsoft.EntityFrameworkCore.SqlServer
   dotnet add package Microsoft.EntityFrameworkCore.Tools
   

Step 3: Configure Services in Startup.cs (or Program.cs for .NET 6 and later)

In .NET Core 3.x and earlier, configure the identity service in Startup.cs. In .NET 6 and later, this is done in Program.cs.

For .NET 6 and later:

using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using IdentityApp.Data; // Make sure to create the Data folder later
using IdentityApp.Models;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllersWithViews();
builder.Services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));

builder.Services.AddDefaultIdentity<IdentityUser>(options => options.SignIn.RequireConfirmedAccount = true)
    .AddEntityFrameworkStores<ApplicationDbContext>();

var app = builder.Build();

// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Home/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();

app.UseAuthentication(); // Make sure this is before UseAuthorization
app.UseAuthorization();

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

app.Run();

For .NET Core 3.x and earlier:

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Identity;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using IdentityApp.Data; // Make sure to create the Data folder later
using IdentityApp.Models;

public class Startup
{
    public IConfiguration Configuration { get; }

    public Startup(IConfiguration configuration)
    {
        Configuration = configuration;
    }

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddDbContext<ApplicationDbContext>(options =>
            options.UseSqlServer(
                Configuration.GetConnectionString("DefaultConnection")));

        services.AddDefaultIdentity<IdentityUser>(options => options.SignIn.RequireConfirmedAccount = true)
            .AddEntityFrameworkStores<ApplicationDbContext>();

        services.AddControllersWithViews();
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }
        else
        {
            app.UseExceptionHandler("/Home/Error");
            app.UseHsts();
        }

        app.UseHttpsRedirection();
        app.UseStaticFiles();

        app.UseRouting();

        app.UseAuthentication();
        app.UseAuthorization();

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

Step 4: Create the Database Context

1. Create a new folder named Data in the root of your project.
2. Inside the Data folder, create a file named ApplicationDbContext.cs:

using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore;

namespace IdentityApp.Data
{
    public class ApplicationDbContext : IdentityDbContext<IdentityUser>
    {
        public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
            : base(options)
        {
        }
    }
}

Step 5: Configure the Connection String

1. Open the appsettings.json file and add a connection string:

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=IdentityAppDb;Trusted_Connection=True;MultipleActiveResultSets=true"
  },
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "AllowedHosts": "*"
}

Step 6: Apply Migrations

1. Run the following commands to create and apply migrations:

   dotnet tool install --global dotnet-ef
   dotnet ef migrations add InitialCreate
   dotnet ef database update
   

Step 7: Add Login and Register Pages

1. Add the Account Controller: Create a new folder named Controllers if it doesn't exist and add a file named AccountController.cs:

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using System.Threading.Tasks;

namespace IdentityApp.Controllers
{
    public class AccountController : Controller
    {
        private readonly UserManager<IdentityUser> _userManager;
        private readonly SignInManager<IdentityUser> _signInManager;
        private readonly ILogger<AccountController> _logger;

        public AccountController(
            UserManager<IdentityUser> userManager,
            SignInManager<IdentityUser> signInManager,
            ILogger<AccountController> logger)
        {
            _userManager = userManager;
            _signInManager = signInManager;
            _logger = logger;
        }

        [HttpGet]
        public IActionResult Register(string returnUrl = null)
        {
            ViewData["ReturnUrl"] = returnUrl;
            return View();
        }

        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> Register(RegisterViewModel model, string returnUrl = null)
        {
            ViewData["ReturnUrl"] = returnUrl;
            if (ModelState.IsValid)
            {
                var user = new IdentityUser { UserName = model.Email, Email = model.Email };
                var result = await _userManager.CreateAsync(user, model.Password);
                if (result.Succeeded)
                {
                    _logger.LogInformation("User created a new account with password.");

                    await _signInManager.SignInAsync(user, isPersistent: false);
                    return RedirectToLocal(returnUrl);
                }
                AddErrors(result);
            }

            return View(model);
        }

        [HttpGet]
        public IActionResult Login(string returnUrl = null)
        {
            ViewData["ReturnUrl"] = returnUrl;
            return View();
        }

        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> Login(LoginViewModel model, string returnUrl = null)
        {
            ViewData["ReturnUrl"] = returnUrl;
            if (ModelState.IsValid)
            {
                var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, lockoutOnFailure: false);
                if (result.Succeeded)
                {
                    _logger.LogInformation("User logged in.");
                    return RedirectToLocal(returnUrl);
                }
                if (result.IsLockedOut)
                {
                    _logger.LogWarning("User account locked out.");
                    return RedirectToAction(nameof(Lockout));
                }
                else
                {
                    ModelState.AddModelError(string.Empty, "Invalid login attempt.");
                    return View(model);
                }
            }

            return View(model);
        }

        [HttpGet]
        [AllowAnonymous]
        public IActionResult Lockout()
        {
            return View();
        }

        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> Logout()
        {
            await _signInManager.SignOutAsync();
            _logger.LogInformation("User logged out.");
            return RedirectToAction(nameof(HomeController.Index), "Home");
        }

        private void AddErrors(IdentityResult result)
        {
            foreach (var error in result.Errors)
            {
                ModelState.AddModelError(string.Empty, error.Description);
            }
        }

        private IActionResult RedirectToLocal(string returnUrl)
        {
            if (Url.IsLocalUrl(returnUrl))
            {
                return Redirect(returnUrl);
            }
            else
            {
                return RedirectToAction(nameof(HomeController.Index), "Home");
            }
        }
    }
}

2. Create Views for the Account Actions:

   • Create a folder named Account inside the Views folder.
   • Add Register.cshtml:

   @model RegisterViewModel
   @{
       ViewData["Title"] = "Register";
   }
   
   <h2>@ViewData["Title"]</h2>
   
   <form asp-route-returnUrl="@ViewData["ReturnUrl"]" method="post">
       <div asp-validation-summary="All" class="text-danger"></div>
       <div class="form-group">
           <label asp-for="Email"></label>
           <input asp-for="Email" class="form-control" />
           <span asp-validation-for="Email" class="text-danger"></span>
       </div>
       <div class="form-group">
           <label asp-for="Password"></label>
           <input asp-for="Password" class="form-control" />
           <span asp-validation-for="Password" class="text-danger"></span>
       </div>
       <div class="form-group">
           <label asp-for="ConfirmPassword"></label>
           <input asp-for="ConfirmPassword" class="form-control" />
           <span asp-validation-for="ConfirmPassword" class="text-danger"></span>
       </div>
       <button type="submit" class="btn btn-default">Register</button>
   </form>
   

   • Add Login.cshtml:

   @model LoginViewModel
   @{
       ViewData["Title"] = "Log in";
   }
   
   <h2>@ViewData["Title"]</h2>
   
   <form asp-route-returnUrl="@ViewData["ReturnUrl"]" method="post">
       <div asp-validation-summary="All" class="text-danger"></div>
       <div class="form-group">
           <label asp-for="Email"></label>
           <input asp-for="Email" class="form-control" />
           <span asp-validation-for="Email" class="text-danger"></span>
       </div>
       <div class="form-group">
           <label asp-for="Password"></label>
           <input asp-for="Password" class="form-control" />
           <span asp-validation-for="Password" class="text-danger"></span>
       </div>
       <div class="form-group">
           <div class="checkbox">
               <label asp-for="RememberMe">
                   <input asp-for="RememberMe" />
                   @Html.DisplayNameFor(m => m.RememberMe)
               </label>
           </div>
       </div>
       <button type="submit" class="btn btn-default">Log in</button>
   </form>
   

3. Add View Models RegisterViewModel and LoginViewModel:

   • Create a folder named Models if it doesn't exist.
   • Add RegisterViewModel.cs: