Pourquoi Asp.Net l'Identité IdentityDbContext une Boîte Noire?

Il y a un malentendu fondamental sur la manière dont DbContext œuvres. Les noms de propriété de votre DbSets dans votre contexte ne pas correspondent à des noms de table. Si quoi que ce soit, le nom de la table est basé sur le nom de la classe de l'entité réelle, mais même cela peut être substituée. Un parfait exemple est bien sûr, de votre classe d'utilisateur, qui est par défaut ApplicationUser, mais va résider dans une table appelée AspNetUsers.

Tous les DbSet propriétés dans votre contexte, déterminer est de l'API que vous utilisez pour accéder aux données via Entity Framework. IdentityDbContext implémente DbSet propriétés nom Users, Roles, etc. Donc, c'est comment accéder à ces données, pas via le nom de la table (c'est à dire context.Users).

De plus, si vous n'êtes pas satisfait d'avoir deux contextes, vous n'avez pas à garder que deux. Faites votre contexte principal hériter de IdentityDbContext<ApplicationUser> au lieu de DbContext et de tuer le scaffolding version.

Il y a certainement beaucoup de confusion autour de IdentityDbContext, une recherche rapide autour et vous trouverez beaucoup de questions à ce sujet.

ASP.NET l'Identité DbContext confusion

Comment puis-je changer les noms de table lors de l'utilisation de Visual Studio 2013 AspNet Identité?

Fusion MyDbContext avec IdentityDbContext

La réponse à toutes ces questions, nous devons d'abord comprendre comment IdentityDbContext œuvres. Pour clarifier les choses, nous devons prendre en considération que IdentityDbContext est juste une classe héritée de DbContext et pas une boîte noire!

Jetons un coup d'oeil à IdentityDbContext source:

///<summary>
///Base class for the Entity Framework database context used for identity.
///</summary>
///<typeparam name="TUser">The type of user objects.</typeparam>
///<typeparam name="TRole">The type of role objects.</typeparam>
///<typeparam name="TKey">The type of the primary key for users and roles.</typeparam>
///<typeparam name="TUserClaim">The type of the user claim object.</typeparam>
///<typeparam name="TUserRole">The type of the user role object.</typeparam>
///<typeparam name="TUserLogin">The type of the user login object.</typeparam>
///<typeparam name="TRoleClaim">The type of the role claim object.</typeparam>
///<typeparam name="TUserToken">The type of the user token object.</typeparam>
public abstract class IdentityDbContext<TUser, TRole, TKey, TUserClaim, TUserRole, TUserLogin, TRoleClaim, TUserToken> : DbContext
where TUser : IdentityUser<TKey, TUserClaim, TUserRole, TUserLogin>
where TRole : IdentityRole<TKey, TUserRole, TRoleClaim>
where TKey : IEquatable<TKey>
where TUserClaim : IdentityUserClaim<TKey>
where TUserRole : IdentityUserRole<TKey>
where TUserLogin : IdentityUserLogin<TKey>
where TRoleClaim : IdentityRoleClaim<TKey>
where TUserToken : IdentityUserToken<TKey>
{
///<summary>
///Initializes a new instance of <see cref="IdentityDbContext"/>.
///</summary>
///<param name="options">The options to be used by a <see cref="DbContext"/>.</param>
public IdentityDbContext(DbContextOptions options) : base(options)
{ }
///<summary>
///Initializes a new instance of the <see cref="IdentityDbContext" /> class.
///</summary>
protected IdentityDbContext()
{ }
///<summary>
///Gets or sets the <see cref="DbSet{TEntity}"/> of Users.
///</summary>
public DbSet<TUser> Users { get; set; }
///<summary>
///Gets or sets the <see cref="DbSet{TEntity}"/> of User claims.
///</summary>
public DbSet<TUserClaim> UserClaims { get; set; }
///<summary>
///Gets or sets the <see cref="DbSet{TEntity}"/> of User logins.
///</summary>
public DbSet<TUserLogin> UserLogins { get; set; }
///<summary>
///Gets or sets the <see cref="DbSet{TEntity}"/> of User roles.
///</summary>
public DbSet<TUserRole> UserRoles { get; set; }
///<summary>
///Gets or sets the <see cref="DbSet{TEntity}"/> of User tokens.
///</summary>
public DbSet<TUserToken> UserTokens { get; set; }
///<summary>
///Gets or sets the <see cref="DbSet{TEntity}"/> of roles.
///</summary>
public DbSet<TRole> Roles { get; set; }
///<summary>
///Gets or sets the <see cref="DbSet{TEntity}"/> of role claims.
///</summary>
public DbSet<TRoleClaim> RoleClaims { get; set; }
///<summary>
///Configures the schema needed for the identity framework.
///</summary>
///<param name="builder">
///The builder being used to construct the model for this context.
///</param>
protected override void OnModelCreating(ModelBuilder builder)
{
builder.Entity<TUser>(b =>
{
b.HasKey(u => u.Id);
b.HasIndex(u => u.NormalizedUserName).HasName("UserNameIndex").IsUnique();
b.HasIndex(u => u.NormalizedEmail).HasName("EmailIndex");
b.ToTable("AspNetUsers");
b.Property(u => u.ConcurrencyStamp).IsConcurrencyToken();
b.Property(u => u.UserName).HasMaxLength(256);
b.Property(u => u.NormalizedUserName).HasMaxLength(256);
b.Property(u => u.Email).HasMaxLength(256);
b.Property(u => u.NormalizedEmail).HasMaxLength(256);
b.HasMany(u => u.Claims).WithOne().HasForeignKey(uc => uc.UserId).IsRequired();
b.HasMany(u => u.Logins).WithOne().HasForeignKey(ul => ul.UserId).IsRequired();
b.HasMany(u => u.Roles).WithOne().HasForeignKey(ur => ur.UserId).IsRequired();
});
builder.Entity<TRole>(b =>
{
b.HasKey(r => r.Id);
b.HasIndex(r => r.NormalizedName).HasName("RoleNameIndex");
b.ToTable("AspNetRoles");
b.Property(r => r.ConcurrencyStamp).IsConcurrencyToken();
b.Property(u => u.Name).HasMaxLength(256);
b.Property(u => u.NormalizedName).HasMaxLength(256);
b.HasMany(r => r.Users).WithOne().HasForeignKey(ur => ur.RoleId).IsRequired();
b.HasMany(r => r.Claims).WithOne().HasForeignKey(rc => rc.RoleId).IsRequired();
});
builder.Entity<TUserClaim>(b => 
{
b.HasKey(uc => uc.Id);
b.ToTable("AspNetUserClaims");
});
builder.Entity<TRoleClaim>(b => 
{
b.HasKey(rc => rc.Id);
b.ToTable("AspNetRoleClaims");
});
builder.Entity<TUserRole>(b => 
{
b.HasKey(r => new { r.UserId, r.RoleId });
b.ToTable("AspNetUserRoles");
});
builder.Entity<TUserLogin>(b =>
{
b.HasKey(l => new { l.LoginProvider, l.ProviderKey });
b.ToTable("AspNetUserLogins");
});
builder.Entity<TUserToken>(b => 
{
b.HasKey(l => new { l.UserId, l.LoginProvider, l.Name });
b.ToTable("AspNetUserTokens");
});
}
}

Basé sur le code source de tout ce que vous avez à faire est de créer un DbContext qui hérite de IdentityDbContext et d'avoir accès aux classes.

public class ApplicationDbContext 
: IdentityDbContext
{
public ApplicationDbContext()
: base("DefaultConnection")
{
}
static ApplicationDbContext()
{
Database.SetInitializer<ApplicationDbContext>(new ApplicationDbInitializer());
}
public static ApplicationDbContext Create()
{
return new ApplicationDbContext();
}
//Add additional items here as needed
}

Si vous souhaitez étendre les classes ont un coup d'oeil à AspNet Identité 2.0 Extensible Modèle De Projet