The Authorize attribute in ASP.NET Core WebAPI controller with the Roles is not work

I tried using [Authorize(Roles="role")] on my controller, but it doesn't work. Later, I checked using IsInRole to confirm if the role was successfully added, but it always shows false.

However, I found an article that had previously addressed this problem, so I tried the suggested solution, but it still didn't work.

https://stackoverflow.com/questions/53271496/asp-net-core-identity-2-user-isinrole-always-returns-false

I would like you to help me identify any issues in my code.

user.IsInRole("Developer") is return false, but _userManager.IsInRoleAsync(user1, "Developer") is return ture.

var user = HttpContext.User;
var ss = user.IsInRole("Developer"); // return false
var user1 = await _userManager.Users
                .FirstOrDefaultAsync(x => x.UserName == User.FindFirstValue(ClaimTypes.Name));
var sss = await _userManager.IsInRoleAsync(user1, "Developer");  // return true

services.AddIdentityCore<AppUser>(opt =>
            {
                opt.Password.RequireDigit = false;
                opt.Password.RequiredLength = 0;
                opt.Password.RequireLowercase = false;
                opt.Password.RequireUppercase = false;
                opt.Password.RequireNonAlphanumeric = false;
                opt.User.RequireUniqueEmail = false;
            })
            .AddRoles<IdentityRole>()
            .AddEntityFrameworkStores<DataContext>();

services.AddScoped<IUserClaimsPrincipalFactory<AppUser>,UserClaimsPrincipalFactory<AppUser, IdentityRole>>();

Here is my user registration process.

if (await _userManager.Users.AnyAsync(x => x.UserName == registerDto.Username))
{
   ModelState.AddModelError("username", "Username taken");
   return ValidationProblem();
}

var user = new AppUser
{
   DisplayName = registerDto.DisplayName,
   UserName = registerDto.Username
};
var role = registerDto.Role;

if (await _roleManager.RoleExistsAsync(role))
{
   var result = await _userManager.CreateAsync(user, registerDto.Password);

   if (result.Succeeded == false)
   {
       return BadRequest(result.Errors);
   }

   await _userManager.AddToRoleAsync(user, role);
   return await CreateUserObject(user);
}

return BadRequest($"Role {role} not found");

Updete:
It's AspNetRoles table.

Update 2:
My others setting.

services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
            .AddJwtBearer(opt =>
            {
                opt.TokenValidationParameters = new TokenValidationParameters
                {
                    ValidateIssuerSigningKey = true,
                    IssuerSigningKey = key,
                    ValidateIssuer = false,
                    ValidateAudience = false
                };
                opt.Events = new JwtBearerEvents
                {
                    OnMessageReceived = context =>
                    {
                        var accessToken = context.Request.Query["access_token"];
                        var path = context.HttpContext.Request.Path;
                        if (!string.IsNullOrEmpty(accessToken) &&
                            HubPath.CheckStartsWithSegments(path))
                        {
                            context.Token = accessToken;
                        }
                        return Task.CompletedTask;
                    }
                };
            });

builder.Services.AddControllers(opt =>
{
    var policy = new AuthorizationPolicyBuilder().RequireAuthenticatedUser().Build();
    opt.Filters.Add(new AuthorizeFilter(policy));
});

You can try the following code for a test.(.net6 api project)<br>
AspNetIdentityDbContext.cs

    public class AspNetIdentityDbContext : IdentityDbContext<IdentityUser>
{
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
optionsBuilder.UseMySql("server=192.168.2.68;database=wa99UserAuth;user=mysql1;password=Q!q11111", new MySqlServerVersion(new Version()));
}
}

program.cs

builder.Services.AddDbContext<AspNetIdentityDbContext>();
builder.Services.AddIdentity<IdentityUser, IdentityRole>()
.AddEntityFrameworkStores<AspNetIdentityDbContext>();

controller

    [ApiController]
public class ValuesController : ControllerBase
{
private readonly UserManager<IdentityUser> _userManager;
private readonly RoleManager<IdentityRole> _roleManager;
private readonly SignInManager<IdentityUser> _signInManager;
public ValuesController(UserManager<IdentityUser> userManager,RoleManager<IdentityRole> roleManager,SignInManager<IdentityUser> signInManager)
{
this._userManager = userManager;
this._roleManager = roleManager;
this._signInManager = signInManager;
}
[HttpPost("AddRole")]
public async Task<string> AddRole(string role)
{
var role2 = new IdentityRole { Name = role };         
var result = await _roleManager.CreateAsync(role2);
if (result.Succeeded)
{
return "Succeed";
}
else
{
return "Error";
}
}
[HttpPost("register")]
public async Task<string> register(string username,string password,string role)
{
var user = new IdentityUser
{
UserName = username
};
if (await _roleManager.RoleExistsAsync(role))
{
var result = await _userManager.CreateAsync(user, password);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(user, role);
return "Succeed";
}
else
{
return "Error";
}
}
else
{
return "Error";
}
}
[HttpPost("login")]
public async Task<string> login(string username,string password)
{
var result = await _signInManager.PasswordSignInAsync(username, password, true, false);
if (result.Succeeded)
{
return "Succeed";
}
else
{
return "Error";
}
}
[Authorize(Roles = "Developer")]
[HttpGet("test")]
public async Task test()
{
var user = HttpContext.User;
var ss = user.IsInRole("Developer"); 
var user1 = await _userManager.Users.FirstOrDefaultAsync(x => x.UserName == "user1");
var sss = await _userManager.IsInRoleAsync(user1, "Developer");  
}
}

Test:<br>
1.Add a role name "Developer"<br>
<br>
2.Register a user "testUser" password "Q@q11111" with role "Developer"<br>
<br>
3.Signin the user<br>
<br>
4.Run test ,ss is true