InvalidOperationException: Cannot create a DbSet for 'Role' because this type is not included in the model for the context

Question

The following solution works in .net core 1.1, but after upgrading from 1.1 to 2.0, I received the following error:

InvalidOperationException: Cannot create a DbSet for 'Role' because this type is not included in the model for the context.

When the user attempts to log in and the following statement is executed:

var result = await _signInManager.PasswordSignInAsync(model.Email, 
                                model.Password, model.RememberMe, lockoutOnFailure: false);

What is wrong?

User.cs

public partial class User : IdentityUser<Guid>
{
    public string Name { get; set; }
}

IdentityEntities.cs

public partial class UserLogin : IdentityUserLogin<Guid>
{
}
public partial class UserRole : IdentityUserRole<Guid>
{
}
public partial class UserClaim : IdentityUserClaim<Guid>
{
}
public partial class Role : IdentityRole<Guid>
{
    public Role() : base()
    { 
    }

    public Role(string roleName)
    {
        Name = roleName;
    }
}
public partial class RoleClaim : IdentityRoleClaim<Guid>
{
}
public partial class UserToken : IdentityUserToken<Guid>
{
}

ConfigureServices

services.AddIdentity<User, Role>

score 31 · Answer 1 · answered Nov 01 '18 at 15:29

31

Check that your AppDbContext is NOT inherited from DbContext but instead it should be inherited from IdentityDbContext<ApplicationUser>

answered Nov 01 '18 at 15:29

MaylorTaylor

4,671
16
47
76

1

Unfortunately, this is no option if your `ApplicationUser` inherits `IdentityUser` for a different key type, as IdentityDbContext has the generic restriction `where T : IdentityUser`. – Martin Braun Feb 11 '19 at 00:49
1

This actually sorted my issue. Originally, the ApplicationDbContext was inheriting from IdentityDbContext (without specifying the custom user class). Once specified, the migration recognised and added the changes. Thanks, @MaylorTaylor! – army Feb 23 '19 at 23:51

score 21 · Accepted Answer · edited Oct 25 '17 at 13:37

21

Added this and it worked:

builder.Entity<IdentityUserRole<Guid>>().HasKey(p => new { p.UserId, p.RoleId });

edited Oct 25 '17 at 13:37

answered Oct 19 '17 at 00:20

001

62,807
94
230
350

5

When I do that, A new table "IdentityUserRole" is created in the SQL Server DB. I already added builder.Entity().HasKey(ur => new { ur.UserId, ur.RoleId }), why is it not enough? – Cedric Arnould Sep 08 '18 at 04:28
2

added it where? – niico May 22 '20 at 14:47
1

@niico Put it in `OnModelCreating` – Mohammad Taherian Jul 13 '20 at 21:34

Gurpreet · Answer 3 · 2017-10-27T09:44:14.337

The most common reasons for

Cannot create a DbSet for 'THE-MODEL' because this type is not included in the model for the context

are as follows

The model name does not match with the table name in database
EntityFramework cannot figure out required meta by convention and you have not overriden it.

in your case Role inherits IdentityRoleClaim and that was not configured and default convention required "Id" as key but i suppose it did not have that property so it had to be configured. It would also have worked if you created property in Role like Id => new{UserId,RoleId} which would by convention present Id as the key property to entity framework.

Munam Yousuf · Answer 4 · 2020-04-14T10:00:59.337

10

You can fix the issue by replacing this

public class ApplicationDbContext : IdentityDbContext<AppUser>

with this

public class ApplicationDbContext : IdentityDbContext<AppUser, AppRole, string>

notice this string type in the last argument.

edited Apr 14 '20 at 10:00

answered Jan 29 '20 at 04:46

Munam Yousuf

431
1
6
17

score 9 · Answer 5 · answered Oct 11 '18 at 09:43

If your DbContext doesn't inherit IdentityUserContext - don't use AddEntityFrameworkStores in the ConfigureServices method. Substitute it with AddUserStore and AddRoleStore as follows:

public void ConfigureServices(IServiceCollection services)
{
    ...
    services
        .AddIdentity<MyUserType, MyRoleType>(...)
        .AddUserStore<UserStore<MyUserType, MyRoleType, MyDbContextType, MyKeyType, MyUserClaimType, MyUserRoleType, MyUserLoginType, MyUserTokenType, MyRoleClaimType>>()
        .AddRoleStore<RoleStore<MyRoleType, MyDbContextType, MyKeyType, MyUserRoleType, MyRoleClaimType>>();
    ...
}

If you check the implementation of the AddEntityFrameworkStores method you'll see that it adds stores via searching for generic types in the DbContext, assuming that it inherits IdentityUserContext. Regardless, you'll be stuck with the base Identity* types for claims ... which will generate this exception.

This is the right thing to do, thank you so much. Further notice: `UserStore` and `RoleStore` are in the `Microsoft.AspNetCore.Identity.EntityFrameworkCore` namespace. — Martin Braun, Feb 11 '19 at 01:00

score 4 · Answer 6 · answered May 25 '19 at 19:52

4

I fixed this by adding:

public DbSet<ApplicationRole> ApplicationRoles { get; set; }

to my DbContext.

answered May 25 '19 at 19:52

Simon Morgan

2,018
5
23
36

score 1 · Answer 7 · answered Sep 18 '21 at 00:25

I had the same issue and I found that I didn't include it in the RoleStore and in the UserStore so, You need to do the following In the ApplicationDbContext

public class ApplicationDbContext: IdentityDbContext<User, Role, GUID, UserClaim, UserRole, UserLogin, RoleClaim, UserToken>
{}

You need to add Role, UserRole in the stores as follows:

create a class that inherits from RoleStore as follows

public class AppRoleStore : RoleStore<Role, ApplicaitonDbContext, GUID, UserRole, RoleClaim>{}

2)Create class for the UserStore as follow

public class AppUserStore : UserStore<User, Role, ApplicationDbContext, GUID, UserClaim, UserRole, UserLogin, UserToken, RoleClaim>
    {}

Mohammad Reza Farahani · Answer 8 · 2018-09-17T19:08:43.023

I had the similar problem, this was from the bad configuration for IUserStore in my case. I'm using Autofac for dependency injection and this configuration solved my problem:

var dbContextParameter = new ResolvedParameter((pi, ctx) => pi.ParameterType == typeof(IdentityDbContext),
                                                    (pi, ctx) => ctx.Resolve<DatabaseContext>());

  builder.RegisterType<UserStore<User, Role, DatabaseContext, Guid,UserClaim,UsersInRole,UserLogin,UserToken,RoleClaim>>()
            .As<IUserStore<User>>().WithParameter(dbContextParameter).InstancePerLifetimeScope();
        builder.RegisterType<CustomRoleStore>()
            //RegisterType<UserStore<User, Role, DatabaseContext, Guid,UserClaim,UsersInRole,UserLogin,UserToken,RoleClaim>>()
            .As<IRoleStore<Role>>().WithParameter(dbContextParameter).InstancePerLifetimeScope();

My databaseContext drives from IdentityDbContext

 public class DatabaseContext : IdentityDbContext<User, Role, Guid, UserClaim
    , UsersInRole, UserLogin, RoleClaim, UserToken
    >, IDatabaseContext

and all I had to do was to Create a Userstore and give it to my DI to inject into signinmanager class

score 0 · Answer 9 · answered Aug 16 '19 at 19:31

Add your models in the DBContext using model builder. Write your DB Context class as below.

 public partial class CDBContext : DbContext
   {

    public CDBContext (string ConnectionString) : base(new DbContextOptionsBuilder().UseSqlServer(ConnectionString).Options)
    {

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

        modelBuilder.Query<MediaData>();            
    }

score 0 · Answer 10 · answered Dec 09 '20 at 15:48

In my case I passed wrong class to EF DbContext. I had 2 classes, first one "Accounting" and the second one "Account". I sent "Accounting" , which EF-Dbcontext didn't have the entity and returned

Cannot create a DbSet for 'Accounting' because this type is not included in the model for the context.

Please check your class, which you want to send to your DbContext.

score 0 · Answer 11 · edited Jan 17 '21 at 05:45

You need to check that your AppDbContext is inherited from IdentityDbContext or not. Your AppDbContext must inherit from IdentityDbContext.

Then OnModelCreating you need to map relations like in below -

builder.Entity<ApplicationUserRole>(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();
     });

Overall Application Db Context will looks like -

       using Core.Entities.Identity;
       using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
       using Microsoft.EntityFrameworkCore;

       namespace Infrastructure.Identity
       {
           public class AppIdentityDbContext : IdentityDbContext<AppUser, ApplicationRole, 
           string, IdentityUserClaim<string>,
           ApplicationUserRole, IdentityUserLogin<string>, IdentityRoleClaim<string>, 
           IdentityUserToken<string>>
           {
              public AppIdentityDbContext(DbContextOptions<AppIdentityDbContext> options) : 
              base(options)
         {
         }

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

             builder.Entity<ApplicationUserRole>(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();
             });

          }
       }
    }

Hope your problem will resolve.

score 0 · Answer 12 · answered Mar 02 '22 at 11:31

0

I had this error as well, guide to get it working using EF Core 5.0 and EF Core 6.0 here:

https://stackoverflow.com/a/71321924/3850405

answered Mar 02 '22 at 11:31

Ogglas

62,132
37
328
418

score 0 · Answer 13 · answered Aug 25 '22 at 17:19

Also had this problem. I was calling a stored procedure and passing back a scalar value by name that did not correspond to table structure at all:

result = db.Set<*Object*>()
    .FromSqlRaw($"EXECUTE [dbo].[*StoredProcedure*] {*var*}")
    .AsEnumerable()
    .First().*ScalarValueFromProcedure*;

Object name differed from the table DbSet name. It worked initially, but somehow broke along the way. Creating a DbSet<Object> fixed it.

Marcos Leao · Answer 14 · 2018-11-29T22:36:06.247

I had this problem. To fixed it, I did some changes in my Entity Config Class.

public class AspNetUserClaimsConfig : IEntityTypeConfiguration<IdentityUserClaim<string>>
{
    public void Configure(EntityTypeBuilder<IdentityUserClaim<string>> builder)
    {
        builder.ToTable("AspNetUserClaims", "Identity");

        // Primary key
         builder.HasKey(uc => uc.Id);
    }
}

In my context I did this:

public class IdentityContext : DbContext
{
    public IdentityContext(DbContextOptions<IdentityContext> options) : base(options)
    {
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.ApplyConfiguration(new ApplicationUsersConfig());

        base.OnModelCreating(modelBuilder);
    }
}

InvalidOperationException: Cannot create a DbSet for 'Role' because this type is not included in the model for the context

14 Answers14

Linked