Asp.net Core Identity Framework Core, VS 2017

Nearly every application needs to manage users, roles, rights, authentications and authorizations. Asp.net Core works well with the default identity framework provided by .net team.

Let’s start with a blank Asp.core Project having Mvc configured.

• Open nuget package console and install Entity Framework Core package as we will be using SQL Server database for Identity Framework.
  

  PM> Install-Package Microsoft.EntityFrameworkCore.SqlServer

• Now install the Asp.net Core identity packages using following commands
  

  PM> Install-Package Microsoft.AspNetCore.Identity
  PM> Install-Package Microsoft.AspNetCore.Identity.EntityFrameworkCore

• In models folder create a new class that will hold the information related to your users. I call it “AppUser” class. AppUser should inherit the IdentiyUser class so that it can inherit the builtin features of Identity framework for a user. You can add your custom fields to AppUser as per your requirement.

  public class AppUser : IdentityUser
  {
      // no additional members are required right now
  }
  

• In models folder create a new class for database context. You can name it according to your database name. In my case it would be VenueDbContext. Your context class should inherit one of the DbContexts from the framework. Since you are interested in Identity Framework, let’s inherit from IdentityDbContext.

  public partial class VenuesDbContext : IdentityDbContext<AppUser>
  {
      public VenuesDbContext(DbContextOptions<VenuesDbContext> options) :
          base(options)
      { }
      protected override void OnModelCreating(ModelBuilder builder)
      {
          base.OnModelCreating(builder);
      }
  }
  

  Write a constructor to provide the context options using dependency injection. You will notice another override OnModelCreating in the sample code above. This method is called while creating a model, you can customize the model e.g., provide a different name of the table then the class name we are using in our context. If you provide this override make sure you are calling the base.OnModelCreating() at the beginning of your code, If you do not call the base method you will need to handle few properties of IdentityUser class for which the tables are to be created by yourself.
  Also note that we are using IdentityDbContext. This is the base class Entity Framework context used for the given IdentityUser.

• Once the context is ready, we now need to register the context with Asp.net Core middlewares. Add a configuration property of type IConfigurationRoot in the Startup class.
  

  public IConfigurationRoot Configuration { get; set; }

  Also add a constructor to the Startup class in your asp.net core application.

  public Startup(IHostingEnvironment env) {
      Configuration = new ConfigurationBuilder()
         .SetBasePath(env.ContentRootPath)
         .AddJsonFile("appsettings.json")
         .AddEnvironmentVariables()
         .Build();
  }
  

  In the constructor we are building the configuration object using a Json file “appsettings.json”. This json file will contain the connection string and other related configurations in future. Add appsettings.json file from “Add File” menu option for the project. Contents of appsettings.json file are as follows.

  {
    "ConnectionStrings": {
      "MyConnection": "Server=.\\SQLExpress;Database=VenuesDb;Trusted_Connection=True;MultipleActiveResultSets=true"
    }
  }
  

• You need to add the context with dependency injection in Startup class ConfigureServices() method.
• First we need to add database to the services

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

• Now add the identity to the services right after adding dbcontext to the services.

  services.AddIdentity<AppUser, IdentityRole>()
          .AddEntityFrameworkStores<VenuesDbContext>()
          .AddDefaultTokenProviders();
  

  While adding identity we need to inform this identity will use VenueDbContext to store and retrieve information. You also need to provide the AppUser and IdentityRole classes that you will use to manage identities.

• After registration or identity services now we can safely insturuct the middleware to use Identity. In the Configure() method of Startup class we build the request pipelines using middlewares. Right before adding Mvc, you need to add the Identity middleware.
  

  app.UseIdentity();

• Identity framework is fully configured in the application. You can now use the identity related classes in your controllers e.g.,

  namespace VenueApp.Controllers
  {
      public class HomeController : Controller
      {
          private readonly UserManager<AppUser> _userManager;
          private readonly SignInManager<AppUser> _signInManager;
          public HomeController(UserManager<AppUser> userManager,
          SignInManager<AppUser> signInManager) {
              _userManager = userManager;
              _signInManager = signInManager;
          }
          public IActionResult Index()
          {
              ContentResult content = new ContentResult();
              content.Content = "Hello World!";
              return content;
          }
      }
  }
  

• One last step is to create the database using Migrations i.e., open the nuget package console and run the following command
  

  Add-Migration create_database

• When the migration is created, you will be able to see a new folder with migration and a snapshot file. Migration file contains all the table creation related code for asp.net Identity framework.
• After adding a migration, update the database so that the newly created migration is applied on the database.
  

  PM> Update-Database

Database is created. Now run the application and use user managers and other identity framework features as per your need.

Configurations

Identity Framework can be configured with different settings for password and cookies to be used in the application. These configurations can be passed to the service in Startup class ConfigureServices() method.

services.Configure<IdentityOptions>(options =>
{
    // Password settings
    options.Password.RequireDigit = true;
    options.Password.RequiredLength = 8;
    options.Password.RequireNonAlphanumeric = false;
    options.Password.RequireUppercase = true;
    options.Password.RequireLowercase = false;
}

Along with password you can also configure

• Cookies options
• Lockouts  options
• User options
• Token options
• Claims options
• Sign-In options
• Security stamp related options

For more details
https://docs.microsoft.com/en-us/aspnet/core/security/authentication/identity-configuration