Shulou(Shulou.com)06/03 Report--

In this issue, the editor will bring you about the Identity in ASP.NET Core. The article is rich in content and analyzes and narrates it from a professional point of view. I hope you can get something after reading this article.

Preface

Since the beginning of ASP.NET 2.0 in 2005, Web applications have undergone many changes in dealing with authentication and authorization, such as mobile phones, tablets and so on, so ASP.NET Membership was introduced to adapt to this change at that time, but with the development of time, some social networking sites or programs gathered a large number of users, such as Facebook,Twitter,QQ and so on. At this time, users want to be able to use their identity on these social networking sites to log on to the current site, which eliminates the trivial and necessary operation of registering, and users do not have to remember a large number of account passwords.

With the development of the Internet, more and more developers not only pay attention to the writing of specific business code, but also begin to pay attention to the unit testing of application code, which is the core of developers' attention. So in 2008, the ASP.NET team introduced the MVC framework to help developers build unit tests easily, and developers hope their Membership systems can do the same.

Based on the above, ASP.NET Identity came into being.

The problem to be solved by Identity

Many developers say they don't want to use Identity and it's much easier to implement it on their own. OK, so what's the need? Here are the requirements I give you for this mission.

Identity system

Can be used by all ASP.NET frameworks simultaneously (Web MVC,Web Forms,Web Api,SignalR)

Can be used to build Web, mobile, storage, or hybrid applications.

It can easily expand the user profile (User Profile).

It can be extended for user data.

Persistence

User information is stored in the database by default, and persistence using EF is supported. (as you can see, EF is actually just a function point of Identity.)

You can control the database schema and change the data type of the table name or primary key (int,string)

Different storage mechanisms can be used (such as NoSQL,DB2, etc.)

Unit testing

Enables WEB applications to perform unit tests and write unit tests for ASP.NET Identity

Role mechanism

Provide role mechanism, you can use different roles to limit different permissions, you can easily create roles, add roles to users, and so on.

To support Claims-based

Need to support Claims-based authentication mechanism, where the user identity is a set of Claims, a set of Claims can be more expressive than the role, and the role is only a Bool value to indicate whether or not it is a member.

Third-party social login

You can easily log in with third parties, such as Microsoft accounts, Facebook, Twitter,Google, etc., and store user-specific data.

Encapsulated as middleware

Based on middleware implementation, do not rely on specific projects

Based on Authorzation middleware implementation, instead of using FormsAuthentication to store cookie.

The NuGet package provides

Released as a Nuget package, so that it can be easily iterated and fixed by bug, and can be flexibly provided to users.

These are the requirements I put forward. If you were asked to encapsulate such a user authentication component, would you think of the above function points, and how would you design these function points?

Let's take a look at how Identity designs it.

Getting Started

Let's take a look at the way it is used from the entrance. First we open the Startup.cs file, and then add the following code:

Public class Startup {public void ConfigureServices (IServiceCollection services) {services.AddDbContext (options = > options.UseSqlServer (Configuration ["Data:DefaultConnection:ConnectionString"])); services.AddIdentity (options = > {options.Cookies.ApplicationCookie.AuthenticationScheme = "ApplicationCookie"; options.Cookies.ApplicationCookie.CookieName = "Interop";}) .AddEntityFrameworkStores () .AddDefaultTokenProviders () } public void Configure (IApplicationBuilder app) {/ / use CookieAuthentication middleware for authentication app.UseIdentity ();}}

In ConfigureServices, first the database context is registered, and then services.AddIdentity () Let's take a look at which services are registered.

Public static IdentityBuilder AddIdentity (this IServiceCollection services, Action setupAction) where TUser: class where TRole: class {/ / this is the services.AddAuthentication used by Identity (options = > {/ / This is the Default value for ExternalCookieAuthenticationScheme options.SignInScheme = new IdentityCookieOptions (). ExternalCookieAuthenticationScheme;}); / / register IHttpContextAccessor and services.TryAddSingleton (); / / Identity services services.TryAddSingleton (); services.TryAddScoped (); services.TryAddScoped () Services.TryAddScoped (); / / error description information services.TryAddScoped (); services.TryAddScoped (); / / identity party factory services.TryAddScoped (); / / three objects services.TryAddScoped (); if (setupAction! = null) {services.Configure (setupAction);} return new IdentityBuilder (typeof (TUser), typeof (TRole), services);}

After reading the above code, we basically know an architecture designed by Identity. Through this structure, we can also learn how to organize our code structure when we encapsulate a middleware, and how to use the dependency injection provided by ASP.NET Core to better decouple. Let's take a look at what we can learn from the above code:

1. In the extension method public static IdentityBuilder AddIdentity (this IServiceCollection services, Action setupAction), a parameter Action is provided. What is this used for? This is when we design a middleware, when we need external parameters, we will design an Options class to accept external parameters, and then encapsulate it as an Action delegate. Where it is used, it can be injected in the form of IOption xxx.

2. Services.TryAddScoped (), this registration method means that if it is detected that there is already an Interface or Service to be registered in the DI container, it will not be registered again. So why do you use it this way? This is because if the user has already implemented this interface and is in a registered container, the user registration is used instead of the middleware itself. Users will be able to customize the functions provided by middleware, which is the polymorphism in OO, which is the principle of Richter scale replacement.

3. If you can understand Article 2, then you should know why the IdentityErrorDescriber with the error description information is registered in the service, and it can also solve the problem that you want to prompt the account password, but the Identity output is a prompt for English problems.

4, three objects, this is the core of Identity, so to learn Identity, after reading the blog ASP.NET Core Identity introduction (1, 2), it is enough to learn these three objects.

SignInManager: mainly deals with business logic related to registration and login.

UserManager: handle user-related add and delete, change password, add and delete roles, etc.

RoleManager: role related additions, deletions, updates, etc.

Some students may be very curious, do not rely on the specific database or EF, is how to do the addition, deletion, modification and search?

At this point, several Store interfaces are needed to come in handy. The following are the Store interfaces defined in Identity:

IQueryableRoleStore

IQueryableUserStore

IRoleClaimStore

IRoleStore

IUserAuthenticationTokenStore

IUserClaimStore

IUserEmailStore

IUserLockoutStore

IUserLoginStore

IUserPasswordStore

IUserPhoneNumberStore

IUserRoleStore

IUserSecurityStampStore

IUserStore

IUserTwoFactorStore

With these interfaces, it suddenly becomes clear that Identity is a persistence mechanism implemented in this way, relying on abstract interfaces rather than specific details, which is the principle of dependency inversion in object-oriented.

Identity and EntityFramework

I believe it is easy to understand the relationship between Identity and EntityFramework after reading the previous chapter. Yes, EF is only aimed at the implementation of the above Store interface. Do not believe the source code of the screenshot:

The class files that Identity starts with are defined Entity objects that need to be persisted, and those at the end of Store are the implementations of the interface.

Third-party Identity implementation

In addition to EF is the official default persistence library, there are some third-party libraries, of course, you can also use ADO.NET or Drapper implementation.

MangoDb aims at the implementation provided by Identity: https://github.com/tugberkugurlu/AspNetCore.Identity.MongoDB

LinqToDB aims at the implementation provided by Identity: https://github.com/linq2db/LinqToDB.Identity

The above is the Identity in ASP.NET Core shared by the editor. If you happen to have similar doubts, you might as well refer to the above analysis to understand. If you want to know more about it, you are welcome to follow the industry information channel.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.