如何将ASP.NET Core Identity与自定义用户提供程序集成实现Web API授权？

嘿，我之前刚好处理过几乎一模一样的内部业务系统场景——用ASP.NET Core Identity做授权层的「壳」，对接外部用户管理服务，你的思路方向完全正确，只是缺了几个关键的粘合点，咱们一步步拆解：

你已经实现了IUserStore<TUser>，这是基础，但要让Identity能处理授权，只需要额外实现两个和Claims/角色相关的接口就行，其他Identity的Store接口（比如IUserPasswordStore、IUserEmailStore）完全可以跳过——因为用户的所有数据都由外部服务管理，你不需要在本地处理密码、邮箱这些。

直接在你的ExternalUserStore上实现IUserClaimStore<TUser>和IUserRoleStore<TUser>，核心方法直接调用外部服务：

public class ExternalUserStore : IUserStore<ExternalIdentityUser>, 
                                IUserClaimStore<ExternalIdentityUser>,
                                IUserRoleStore<ExternalIdentityUser>
{
    private readonly IExternalUserService _externalUserService;

    public ExternalUserStore(IExternalUserService externalUserService)
    {
        _externalUserService = externalUserService;
    }

    // 你已经实现的IUserStore核心方法，比如FindByNameAsync直接调用外部服务查用户存在性
    public async Task<ExternalIdentityUser> FindByNameAsync(string normalizedUserName, CancellationToken cancellationToken)
    {
        var userExists = await _externalUserService.CheckUserExistsAsync(normalizedUserName);
        return userExists ? new ExternalIdentityUser { UserName = normalizedUserName } : null;
    }

    // --- IUserClaimStore 实现 ---
    public async Task<IList<Claim>> GetClaimsAsync(ExternalIdentityUser user, CancellationToken cancellationToken)
    {
        // 调用外部服务拿用户声明，转成Identity的Claim格式
        var externalClaims = await _externalUserService.GetUserClaimsAsync(user.UserName);
        return externalClaims.Select(ec => new Claim(ec.ClaimType, ec.ClaimValue)).ToList();
    }

    // 不需要的修改类方法直接抛异常，因为外部服务管用户数据
    public Task AddClaimAsync(ExternalIdentityUser user, Claim claim, CancellationToken cancellationToken)
    {
        throw new NotImplementedException("用户声明由外部服务管理，不支持本地修改");
    }

    // --- IUserRoleStore 实现 ---
    public async Task<IList<string>> GetRolesAsync(ExternalIdentityUser user, CancellationToken cancellationToken)
    {
        // 直接返回外部服务给的角色列表
        return await _externalUserService.GetUserRolesAsync(user.UserName);
    }

    // 同样，修改角色的方法直接抛异常
    public Task AddToRoleAsync(ExternalIdentityUser user, string roleName, CancellationToken cancellationToken)
    {
        throw new NotImplementedException("用户角色由外部服务管理，不支持本地修改");
    }

    // 其他IUserStore的空实现（比如CreateAsync、UpdateAsync）直接返回Task.CompletedTask就行，因为不需要持久化用户
    public Task<IdentityResult> CreateAsync(ExternalIdentityUser user, CancellationToken cancellationToken)
    {
        return Task.FromResult(IdentityResult.Success);
    }
}

因为登录登出由外部DLL处理，你不需要用Identity的默认登录页面，自己写一个API接口就行，核心逻辑是：

1. 调用外部DLL验证用户凭证
2. 验证通过后，通过UserManager拉取用户的声明/角色（这会自动调用你刚才实现的Store接口）
3. 生成Identity的ClaimsPrincipal，要么用Cookie登录（如果是有前端的应用），要么生成JWT（纯API场景推荐）

示例代码（纯API用JWT的情况）：

[ApiController]
[Route("api/auth")]
public class AuthController : ControllerBase
{
    private readonly IExternalAuthDll _externalAuthDll;
    private readonly UserManager<ExternalIdentityUser> _userManager;
    private readonly IConfiguration _config;

    public AuthController(IExternalAuthDll externalAuthDll, UserManager<ExternalIdentityUser> userManager, IConfiguration config)
    {
        _externalAuthDll = externalAuthDll;
        _userManager = userManager;
        _config = config;
    }

    [HttpPost("login")]
    public async Task<IActionResult> Login([FromBody] LoginRequest request)
    {
        // 第一步：调用外部DLL验证登录
        var externalLoginResult = await _externalAuthDll.ValidateCredentialsAsync(request.UserName, request.Password);
        if (!externalLoginResult.IsSuccess)
        {
            return Unauthorized($"登录失败：{externalLoginResult.ErrorMessage}");
        }

        // 第二步：通过Identity获取用户（自动调用你实现的FindByNameAsync）
        var user = await _userManager.FindByNameAsync(request.UserName);
        if (user == null)
        {
            // 外部验证通过但Identity无记录？直接创建临时用户即可，不需要持久化
            user = new ExternalIdentityUser { UserName = request.UserName };
        }

        // 第三步：拉取用户的声明和角色
        var claims = await _userManager.GetClaimsAsync(user);
        var roles = await _userManager.GetRolesAsync(user);
        var roleClaims = roles.Select(r => new Claim(ClaimTypes.Role, r));
        var allClaims = claims.Concat(roleClaims).ToList();

        // 第四步：生成JWT Token
        var token = GenerateJwtToken(allClaims);
        return Ok(new { Token = token, ExpiresIn = 3600 });
    }

    [HttpPost("logout")]
    public async Task<IActionResult> Logout()
    {
        // 先调用外部DLL的登出逻辑
        await _externalAuthDll.LogoutAsync();
        // 如果是Cookie登录，再加一句await _signInManager.SignOutAsync()
        return Ok("登出成功");
    }

    // 辅助方法：生成JWT
    private string GenerateJwtToken(IEnumerable<Claim> claims)
    {
        var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_config["Jwt:SecretKey"]));
        var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);

        var token = new JwtSecurityToken(
            issuer: _config["Jwt:Issuer"],
            audience: _config["Jwt:Audience"],
            claims: claims,
            expires: DateTime.Now.AddHours(1),
            signingCredentials: creds);

        return new JwtSecurityTokenHandler().WriteToken(token);
    }
}

在Program.cs里只需要配置你自定义的Store，不需要加EF Core的存储（因为用户数据不在本地）：

// 注册Identity，指定你的用户类型和自定义Store
builder.Services.AddIdentity<ExternalIdentityUser, IdentityRole>()
    .AddUserStore<ExternalUserStore>()
    .AddUserManager<UserManager<ExternalIdentityUser>>();

// 配置JWT认证（纯API场景）
builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuer = true,
            ValidateAudience = true,
            ValidateLifetime = true,
            ValidateIssuerSigningKey = true,
            ValidIssuer = builder.Configuration["Jwt:Issuer"],
            ValidAudience = builder.Configuration["Jwt:Audience"],
            IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(builder.Configuration["Jwt:SecretKey"]))
        };
    });

// 配置授权策略，比如要求特定角色
builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("AdminOnly", policy => policy.RequireRole("Admin"));
    options.AddPolicy("FinanceOnly", policy => policy.RequireClaim("Department", "Finance"));
});

// 最后别忘了启用认证和授权中间件
app.UseAuthentication();
app.UseAuthorization();

• 别浪费时间实现所有Identity的Store接口，只需要IUserStore+IUserClaimStore+IUserRoleStore三个就够了，其他方法要么抛异常要么空实现。
• 如果不需要持久化用户，IUserStore的CreateAsync/UpdateAsync直接返回成功就行，不需要写数据库逻辑。
• 纯API场景一定要用JWT，别用Cookie，避免跨域和状态管理的麻烦。

内容的提问来源于stack exchange，提问作者Doc