.NET Core 2.1 Identity obtiene todos los usuarios con sus roles asociados

Posterior a consultar con expertos en esta materia, programadores de deferentes áreas y maestros hemos dado con la respuesta a la interrogande y la compartimos en esta publicación.

Solución:

Ahora he implementado la siguiente solución.

Como CodeNotFound señaló en los comentarios, IdentityUser solía tener un Roles propiedad. Este ya no es el caso en .NET Core. Este comentario / problema en GitHub parece ser la solución actual para .Net Core. Intenté implementarlo con el siguiente código:

Aplicación Usuario

public class ApplicationUser : IdentityUser

    public ICollection UserRoles  get; set; 

ApplicationUserRole

public class ApplicationUserRole : IdentityUserRole

    public virtual ApplicationUser User  get; set; 
    public virtual ApplicationRole Role  get; set; 

ApplicationRole

public class ApplicationRole : IdentityRole

    public ICollection UserRoles  get; set; 

DBContext

public class ApplicationDbContext
    : IdentityDbContext,
    ApplicationUserRole, IdentityUserLogin,
    IdentityRoleClaim, IdentityUserToken>

    public ApplicationDbContext(DbContextOptions options)
        : base(options)
    
    

    protected override void OnModelCreating(ModelBuilder builder)
    
        base.OnModelCreating(builder);

        builder.Entity(userRole =>
        
            userRole.HasKey(ur => new  ur.UserId, ur.RoleId );

            userRole.HasOne(ur => ur.Role)
                .WithMany(r => r.UserRoles)
                .HasForeignKey(ur => ur.RoleId)
                .IsRequired();

            userRole.HasOne(ur => ur.User)
                .WithMany(r => r.UserRoles)
                .HasForeignKey(ur => ur.UserId)
                .IsRequired();
        );
    

Puesta en marcha

services.AddIdentity(options => options.Stores.MaxLengthForKeys = 128)
            .AddEntityFrameworkStores()
            .AddDefaultTokenProviders();

Finalmente, asegúrese de que cuando lo esté usando, cargue con entusiasmo los UserRoles del usuario, y luego el Rol del UserRole así:

this.Users = userManager.Users.Include(u => u.UserRoles).ThenInclude(ur => ur.Role).ToList();

Tuve un problema donde el Role propiedad de cada uno UserRole era null y esto se resolvió agregando en el .ThenInclude(ur => ur.Role) parte.

Documento de Microsoft sobre carga ansiosa de varios niveles: https://docs.microsoft.com/en-us/ef/core/querying/related-data#including-multiple-levels

Actualización de ASP Core 2.2

Inherente de IdentityUserRole no string
También es posible que deba eliminar el código en ModelBuilder para que las migraciones funcionen.

recorre la lista de usuarios y obtiene roles de usuario llamando a la función _userManager.GetRolesAsync (usuario) y recorre los roles de usuario y los roles divididos con “,” en uno string variable

[HttpPost]
    public async Task OnPostGetPagination()
    


        var users = await _userManager.Users.ToListAsync();
        InputModel inputModel = new InputModel();
        foreach (var v in users)
        
            inputModel = new InputModel();
            var roles = await _userManager.GetRolesAsync(v);
            inputModel.Email = v.UserName;
            inputModel.role = "";
            foreach (var r in roles)
            
                if (!inputModel.role.Contains(","))
                
                    inputModel.role = r;
                
                else
                
                    inputModel.role = "," + r;
                
            
            Input2.Add(inputModel);
        


    

buena suerte

Comentario de referencia

Primero está el código para obtener datos

 public async Task> GetUserList()
        
            var userList = await (from user in _context.Users
                                  select new
                                  
                                      UserId = user.Id,
                                      Username = user.UserName,
                                      user.Email,
                                      user.EmailConfirmed,
                                      RoleNames = (from userRole in user.Roles //[AspNetUserRoles]
                                                   join role in _context.Roles //[AspNetRoles]//
                                                   on userRole.RoleId
                                                   equals role.Id
                                                   select role.Name).ToList()
                                  ).ToListAsync();

            var userListVm = userList.Select(p => new AccountViewModel
            
                UserId = p.UserId,
                UserName = p.Username,
                Email = p.Email,
                Roles = string.Join(",", p.RoleNames),
                EmailConfirmed = p.EmailConfirmed.ToString()
            );

            return userListVm;
        

En ASP.Net core 2.1, configuramos ApplicationRole de esta manera para obtener los roles de los usuarios. Necesita definir los datos que desea exponer explícitamente para que el usuario los use

public class ApplicationRole : IdentityRole
    
        public virtual ICollection> Users  get; set; 

        public virtual ICollection> Claims  get; set; 
    

Por fin

protected override void OnModelCreating(ModelBuilder modelBuilder)
        
            base.OnModelCreating(modelBuilder);

            foreach (var relationship in modelBuilder.Model.GetEntityTypes().SelectMany(e => e.GetForeignKeys()))
            
                relationship.DeleteBehavior = DeleteBehavior.Restrict;
            

            modelBuilder.Entity().HasMany(u => u.Claims).WithOne().HasForeignKey(c => c.UserId).IsRequired().OnDelete(DeleteBehavior.Cascade);
            modelBuilder.Entity().HasMany(u => u.Roles).WithOne().HasForeignKey(r => r.UserId).IsRequired().OnDelete(DeleteBehavior.Cascade);

            modelBuilder.Entity().HasMany(r => r.Claims).WithOne().HasForeignKey(c => c.RoleId).IsRequired().OnDelete(DeleteBehavior.Cascade);
            modelBuilder.Entity().HasMany(r => r.Users).WithOne().HasForeignKey(r => r.RoleId).IsRequired().OnDelete(DeleteBehavior.Cascade);

            modelBuilder.EnableAutoHistory(null);
        

El resultado será el nombre de usuario y los roles de usuario. Si el usuario tiene más de 1 función, los datos se mostrarán como este administrador, editor, etc.

El código completo se puede encontrar aquí aquí aquí y aquí Espero que esto ayude.

Eres capaz de añadir valor a nuestro contenido cooperando tu experiencia en los comentarios.

---

---

Utiliza Nuestro Buscador