Relacionamento muitos pra muitos

[IuriDev26]

No módulo 3 do Curso 2808(Fundamentos do Entity Framework core) no momento em que mapeamos a classe User temos o seguinte:

Nesse caso é necessário fazer também uma classe RoleMap? Se sim é preciso repetir o mapeamento de muitos pra muitos?

[andrebaltieri]

Bom dia, @IuriDev26, como vai?

Não precisa, só precisamos fazer de um lado... não tem problema se você fizer dos dois, mas só está tendo mais trabalho.

Testa aí e me fala como foi!

[IuriDev26]

Entendi, mas Role tem outras colunas como Id, Name, Slug. Não é necessário fazer o mapeamento de muitos pra muitos em RoleMap certo? Mas no caso dessas outras propriedades, pode deixar sem fazer?

[andrebaltieri]

Se a associação (Tabela associativa) destas entidades gera informação extra, sim!
Ai você pode ter um mapeamento exclusivo para esta entidade associativa (UserRoleMap no caso) e no UserMap/RoleMap manter as referências para as listas. Aqui vão os detalhes:

Aqui está um exemplo de como mapear uma tabela associativa no Entity Framework Core quando a associação entre duas entidades possui informações adicionais.

---

1. Definição das Entidades

Temos as entidades User e Role, que possuem uma relação muitos para muitos. No entanto, a associação entre elas (UserRole) contém uma propriedade extra chamada AssignedAt, que representa a data de atribuição do papel ao usuário.

public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    public ICollection<UserRole> UserRoles { get; set; } = new List<UserRole>();
}

public class Role
{
    public int Id { get; set; }
    public string Name { get; set; }
    public ICollection<UserRole> UserRoles { get; set; } = new List<UserRole>();
}

// Tabela associativa com informação extra
public class UserRole
{
    public int UserId { get; set; }
    public User User { get; set; }
    
    public int RoleId { get; set; }
    public Role Role { get; set; }
    
    public DateTime AssignedAt { get; set; }
}

---

2. Configuração no Entity Framework Core

No DbContext, a relação precisa ser configurada manualmente para que o Entity Framework Core reconheça UserRole como uma entidade associativa com propriedades adicionais.

public class AppDbContext : DbContext
{
    public DbSet<User> Users { get; set; }
    public DbSet<Role> Roles { get; set; }
    public DbSet<UserRole> UserRoles { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // Configuração do relacionamento muitos-para-muitos com entidade associativa
        modelBuilder.Entity<UserRole>()
            .HasKey(ur => new { ur.UserId, ur.RoleId }); // Definição da chave composta

        modelBuilder.Entity<UserRole>()
            .HasOne(ur => ur.User)
            .WithMany(u => u.UserRoles)
            .HasForeignKey(ur => ur.UserId);

        modelBuilder.Entity<UserRole>()
            .HasOne(ur => ur.Role)
            .WithMany(r => r.UserRoles)
            .HasForeignKey(ur => ur.RoleId);
    }
}

---

3. Inserção de Dados

Aqui está um exemplo de como adicionar um usuário com um papel na aplicação:

using (var context = new AppDbContext())
{
    var user = new User { Name = "Alice" };
    var role = new Role { Name = "Admin" };

    var userRole = new UserRole
    {
        User = user,
        Role = role,
        AssignedAt = DateTime.UtcNow
    };

    context.Users.Add(user);
    context.Roles.Add(role);
    context.UserRoles.Add(userRole);
    
    context.SaveChanges();
}

---

4. Consulta de Usuários com seus Papéis

using (var context = new AppDbContext())
{
    var usersWithRoles = context.Users
        .Include(u => u.UserRoles)
            .ThenInclude(ur => ur.Role)
        .ToList();

    foreach (var user in usersWithRoles)
    {
        Console.WriteLine($"Usuário: {user.Name}");
        foreach (var userRole in user.UserRoles)
        {
            Console.WriteLine($" - Role: {userRole.Role.Name}, Assigned At: {userRole.AssignedAt}");
        }
    }
}

---

Resumo

• Criamos um mapeamento muitos-para-muitos com uma tabela associativa (UserRole).
• A entidade UserRole contém uma propriedade extra (AssignedAt).
• O DbContext configura essa relação manualmente com chave composta e foreign keys.
• Inserimos e consultamos os dados corretamente utilizando Include para carregar as informações.

Esse é um padrão utilizado quando uma relação muitos para muitos exige informações extras na associação.

[IuriDev26]

Fala Balta! Muito descritiva a resposta, obrigado. Mas na realidade minha dúvida era em relação ao mapeamento da Entidade Role mesmo. Porque na classe UserMap foram colocadas todas as regras para cada coluna da tabela User e também sua relação com Role. Mas e no caso da Entidade Role? Tudo bem, eu não preciso mapear o relacionamento desta com User, mas pelo fato de a Classe Role ter as suas próprias colunas(Id, Name, Slug), é necessário fazer também seu mapeamento com uma classe RoleMap? Por exemplo:

public class RoleMap : IEntityTypeConfiguration<Role>
{
    public void Configure(EntityTypeBuilder<Role> builder)
    {
        builder.ToTable("Roles");
        
        builder.HasKey(x => x.Id);
        
        builder.Property(x => x.Id)
            .HasColumnName("Id")
            .ValueGeneratedOnAdd()
            .IsRequired();
        
        builder.Property(x => x.Name)
            .HasColumnName("Name")
            .HasColumnType("NVARCHAR")
            .HasMaxLength(100)
            .IsRequired();
        
        builder.Property(x => x.Slug)
            .HasColumnName("Slug")
            .HasColumnType("NVARCHAR")
            .HasMaxLength(80)
            .IsRequired();  
    }
}
    

Precisaria fazer esse mapeamento acima?

[andrebaltieri]

@IuriDev26 boa noite! Sim, é necessário fazer o mapeamento... acredito que no curso fazemos ele...
Só a relação NxN que não precisa duplicar... você escolhe um dos dos dois para fazer!