Why is UserManager.CreateIdentityAsync() looking f

问题:

I'm using Identity2.0 with MVC5 CodeFirst I have extended both the IdentityUser and IdentityRole like this:

public class ApplicationUser : IdentityUser
{
    [Required]
    [StringLength(50)]
    public string FirstName { get; set; }

    [Required]
    [StringLength(50)]
    public string LastName { get; set; }
}

public class ApplicationRole : IdentityRole
{
    [Required]
    [StringLength(50)]
    public string ProperName { get; set; }

    [Required]
    public string Description { get; set; }
}

public class MyAppDb : IdentityDbContext<ApplicationUser, ApplicationRole, string, IdentityUserLogin, IdentityUserRole, IdentityUserClaim>
{
    public MyAppDb()
        : base("MyAppDb")
    {
    }
}

Notice MyAppDb inherits from IdentityDbContext but that I pass an ApplicationRole instead of IdentityRole. My ApplicationRole inherits from IdentityRole so this should not be a problem.

BUT...

My AccountController is throwing this error:

The entity type IdentityRole is not part of the model for the current context. 

At the UserManager.CreateIdentityAsync(...) in this code:

private async Task SignInAsync(ApplicationUser user, bool isPersistent)
{
     AuthenticationManager.SignOut(DefaultAuthenticationTypes.ExternalCookie);
     var identity = await UserManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie);
     AuthenticationManager.SignIn(new AuthenticationProperties() { IsPersistent = isPersistent }, identity);
}

The user is being created here:

        var user = await UserManager.FindAsync(model.UserName, model.Password);
        if (user != null)
        {
            await SignInAsync(user, model.RememberMe);
            return RedirectToLocal(returnUrl);
        }

What is the "major malfunction"? ;)

UPDATE: I'm fairly sure the issue has something to do with the UserStore here:

    public class AccountController : Controller
    {
        public AccountController ()
            : this(new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(new MyAppDb())))
        {
        }

        public AccountController (UserManager<ApplicationUser> userManager)
        {
            UserManager = userManager;
            UserManager.PasswordValidator = (IIdentityValidator<string>)new MinimumLengthValidator(8);
            UserManager.UserValidator = new UserValidator<ApplicationUser>(UserManager) { AllowOnlyAlphanumericUserNames = false };
        }

        public UserManager<ApplicationUser> UserManager { get; private set; }
...

How do I get the UserStore to know about ApplicationRole when I can only pass it one argument?

回答1:

I solved this issue by creating an ApplicationUserStore and ApplicationUserManager:

public class ApplicationUser : IdentityUser<string, ApplicationUserLogin, ApplicationUserRole, ApplicationUserClaim>
{
    [Required]
    [StringLength(50)]
    public string FirstName { get; set; }

    [Required]
    [StringLength(50)]
    public string LastName { get; set; }

    public async Task<ClaimsIdentity> GenerateUserIdentityAsync(ApplicationUserManager manager)
    {
        // Note the authenticationType must match the one defined in CookieAuthenticationOptions.AuthenticationType
        var userIdentity = await manager.CreateIdentityAsync(this, DefaultAuthenticationTypes.ApplicationCookie);
        // Add custom user claims here
        return userIdentity;
    }

}

public class ApplicationUserLogin : IdentityUserLogin<string>
{
}

public class ApplicationUserClaim : IdentityUserClaim<string>
{
}

public class ApplicationUserRole : IdentityUserRole<string>
{
}

public class ApplicationRole : IdentityRole<string, ApplicationUserRole>
{
    [Required]
    [StringLength(50)]
    public string ProperName { get; set; }
}


public class MyAppDb : IdentityDbContext<ApplicationUser, ApplicationRole, string, ApplicationUserLogin, ApplicationUserRole, ApplicationUserClaim>
{
    public static MyAppDb Create()
    {
        return new MyAppDb();
    }

    public MyAppDb()
        : base("MyAppDb")
    {
    }
}


public class ApplicationUserStore : UserStore<ApplicationUser, ApplicationRole, string, ApplicationUserLogin, ApplicationUserRole, ApplicationUserClaim>
{
    public ApplicationUserStore(MyAppDb context)
        : base(context)
    {
    }
}

public class ApplicationUserManager : UserManager<ApplicationUser, string>
{
    public ApplicationUserManager(IUserStore<ApplicationUser, string> store)
        : base(store)
    {
    }

    public static ApplicationUserManager Create(IdentityFactoryOptions<ApplicationUserManager> options)
    {
        var manager = new ApplicationUserManager(new ApplicationUserStore(new MyAppDb()));
        // Configure the application user manager
        manager.UserValidator = new UserValidator<ApplicationUser>(manager)
        {
            AllowOnlyAlphanumericUserNames = false,
            RequireUniqueEmail = true
        };
        manager.PasswordValidator = (IIdentityValidator<string>)new MinimumLengthValidator(8);

        return manager;
    }
}

public class ApplicationRoleStore : RoleStore<ApplicationRole, string, ApplicationUserRole>
{
    public ApplicationRoleStore(MyAppDb context)
        : base(context)
    {
    }
}

public class ApplicationRoleManager : RoleManager<ApplicationRole, string>
{
    public ApplicationRoleManager(IRoleStore<ApplicationRole, string> store)
        : base(store)
    {
    }

    public static ApplicationRoleManager Create(IdentityFactoryOptions<ApplicationRoleManager> options)
    {
        var manager = new ApplicationRoleManager(new ApplicationRoleStore(new MyAppDb()));

        return manager;
    }
}