In ASP.NET Core, Identity is a membership system that allows you to add login functionality to your application. It includes features like user registration, password management, role management, and more.

Here’s a step-by-step guide to adding Identity in an ASP.NET Core application, along with an example.

Step 1: Install ASP.NET Core Identity

Start by installing the necessary NuGet packages for ASP.NET Core Identity:

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

This adds the Identity and Entity Framework Core libraries to your project.

Step 2: Configure Services in Startup.cs (or Program.cs for .NET 6+)

In ASP.NET Core 5.x and earlier, you'd typically configure services in Startup.cs. If you're using .NET 6+, you'll configure services in Program.cs. Below is how you would do it for ASP.NET Core 5.0:

In Startup.cs:

public void ConfigureServices(IServiceCollection services)
{
    // Configure Entity Framework with a SQL Server database
    services.AddDbContext<ApplicationDbContext>(options =>
        options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

    // Add Identity services
    services.AddIdentity<ApplicationUser, IdentityRole>()
        .AddEntityFrameworkStores<ApplicationDbContext>()
        .AddDefaultTokenProviders();

    // Add MVC
    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(); // Enable Authentication
    app.UseAuthorization();  // Enable Authorization

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

Step 3: Create the Application User and DbContext

You need to create a custom user class that extends IdentityUser and an ApplicationDbContext that extends IdentityDbContext.

ApplicationUser.cs:

public class ApplicationUser : IdentityUser
{
    // Add custom properties if necessary
}

ApplicationDbContext.cs:

public class ApplicationDbContext : IdentityDbContext<ApplicationUser>
{
    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
        : base(options)
    {
    }
}

Step 4: Update the Database

Create a migration and update the database to apply the changes for Identity.

dotnet ef migrations add InitialCreate
dotnet ef database update

Step 5: Set up Identity Pages or Controllers

You can use Identity's built-in Razor Pages or set up custom controllers for registration and login.

Option 1: Use Default Identity UI

You can scaffold Identity into your project using the following command to customize the Identity pages:

dotnet aspnet-codegenerator identity --useDefaultUI

This adds the default Identity UI to your project.

Option 2: Create Custom Authentication Controllers

Alternatively, you can create custom controllers for handling user registration and login.

AccountController.cs:

public class AccountController : Controller
{
    private readonly UserManager<ApplicationUser> _userManager;
    private readonly SignInManager<ApplicationUser> _signInManager;

    public AccountController(UserManager<ApplicationUser> userManager, SignInManager<ApplicationUser> signInManager)
    {
        _userManager = userManager;
        _signInManager = signInManager;
    }

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

    [HttpPost]
    public async Task<IActionResult> Register(RegisterViewModel model)
    {
        if (ModelState.IsValid)
        {
            var user = new ApplicationUser { UserName = model.Email, Email = model.Email };
            var result = await _userManager.CreateAsync(user, model.Password);

            if (result.Succeeded)
            {
                await _signInManager.SignInAsync(user, isPersistent: false);
                return RedirectToAction("Index", "Home");
            }
            foreach (var error in result.Errors)
            {
                ModelState.AddModelError(string.Empty, error.Description);
            }
        }

        return View(model);
    }

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

    [HttpPost]
    public async Task<IActionResult> Login(LoginViewModel model)
    {
        if (ModelState.IsValid)
        {
            var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, lockoutOnFailure: false);

            if (result.Succeeded)
            {
                return RedirectToAction("Index", "Home");
            }

            ModelState.AddModelError(string.Empty, "Invalid login attempt.");
        }

        return View(model);
    }
}

Views/Account/Register.cshtml:

<form asp-action="Register" method="post">
    <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" type="password" />
        <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" type="password" />
        <span asp-validation-for="ConfirmPassword" class="text-danger"></span>
    </div>
    <button type="submit" class="btn btn-primary">Register</button>
</form>

 

 

Step 6: Configure Authentication Middleware

In Startup.cs, make sure to call app.UseAuthentication() and app.UseAuthorization() within the Configure method, as shown in step 2.

Example Summary

1. Install ASP.NET Core Identity.
2. Configure services for Identity in Startup.cs.
3. Create custom ApplicationUser  ApplicationDbContext classes.
4. Apply database migrations.
5. Scaffold Identity UI or create custom controllers for registration and login.
6. Use the default or custom UI to manage authentication.

Further Customization

You can customize your Identity to suit your needs by adding roles, email confirmation, external authentication (e.g., Google, Facebook), and more.

Let me know if you'd like more details on any specific implementation part!