C# EF Core 3.1身份模型定制-我做错了什么？

不确定我做错了什么，以及为什么要为每个表创建双导航。我正在阅读来自的指南

这让我抓狂，我需要在下周上线前解决这个问题

任何帮助都将不胜感激

实体：

public class AppUser : IdentityUser<long>
    {
        public bool HasResetPassword { get; set; }
        public DateTime? LastLogIn { get; set; }
        public DateTime? DateRegistered { get; set; }
        public DateTime? RegistrationDate { get; set; }

        public override string ToString()
        {
            return UserName;
        }
        public virtual ICollection<AppUserClaim> Claims { get; set; }
        public virtual ICollection<AppUserLogin> Logins { get; set; }
        public virtual ICollection<AppUserToken> Tokens { get; set; }
        public virtual ICollection<AppUserRole> UserRoles { get; set; }


    }
    public class AppRole : IdentityRole<long>
    {
        public string Description { get; set; }
        public virtual ICollection<AppUserRole> UserRoles { get; set; }

        public override string ToString()
        {
            return $"{Name} - {Description}";
        }
    }
    public class AppUserRole : IdentityUserRole<long>
    {
        public virtual AppUser User { get; set; }
        public virtual AppRole Role { get; set; }
    }
    public class AppUserClaim : IdentityUserClaim<long>
    {
        public virtual AppUser User { get; set; }
    }

    public class AppUserLogin : IdentityUserLogin<long>
    {
        public virtual AppUser User { get; set; }
    }

    public class AppRoleClaim : IdentityRoleClaim<long>
    {
        public virtual AppRole Role { get; set; }
    }

    public class AppUserToken : IdentityUserToken<long>
    {
        public virtual AppUser User { get; set; }
    }```


DbContext

    public partial class ApplicationDbContext
          : IdentityDbContext<AppUser, AppRole, long, AppUserClaim, AppUserRole, AppUserLogin, AppRoleClaim, AppUserToken>
    {
        public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options) : base(options)
        {
        }

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

            foreach (var relationship in modelBuilder.Model.GetEntityTypes().SelectMany(e => e.GetForeignKeys()))
            {
                relationship.DeleteBehavior = DeleteBehavior.Restrict;
            }
            #region Identity
            modelBuilder.Entity<AppUser>(b =>
            {

                // Each User can have many UserClaims
                b.HasMany(e => e.Claims)
                    .WithOne()
                    .HasForeignKey(uc => uc.UserId)
                    .IsRequired();

                b.HasKey(u => u.Id);

                b.Property(p => p.Id).ValueGeneratedOnAdd();


                // Each User can have many UserLogins
                b.HasMany(e => e.Logins)
                    .WithOne()
                    .HasForeignKey(ul => ul.UserId)
                    .IsRequired();

                // Each User can have many UserTokens
                b.HasMany(e => e.Tokens)
                    .WithOne()
                    .HasForeignKey(ut => ut.UserId)
                    .IsRequired();

                // Each User can have many entries in the UserRole join table
                b.HasMany(e => e.UserRoles)
                    .WithOne()
                    .HasForeignKey(ur => ur.UserId)
                    .IsRequired();
            });
            modelBuilder.Entity<AppRole>(b =>
            {

                b.HasKey(u => u.Id);
                b.Property(p => p.Id).ValueGeneratedOnAdd();


                // Each Role can have many entries in the UserRole join table
                b.HasMany(e => e.UserRoles)
                   .WithOne(e => e.Role)
                   .HasForeignKey(ur => ur.RoleId)
                   .IsRequired();
            });
            modelBuilder.Entity<AppUserRole>(b =>
            {

                b.HasKey(u => new { u.RoleId, u.UserId });
            });
            modelBuilder.Entity<AppUserClaim>(b =>
            {

                b.HasKey(u => u.Id);
                b.Property(p => p.Id).ValueGeneratedOnAdd();
            });
            modelBuilder.Entity<AppUserLogin>(b =>
            {

                b.HasKey(u => new { u.LoginProvider, u.ProviderKey });
            });
            modelBuilder.Entity<AppRoleClaim>(b =>
            {

                b.HasKey(u => u.Id);
                b.Property(p => p.Id).ValueGeneratedOnAdd();
            });
            modelBuilder.Entity<AppUserToken>(b =>
            {


                b.HasKey(u => new { u.UserId, u.LoginProvider });
            });
            #endregion

公共类AppUser:IdentityUser
{
public bool HasResetPassword{get；set；}
公共日期时间？LastLogIn{get；set；}
公共日期时间？日期注册{get；set；}
公共日期时间？注册日期{get；set；}
公共重写字符串ToString（）
{
返回用户名；
}
公共虚拟ICollection声明{get；set；}
公共虚拟ICollection登录名{get；set；}
公共虚拟ICollection令牌{get；set；}
公共虚拟ICollection用户角色{get；set；}
}
公共类许可：IdentityRole
{
公共字符串说明{get；set；}
公共虚拟ICollection用户角色{get；set；}
公共重写字符串ToString（）
{
返回$“{Name}-{Description}”；
}
}
公共类AppUserRole:IdentityUserRole
{
公共虚拟AppUser用户{get；set；}
公共虚拟访问角色{get；set；}
}
公共类AppUserClaim:IdentityUserClaim
{
公共虚拟AppUser用户{get；set；}
}
公共类AppUserLogin:IdentityUserLogin
{
公共虚拟AppUser用户{get；set；}
}
公共类ApprovalClaim:IdentityRoleClaim
{
公共虚拟访问角色{get；set；}
}
公共类AppUserToken:IdentityUserToken
{
公共虚拟AppUser用户{get；set；}
}```
DbContext
公共分部类ApplicationDbContext
：IdentityDbContext
{
公共应用程序DBContext（DbContextOptions选项）：基本（选项）
{
}
...
模型创建时受保护的覆盖无效（ModelBuilder ModelBuilder）
{
基于模型创建（modelBuilder）；
foreach（modelBuilder.Model.GetEntityTypes（）中的var关系。SelectMany（e=>e.GetForeignKeys（））
{
relationship.DeleteBehavior=DeleteBehavior.Restrict；
}
#地域认同
modelBuilder.Entity（b=>
{
//每个用户可以有许多用户声明
b、 有很多（e=>e.Claims）
.WithOne（）
.HasForeignKey（uc=>uc.UserId）
.IsRequired（）；
b、 HasKey（u=>u.Id）；
b、 属性（p=>p.Id）；
//每个用户可以有多个用户登录
b、 HasMany（e=>e.Logins）
.WithOne（）
.HasForeignKey（ul=>ul.UserId）
.IsRequired（）；
//每个用户可以有许多usertoken
b、 HasMany（e=>e.Tokens）
.WithOne（）
.HasForeignKey（ut=>ut.UserId）
.IsRequired（）；
//在UserRole联接表中，每个用户可以有多个条目
b、 HasMany（e=>e.UserRoles）
.WithOne（）
.HasForeignKey（ur=>ur.UserId）
.IsRequired（）；
});
modelBuilder.Entity（b=>
{
b、 HasKey（u=>u.Id）；
b、 属性（p=>p.Id）；
//在UserRole联接表中，每个角色可以有多个条目
b、 HasMany（e=>e.UserRoles）
.WithOne（e=>e.Role）
.HasForeignKey（ur=>ur.RoleId）
.IsRequired（）；
});
modelBuilder.Entity（b=>
{
b、 HasKey（u=>new{u.RoleId，u.UserId}）；
});
modelBuilder.Entity（b=>
{
b、 HasKey（u=>u.Id）；
b、 属性（p=>p.Id）；
});
modelBuilder.Entity（b=>
{
b、 HasKey（u=>new{u.LoginProvider，u.ProviderKey}）；
});
modelBuilder.Entity（b=>
{
b、 HasKey（u=>u.Id）；
b、 属性（p=>p.Id）；
});
modelBuilder.Entity（b=>
{
b、 HasKey（u=>new{u.UserId，u.LoginProvider}）；
});
#端区

我相信你在做无用的工作，你想达到什么目的？双外键的作用是什么

如果只想向安全表添加列， 遵循这篇文章，它是用一种简单而精确的方式写的：

这是一个小例子：

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Identity;

namespace Identity.Models
{
    public class AppUser : IdentityUser
    {
        public Country Country { get; set; }

        public int Age { get; set; }

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

    public enum Country
    {
        USA, UK, France, Germany, Russia
    }
}

---

我相信你在做无用的工作，你想达到什么目的？双外键是干什么用的

如果只想向安全表添加列， 遵循这篇文章，它是用一种简单而精确的方式写的：

这是一个小例子：

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Identity;

namespace Identity.Models
{
    public class AppUser : IdentityUser
    {
        public Country Country { get; set; }

        public int Age { get; set; }

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

    public enum Country
    {
        USA, UK, France, Germany, Russia
    }
}

---

您面临的问题是什么？每个表的双外键和关系好的，但什么不起作用？您是否遇到编译错误？运行时错误？查询不起作用？发生了什么？关系已在

IdentityDbContext.OnModelCreating

中定义。是否需要重新定义它们？我没有任何说明那篇文章说你必须重新配置已经在

IdentityDbContext

中设置的实体。事实上，当查看时，onModelCreating是空的。你面临的问题是什么？每个表的双外键和关系好的，但是什么不起作用？你得到了编译错误吗？运行时错误？查询不起作用？发生了什么？关系已在

IdentityDbContext.OnModelCreating

中定义。是否需要重新定义它们？其他