asp.net core 3.x Identity

一、前言

這方面的資料很多，重復的寫沒必要，但是最近一直在學習身份驗證和授權相關東東，為了成體系還是寫一篇，主要是從概念上理解identity系統。

參考：https://www.cnblogs.com/r01cn/p/5179506.html

 

二、概述

幾乎所有系統都包含用戶、角色、權限、登錄、注冊等等，以前我們通常是自己來實現，定義各種實體、以及對應的Repository、Service類，其實這些功能早在.net 2.0就已有實現，並且一直在進化，要么是因為大家不了解，要么是因為覺得擴展性不強，最終使用微軟提供的用戶管理的人不多，這里就不扯以前的事了。現在的asp.net core延續了.net framework最后一次實現的Identity，暫且稱為“標識系統”吧。我的理解是它主要提供用戶管理、角色管理等功能，並且提供了相關的類與身份驗證系統結合，還包括持久化和UI，還提供了很多擴展點，當然預留了很多擴展點，也提供了默認實現，就使用起來。用還是不用了解之后再做決定也不遲。

身份驗證、授權、用戶/角色管理這三個系統是獨立的，只是授權依賴身份驗證，你要判斷某人能干啥，至少得讓他先登錄吧。所以identity系統不是必須的，但是用它比自己實現更方便。另一個原因一些開源框架對於用戶、角色、權限、登錄這些東西往往也是直接使用的微軟原生的，只是做了些許擴展和集成。

主要概念包括：

• 用戶實體：IdentityUser，對應到用戶數據表
• 用戶數據操作接口：UserStore，對用戶進行CRUD和其它功能的  與數據庫操作相關的功能
• 用戶管理器：UserManager，對用戶進行CRUD和相關操作的業務邏輯類，
• 登錄器：SignInManager提供登錄相關功能，實現identity系統和身份驗證系統的結合
• 角色實體：類別用戶
• 角色數據操作接口：類別用戶
• 角色管理器：類比用戶

默認使用EF做數據庫相關操作，當然非常容易擴展。

 

三、IdentityUser

系統中通常有兩種用戶，

• 一個是asp.net框架中的當前登錄用戶，也就是HttpContext.User，它是ClaimsPrincipal類型。它里面相對來說屬性比較少，只包含用戶id和與授權判斷相關數據，比如角色
• 一個是我們做用戶管理時的用戶實體。它包含完整的用戶信息

比如像“手機號”這個字段在用戶實體里肯定是有的，但是沒必要放進當前登錄用戶，因為這個字段不是每次請求都需要的。只要那些被平凡訪問的字段放進當前登錄用戶才比較合適。

這個用戶就是用戶實體，對應到數據庫的用戶表。用下半身也能想到它大概包含哪些屬性：id、姓名、賬號、密碼、郵箱、性別、出生年月、民族、籍貫、地址、電話、巴拉巴拉.....

大概了解了啥是用戶，我們來看看它比較特殊的幾個點

3.1、繼承結構

 public class IdentityUser<TKey>    public class IdentityUser : IdentityUser<string> 

因為在設計identity系統時，不曉得將來的開發人員希望用什么類型作為主鍵，所以定義成泛型。又由於大部分時候可能使用字符串（可能是對應guid），默認有個實現。

 

3.2、特殊字段

NormalizedUserName：標准化的用戶名，默認是直接將UserName屬性轉換為大寫，主要可能用來方便提升查詢性能的。類似的還有Email與NormalizedEmail的關系
EmailConfirmed：是否已做了郵箱確認。我們注冊用戶時會向用戶發送一封郵件，用戶進入郵箱點擊郵件中的地址進行激活，此字典就是標識是否已激活了，類似的還有手機號確認PhoneNumberConfirmed
SecurityStamp：當在后台修改用戶的跟安全相關的信息，比如修改了密碼，更新用戶到數據庫會自動更新此值，這樣用戶下次登錄時可以判斷此值變化了，要求用戶重新登錄。
ConcurrencyStamp：跟上面有點類似，不過主要是做並發沖突的，是針對整個用戶所有字段更新的，比如有兩個現成都在修改同一個用戶，會比對此字段是否另一個用戶也在修改，如果是則其中一個線程修改失敗
AccessFailedCount：登錄失敗次數，多次登錄失敗會鎖定的功能會用到此字段。

 

3.3、額外概念

UserClaims：當用戶做第三方登錄（比如：微信、google）時，可能會獲取第三方中關於用戶的額外字段，這些字段就是存儲在用戶的Claim中的，所以這是一個一對多關系，一個用戶擁有多個第三方Claim
UserLogins：用戶第三方登錄，記錄某用戶綁定的第三方登錄的信息，比如openid啥的，所以也是一對多關系，一個用戶可能綁定多個第三方登錄
UserTokens：用戶登錄 發送手機驗證碼、或郵箱激活用的驗證碼之類的，也是一對多

 

3.x、如何擴展

定義IdentityUser子類、定義UserManager子類、定義RoleManager子類 ，由於這些還沒說，所以后面講吧

 

四、跟用戶相關的數據操作接口Store

 定義一堆接口來對用戶進行管理，這些功能都是跟數據庫操作相關的。看看這些接口是干啥用的：

• IUserLoginStore：管理用戶綁定第三方登錄的數據操作相關功能，比如獲取綁定的第三方登錄列表
• IUserClaimStore：用戶做第三方登錄獲取的用戶的第三方賬號相關字段值
• IUserPasswordStore：專門針對用戶密碼的處理，比如設置獲取某用戶的密碼
• IUserSecurityStampStore：參考
• IUserEmailStore：針對用戶郵箱地址的處理
• 略....

為毛要分開定義呢？還是那個話你可以對單獨的功能進行擴展。

可以看到整個繼承體系使用了很多泛型，目的是方便我們將來進行擴展，比如：我們將來可能使用int作為用戶的主鍵、也可能自定義一個用戶子類擴展更多字段、也可能繼承Role實現更多屬性、也可能不使用EF，也可能使用EF，但是希望用自己的DBContext等等。。。。

為了將來擴展時盡量寫更少的代碼，所以實現了抽象類，也提供了默認子類，所以將來如果沒有特殊需求，對用戶管理的數據操作就完全不用自己寫，有特殊需求是簡單實現一個子類就ok拉，最最最復雜的情況我們才需要自己來實現這個接口

 

默認情況下使用UserStore這個類，它實現上面說的所有接口。

 

 

 

 

 

 

 

 

 

五、UserManager

用戶管理的業務邏輯類

內部使用IUserStore

最奇葩的是內部針對數據庫操作的上面說了分開接口定義的，但是在這個類內部使用時只注入了IUserStore，然后對特殊步驟的處理是直接拿這個強轉的。。所以將來擴展時我們必須重寫單獨那個方法，而不是只替換Store

AspNetUserManager<TUser>子類提供identity框架與asp.net框架結合的，主要就體現當前請求的CancellationToken的處理

 

待補充...........

六、SignInManager

用來結合identity系統和 身份驗證系統的，主要提供登錄、注銷相關功能。登錄又分為多種：賬號密碼登錄、第三方登錄、雙因素登錄

 

七、啟動配置

7.1、AddDefaultIdentity

1. 注冊身份驗證需要的核心服務；設置默認身份驗證方案為“Identity.Appliction”，設置默認登錄使用的身份驗證方案為"Identity.External"。
2. 注冊多個身份驗證驗證方案，其中就包含我們最常用的基於cookie的身份驗證方案以及第三方登錄、雙因素登錄等對應的身份驗證方案
3. 注冊標識系統跟用戶管理相關的各種服務（這些服務主要在UserManager中被使用）

1public static IdentityBuilder AddDefaultIdentity<TUser>(this IServiceCollection services, Action<IdentityOptions> configureOptions) where TUser : class
{
     services.AddAuthentication(o =>
     {
           o.DefaultScheme = IdentityConstants.ApplicationScheme;
           o.DefaultSignInScheme = IdentityConstants.ExternalScheme;
     })
     .AddIdentityCookies(o => { });

     return services.AddIdentityCore<TUser>(o =>
     {
           o.Stores.MaxLengthForKeys = 128;
           configureOptions?.Invoke(o);
     })
     .AddDefaultUI()
     .AddDefaultTokenProviders();
}

 

7.2、AddIdentityCookies

這里對應上面的步驟2，上面源碼第8行

添加多個基於基於cookie的身份驗證方案，具體如下：

1. 名稱=“Identity.Appliction”；　　選項類型=CookieAuthenticationOptions；　　身份驗證處理器類型=CookieAuthenticationHandler
2. 名稱=Identity.External”；   　　 選項類型=CookieAuthenticationOptions；　　身份驗證處理器類型=CookieAuthenticationHandler
3. 名稱=“Identity.TwoFactorRememberMe”；　　  選項類型=CookieAuthenticationOptions；　　身份驗證處理器類型=CookieAuthenticationHandler
4. 名稱=“Identity.TwoFactorUserId”；　　　　　　選項類型=CookieAuthenticationOptions；　　身份驗證處理器類型=CookieAuthenticationHandler

可以看到這4個身份驗證方案的身份驗證處理器和選項對象的類型都是一樣的，只是方案名稱不同，當然選項的值也不同。
第1個身份驗證方案是我們最常用的基於cookie的身份驗證，且它是默認身份驗證方案，意思是將來請求抵達時身份驗證中間件將嘗試從cookie中獲取用戶標識。
第2個身份驗證方案是跟第三方登錄相關的，第3、4個是跟雙因素登錄（估計類似手機驗證碼登錄）相關的，后期再說。 

public static class IdentityCookieAuthenticationBuilderExtensions
{
        public static IdentityCookiesBuilder AddIdentityCookies(this AuthenticationBuilder builder)
            => builder.AddIdentityCookies(o => { });

        public static IdentityCookiesBuilder AddIdentityCookies(this AuthenticationBuilder builder, Action<IdentityCookiesBuilder> configureCookies)
        {
            var cookieBuilder = new IdentityCookiesBuilder();
            cookieBuilder.ApplicationCookie = builder.AddApplicationCookie();
            cookieBuilder.ExternalCookie = builder.AddExternalCookie();
            cookieBuilder.TwoFactorRememberMeCookie = builder.AddTwoFactorRememberMeCookie();
            cookieBuilder.TwoFactorUserIdCookie = builder.AddTwoFactorUserIdCookie();
            configureCookies?.Invoke(cookieBuilder);
            return cookieBuilder;
        }

        public static OptionsBuilder<CookieAuthenticationOptions> AddApplicationCookie(this AuthenticationBuilder builder)
        {
            builder.AddCookie(IdentityConstants.ApplicationScheme, o =>
            {
                o.LoginPath = new PathString("/Account/Login");
                o.Events = new CookieAuthenticationEvents
                {
                    OnValidatePrincipal = SecurityStampValidator.ValidatePrincipalAsync
                };
            });
            return new OptionsBuilder<CookieAuthenticationOptions>(builder.Services, IdentityConstants.ApplicationScheme);
        }

        public static OptionsBuilder<CookieAuthenticationOptions> AddExternalCookie(this AuthenticationBuilder builder)
        {
            builder.AddCookie(IdentityConstants.ExternalScheme, o =>
            {
                o.Cookie.Name = IdentityConstants.ExternalScheme;
                o.ExpireTimeSpan = TimeSpan.FromMinutes(5);
            });
            return new OptionsBuilder<CookieAuthenticationOptions>(builder.Services, IdentityConstants.ExternalScheme);
        }

        public static OptionsBuilder<CookieAuthenticationOptions> AddTwoFactorRememberMeCookie(this AuthenticationBuilder builder)
        {
            builder.AddCookie(IdentityConstants.TwoFactorRememberMeScheme, o => o.Cookie.Name = IdentityConstants.TwoFactorRememberMeScheme);
            return new OptionsBuilder<CookieAuthenticationOptions>(builder.Services, IdentityConstants.TwoFactorRememberMeScheme);
        }

        public static OptionsBuilder<CookieAuthenticationOptions> AddTwoFactorUserIdCookie(this AuthenticationBuilder builder)
        {
            builder.AddCookie(IdentityConstants.TwoFactorUserIdScheme, o =>
            {
                o.Cookie.Name = IdentityConstants.TwoFactorUserIdScheme;
                o.ExpireTimeSpan = TimeSpan.FromMinutes(5);
            });
            return new OptionsBuilder<CookieAuthenticationOptions>(builder.Services, IdentityConstants.TwoFactorUserIdScheme);
        }
    }

 

7.2.1、OptionsBuilder<TOptions>

若要完全掌握asp.net core的選項模型請參考：https://www.cnblogs.com/artech/p/inside-asp-net-core-06-01.html

通常我們定義一樣選項模型的賦值邏輯是在Startup中通過如下方式來定義

public void ConfigureServices(IServiceCollection services)
{
       services.Configure<CookiePolicyOptions>(opt => {
              //選項對象的賦值邏輯
              //opt...
       });
       services.PostConfigure<CookiePolicyOptions>(opt => {
              //選項對象的覆蓋邏輯
              //opt...
       });

若我們開發一個功能組件，可以調用方一個機會可以對我們組件進行配置，通常我們提供一個選項對象，調用方可以通過上面的方式來定義選項對象的賦值邏輯，我們組件內部通過依賴注入直接使用這個選項對象就可以了。更好的方式是我們的組件向外暴露一個OptionsBuilder<TOptions>，其中TOptions就是選項類型。下面直接通過如何使用它來理解它的用途。假設我們的組件向調用方暴露一個OptionsBuilder<MyModule>

var optBuilder = //我們的模塊提供一個擴展方法返回OptionsBuilder<MyModuleOptions>
optBuilder.Configre(opt=>{
     opt.XXXX = xxx..;
     //.....
});

當然也提供了PostConfigure，可以發現返回的對象已經指明了選項對象的類型，因此后續的調用無需提供泛型參數，所以調用方會覺得這種方式更簡單；而且此Builder對象是專門針對我們的模塊的選項對象，所以更具相關性。

OptionsBuilder<TOptions>是一個通用類，所不同功能模塊的不同選項對象都可以使用它。

 

7.2.2、IdentityCookiesBuilder

public class IdentityCookiesBuilder
{
    public OptionsBuilder<CookieAuthenticationOptions> ApplicationCookie { get; set; }
    public OptionsBuilder<CookieAuthenticationOptions> ExternalCookie { get; set; }
    public OptionsBuilder<CookieAuthenticationOptions> TwoFactorRememberMeCookie { get; set; }
    public OptionsBuilder<CookieAuthenticationOptions> TwoFactorUserIdCookie { get; set; }
}

 

7.2.3、如何為每種身份驗證方案設置選項

添加一個身份驗證方案通常需要：設置方案名、指定身份驗證處理器類型、配置身份驗證選項對象。根據上面的說明及源碼我們發現AddDefaultIdentity中的AddIdentityCookies只是添加了4個身份驗證方案，分別設置了名稱，並因為AddCookie，所以都是添加的CookieAuthenticationHandler作為身份驗證處理器的，那么選項對象如何配置呢？其實就是調用AddIdentityCookies丟入一個委托進行配置的，只是AddDefaultIdentity中沒有給了一個空委托 .AddIdentityCookies(o => { }); ，完全可以通過類似如下代碼進行配置

.AddIdentityCookies(o => {
    //配置默認身份驗證的選項 
    o.ApplicationCookie.Configre(opt=>{}
        opt.....//配置
    );
    //配置第三方登錄的相關選項
    o.ExternalCookie.Configre(opt=>{}
        opt.....//配置
    );
    ....雙因素登錄...
});

遺憾的是AddDefaultIdentity沒有給我機會來配置這些選項。可能之所以叫AddDefault的原因，其實安全可以在參數中多提供一個委托，內部做下回調，從而允許我們可以進行配置。話說回來我們完全可以不使用AddDefaultIdentity，而是手動去Startup中注冊相關服務並配置選項。類似下面這樣

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

            services.AddAuthentication(o =>
            {
                o.DefaultScheme = IdentityConstants.ApplicationScheme;
                o.DefaultSignInScheme = IdentityConstants.ExternalScheme;
            }).AddApplicationCookie().Configure(opt=> { 
                //配置此方案的選項
            });
            services.AddIdentityCore<IdentityUser>(o =>
            {
                o.Stores.MaxLengthForKeys = 128;
            })
               .AddDefaultUI()
               .AddDefaultTokenProviders()
               .AddEntityFrameworkStores<ApplicationDbContext>();

 另外如果我們不配置則這些選項對象將使用默認值，參考：asp.net core 3.x 身份驗證-2啟動階段的配置

 

7.3、AddIdentityCore

對應總步驟3，注冊Identity（標識系統）跟用戶管理相關的服務。具體參考下面的源碼：

public static IdentityBuilder AddIdentityCore<TUser>(this IServiceCollection services, Action<IdentityOptions> setupAction) where TUser : class
{
     // Services identity depends on
     services.AddOptions().AddLogging();

     // Services used by identity
     services.TryAddScoped<IUserValidator<TUser>, UserValidator<TUser>>();
     services.TryAddScoped<IPasswordValidator<TUser>, PasswordValidator<TUser>>();
     services.TryAddScoped<IPasswordHasher<TUser>, PasswordHasher<TUser>>();
     services.TryAddScoped<ILookupNormalizer, UpperInvariantLookupNormalizer>();
     services.TryAddScoped<IUserConfirmation<TUser>, DefaultUserConfirmation<TUser>>();
     // No interface for the error describer so we can add errors without rev'ing the interface
     services.TryAddScoped<IdentityErrorDescriber>();
     services.TryAddScoped<IUserClaimsPrincipalFactory<TUser>, UserClaimsPrincipalFactory<TUser>>();
     services.TryAddScoped<UserManager<TUser>>();
     if (setupAction != null)
     {
          services.Configure(setupAction);
     }
     return new IdentityBuilder(typeof(TUser), services);
}

 

7.3.1、IdentityOptions

Identity系統中會用到各種配置選項就是通過它來提供的，它相當於一個選項對象的容器，里面包含各種子選項對象，看看源碼

public class IdentityOptions
{
    public ClaimsIdentityOptions ClaimsIdentity { get; set; } = new ClaimsIdentityOptions();
    public UserOptions User { get; set; } = new UserOptions();
    public PasswordOptions Password { get; set; } = new PasswordOptions();
    public LockoutOptions Lockout { get; set; } = new LockoutOptions();
    public SignInOptions SignIn { get; set; } = new SignInOptions();
    public TokenOptions Tokens { get; set; } = new TokenOptions();
    public StoreOptions Stores { get; set; } = new StoreOptions();
}

這個選項對象的賦值邏輯是通過AddDefaultIdentity的委托參數傳進來的，這意味着我們配置時可以通過如下方式來配置Identity系統的選項：

services.AddDefaultIdentity<IdentityUser>(options =>
{
      options.SignIn.RequireConfirmedAccount = true;
      options.Password.RequiredLength = 9;//密碼相關配置
      options.SignIn.RequireConfirmedEmail = true;//登錄相關配置
      //其它相關配置....
})
.AddEntityFrameworkStores<ApplicationDbContext>();

在登錄管理器SignInManager、UserManager等多個組件都會使用到此選項對象。

 

7.3.2、IdentityBuilder

AddIdentityCore方法只是注冊與用戶管理相關服務，這是一種最小注冊，如果還希望使用更多Identity系統提供的功能還需要注冊其它相關服務，注冊這些服務的方法就定義在IdentityBuilder，其實完全可以使用services進行注冊，只是使用IdentityBuilder更簡單，也跟具相關性，因為這些注冊方法都是跟Identity系統相關的。

AddIdentityCore的返回類型是IdentityBuilder、也作為AddDefaultIdentity的最終返回對象。因此我們可以在調用AddDefaultIdentity后繼續做其它服務的配置，例如在Startup中這樣：

services.AddDefaultIdentity<IdentityUser>(options => options.SignIn.RequireConfirmedAccount = true)
                .AddRoleManager<RoleManager<IdentityUser>>()//注冊角色管理器
            .AddEntityFrameworkStores<ApplicationDbContext>();//注冊基於ef的數據操作類

 

IdentityBuilder完整源碼：

public class IdentityBuilder
{
    public IdentityBuilder(Type user, IServiceCollection services)
    {
        UserType = user;
        Services = services;
    }
    public IdentityBuilder(Type user, Type role, IServiceCollection services) : this(user, services)
        => RoleType = role;
    public Type UserType { get; private set; }
    public Type RoleType { get; private set; }
    public IServiceCollection Services { get; private set; }
    private IdentityBuilder AddScoped(Type serviceType, Type concreteType)
    {
        Services.AddScoped(serviceType, concreteType);
        return this;
    }
    public virtual IdentityBuilder AddUserValidator<TValidator>() where TValidator : class
        => AddScoped(typeof(IUserValidator<>).MakeGenericType(UserType), typeof(TValidator));
    public virtual IdentityBuilder AddClaimsPrincipalFactory<TFactory>() where TFactory : class
        => AddScoped(typeof(IUserClaimsPrincipalFactory<>).MakeGenericType(UserType), typeof(TFactory));
    public virtual IdentityBuilder AddErrorDescriber<TDescriber>() where TDescriber : IdentityErrorDescriber
    {
        Services.AddScoped<IdentityErrorDescriber, TDescriber>();
        return this;
    }
    public virtual IdentityBuilder AddPasswordValidator<TValidator>() where TValidator : class
        => AddScoped(typeof(IPasswordValidator<>).MakeGenericType(UserType), typeof(TValidator));
    public virtual IdentityBuilder AddUserStore<TStore>() where TStore : class
        => AddScoped(typeof(IUserStore<>).MakeGenericType(UserType), typeof(TStore));
    public virtual IdentityBuilder AddTokenProvider<TProvider>(string providerName) where TProvider : class
        => AddTokenProvider(providerName, typeof(TProvider));
    public virtual IdentityBuilder AddTokenProvider(string providerName, Type provider)
    {
        if (!typeof(IUserTwoFactorTokenProvider<>).MakeGenericType(UserType).GetTypeInfo().IsAssignableFrom(provider.GetTypeInfo()))
        {
            throw new InvalidOperationException(Resources.FormatInvalidManagerType(provider.Name, "IUserTwoFactorTokenProvider", UserType.Name));
        }
        Services.Configure<IdentityOptions>(options =>
        {
            options.Tokens.ProviderMap[providerName] = new TokenProviderDescriptor(provider);
        });
        Services.AddTransient(provider);
        return this;
    }
    public virtual IdentityBuilder AddUserManager<TUserManager>() where TUserManager : class
    {
        var userManagerType = typeof(UserManager<>).MakeGenericType(UserType);
        var customType = typeof(TUserManager);
        if (!userManagerType.GetTypeInfo().IsAssignableFrom(customType.GetTypeInfo()))
        {
            throw new InvalidOperationException(Resources.FormatInvalidManagerType(customType.Name, "UserManager", UserType.Name));
        }
        if (userManagerType != customType)
        {
            Services.AddScoped(customType, services => services.GetRequiredService(userManagerType));
        }
        return AddScoped(userManagerType, customType);
    }
    public virtual IdentityBuilder AddRoles<TRole>() where TRole : class
    {
        RoleType = typeof(TRole);
        AddRoleValidator<RoleValidator<TRole>>();
        Services.TryAddScoped<RoleManager<TRole>>();
        Services.AddScoped(typeof(IUserClaimsPrincipalFactory<>).MakeGenericType(UserType), typeof(UserClaimsPrincipalFactory<,>).MakeGenericType(UserType, RoleType));
        return this;
    }
    public virtual IdentityBuilder AddRoleValidator<TRole>() where TRole : class
    {
        if (RoleType == null)
        {
            throw new InvalidOperationException(Resources.NoRoleType);
        }
        return AddScoped(typeof(IRoleValidator<>).MakeGenericType(RoleType), typeof(TRole));
    }
    public virtual IdentityBuilder AddPersonalDataProtection<TProtector, TKeyRing>()
        where TProtector : class,ILookupProtector
        where TKeyRing : class, ILookupProtectorKeyRing
    {
        Services.AddSingleton<IPersonalDataProtector, DefaultPersonalDataProtector>();
        Services.AddSingleton<ILookupProtector, TProtector>();
        Services.AddSingleton<ILookupProtectorKeyRing, TKeyRing>();
        return this;
    }
    public virtual IdentityBuilder AddRoleStore<TStore>() where TStore : class
    {
        if (RoleType == null)
        {
            throw new InvalidOperationException(Resources.NoRoleType);
        }
        return AddScoped(typeof(IRoleStore<>).MakeGenericType(RoleType), typeof(TStore));
    }
    public virtual IdentityBuilder AddRoleManager<TRoleManager>() where TRoleManager : class
    {
        if (RoleType == null)
        {
            throw new InvalidOperationException(Resources.NoRoleType);
        }
        var managerType = typeof(RoleManager<>).MakeGenericType(RoleType);
        var customType = typeof(TRoleManager);
        if (!managerType.GetTypeInfo().IsAssignableFrom(customType.GetTypeInfo()))
        {
            throw new InvalidOperationException(Resources.FormatInvalidManagerType(customType.Name, "RoleManager", RoleType.Name));
        }
        if (managerType != customType)
        {
            Services.AddScoped(typeof(TRoleManager), services => services.GetRequiredService(managerType));
        }
        return AddScoped(managerType, typeof(TRoleManager));
    }
}

 

八、基於RazorPages的UI

 

 

IdentityServiceCollectionExtensions

AddIdentity  ConfigureApplicationCookie ConfigureExternalCookie