C# Fluent NHibernate多对多插入问题

我有UserModel和RoleModel。我认为他们可能处于多对多关系中，因为用户可以有多个角色，而一个角色可以有多个用户。我将其设置为多对多，但当我尝试插入用户时，会出现如下错误：

INSERT语句外键约束“FK6209393F7EB4E792”与一致。“projectcoderwho”数据库“dbo.roles”列“Id”表中存在重叠。 声明已终止

我搜索了一些，但没有什么对我有用的，或者我看不到一些东西。 现在有人知道我的问题了吗

这些代码只工作过一次。但是现在我得到了上面的错误

UserModel.cs：

public class UserModel
{
    public virtual int Id { get; set; }
    public virtual DateTime RegisterDate { get; set; }
    public virtual string RegisterIp { get; set; }
    public virtual string EMail { get; set; }
    public virtual string Password { get; set; }
    public virtual string UserName { get; set; }
    public virtual string FirstName { get; set; }
    public virtual string LastName { get; set; }
    public virtual string WebSiteLink { get; set; }
    public virtual string FaceBookLink { get; set; }
    public virtual string TwitterLink { get; set; }
    public virtual string GooglePlusLink { get; set; }
    public virtual string PinterestLink { get; set; }
    public virtual IList<RoleModel> UserRole { get; set; }
    public virtual DateTime LastLogIn { get; set; }
    public virtual string LastLoginIP { get; set; }
    public virtual string About { get; set; }
    public virtual bool IsActive { get; set; }
    public virtual bool IsFreelancer { get; set; }
    public virtual bool IsBanned { get; set; }

    public UserModel()
    {
        UserRole = new List<RoleModel>();
    }

}

公共类用户模型
{
公共虚拟整数Id{get；set；}
公共虚拟日期时间注册表日期{get；set；}
公共虚拟字符串寄存器IP{get；set；}
公共虚拟字符串电子邮件{get；set；}
公共虚拟字符串密码{get；set；}
公共虚拟字符串用户名{get；set；}
公共虚拟字符串FirstName{get；set；}
公共虚拟字符串LastName{get；set；}
公共虚拟字符串网站链接{get；set；}
公共虚拟字符串FaceBookLink{get；set；}
公共虚拟字符串TwitterLink{get；set；}
公共虚拟字符串GooglePlusLink{get；set；}
公共虚拟字符串PinterestLink{get；set；}
公共虚拟IList用户角色{get；set；}
公共虚拟日期时间上次登录{get；set；}
公共虚拟字符串LastLoginIP{get；set；}
关于{get；set；}的公共虚拟字符串
公共虚拟布尔是活动的{get；set；}
公共虚拟bool是自由职业者{get；set；}
公共虚拟布尔被禁止{get；set；}
公共用户模型（）
{
UserRole=新列表（）；
}
}

RoleModel.cs

public class RoleModel
{
    //will contains as default: Admin,Moderator,Author,User
    public virtual int Id { get; set; }
    public virtual string RoleName { get; set; }
    public virtual IList<UserModel> UsersInRole { get; set; }

    public RoleModel()
    {
        UsersInRole = new List<UserModel>();
    }
}

公共类角色模型
{
//将默认包含：管理员、版主、作者、用户
公共虚拟整数Id{get；set；}
公共虚拟字符串RoleName{get；set；}
公共虚拟IList用户角色{get；set；}
公共角色模型（）
{
UsersInRole=新列表（）；
}
}

UserModelMap.cs：

public class UserModelMap : ClassMap<UserModel>
{
    public UserModelMap()
    {
        Table("Users");

        Id(x => x.Id);

        Map(x => x.RegisterDate);
        Map(x => x.RegisterIp);
        Map(x => x.EMail);
        Map(x => x.Password);
        Map(x => x.UserName);
        Map(x => x.FirstName);
        Map(x => x.LastName);
        Map(x => x.WebSiteLink);
        Map(x => x.FaceBookLink);
        Map(x => x.TwitterLink);
        Map(x => x.GooglePlusLink);
        Map(x => x.PinterestLink);
        Map(x => x.LastLogIn);
        Map(x => x.LastLoginIP);
        Map(x => x.About);
        Map(x => x.IsActive);
        Map(x => x.IsFreelancer);
        Map(x => x.IsBanned);

        HasManyToMany(x => x.UserRole).Table("UsersRoles")
            .ParentKeyColumn("RoleId")
            .ChildKeyColumn("UserId")
            .LazyLoad()
            .Cascade.All();
    }
}

public class RoleModelMap : ClassMap<RoleModel>
{
    public RoleModelMap()
    {
        Table("Roles");

        Id(x => x.Id);

        Map(x => x.RoleName);

        HasManyToMany(x => x.UsersInRole).Table("UsersRoles")
            .ParentKeyColumn("RoleId")
            .ChildKeyColumn("UserId")
            .LazyLoad()
            .Inverse();
    }
}

public类UserModelMap:ClassMap
{
公共UserModelMap（）
{
表（“用户”）；
Id（x=>x.Id）；
Map（x=>x.RegisterDate）；
Map（x=>x.RegisterIp）；
Map（x=>x.EMail）；
映射（x=>x.Password）；
映射（x=>x.UserName）；
Map（x=>x.FirstName）；
Map（x=>x.LastName）；
地图（x=>x.WebSiteLink）；
Map（x=>x.FaceBookLink）；
Map（x=>x.TwitterLink）；
Map（x=>x.GooglePlusLink）；
Map（x=>x.PinterestLink）；
Map（x=>x.LastLogIn）；
Map（x=>x.LastLoginIP）；
Map（x=>x.About）；
Map（x=>x.IsActive）；
Map（x=>x.isr）；
Map（x=>x.isbanked）；
HasManyToMany（x=>x.UserRole）.Table（“UsersRoles”）
.ParentKeyColumn（“RoleId”）
.ChildKeyColumn（“用户ID”）
.LazyLoad（）
.Cascade.All（）；
}
}

RoleModelMap.cs：

public class UserModelMap : ClassMap<UserModel>
{
    public UserModelMap()
    {
        Table("Users");

        Id(x => x.Id);

        Map(x => x.RegisterDate);
        Map(x => x.RegisterIp);
        Map(x => x.EMail);
        Map(x => x.Password);
        Map(x => x.UserName);
        Map(x => x.FirstName);
        Map(x => x.LastName);
        Map(x => x.WebSiteLink);
        Map(x => x.FaceBookLink);
        Map(x => x.TwitterLink);
        Map(x => x.GooglePlusLink);
        Map(x => x.PinterestLink);
        Map(x => x.LastLogIn);
        Map(x => x.LastLoginIP);
        Map(x => x.About);
        Map(x => x.IsActive);
        Map(x => x.IsFreelancer);
        Map(x => x.IsBanned);

        HasManyToMany(x => x.UserRole).Table("UsersRoles")
            .ParentKeyColumn("RoleId")
            .ChildKeyColumn("UserId")
            .LazyLoad()
            .Cascade.All();
    }
}

public class RoleModelMap : ClassMap<RoleModel>
{
    public RoleModelMap()
    {
        Table("Roles");

        Id(x => x.Id);

        Map(x => x.RoleName);

        HasManyToMany(x => x.UsersInRole).Table("UsersRoles")
            .ParentKeyColumn("RoleId")
            .ChildKeyColumn("UserId")
            .LazyLoad()
            .Inverse();
    }
}

public类RoleModelMap:ClassMap
{
公共角色模型映射（）
{
表（“角色”）；
Id（x=>x.Id）；
Map（x=>x.RoleName）；
HasManyToMany（x=>x.UsersInRole）.Table（“UsersRoles”）
.ParentKeyColumn（“RoleId”）
.ChildKeyColumn（“用户ID”）
.LazyLoad（）
.Inverse（）；
}
}

在UserApiController.cs中：

[Route("User/Register")]
[HttpPost]
public string RegisterUser(object regUser)
{
    RoleModel userRole = BlogModule.getUserRole();//Getting "User" role
    UserModel newUser = JsonConvert.DeserializeObject<UserModel>(regUser.ToString());
    string hashedPassword = BlogModule.PasswordToMD5(newUser.Password);
    newUser.Password = hashedPassword;
    newUser.RegisterDate = DateTime.Now;
    newUser.UserRole.Add(userRole);
    newUser.LastLogIn = DateTime.Now;
    newUser.LastLoginIP = newUser.RegisterIp;


    DbOperations.AddNewUserToDatabase(newUser);

    string sonuc = "true";
    return sonuc;
}

[路由（“用户/注册”）]
[HttpPost]
公共字符串注册器（对象注册器）
{
RoleModel userRole=BlogModule.getUserRole（）；//获取“用户”角色
UserModel newUser=JsonConvert.DeserializeObject（regUser.ToString（））；
字符串hashedPassword=BlogModule.PasswordToMD5（newUser.Password）；
newUser.Password=hashedPassword；
newUser.RegisterDate=DateTime.Now；
newUser.UserRole.Add（UserRole）；
newUser.LastLogIn=DateTime.Now；
newUser.LastLoginIP=newUser.RegisterIp；
DbOperations.AddNewUserToDatabase（newUser）；
字符串sonuc=“true”；
返回sonuc；
}

AddNewUserToDatabase（UserModel newUser）：

publicstaticvoid AddNewUserToDatabase（UserModel newUser）
{
使用（var session=NHibernateHelper.OpenSession（））
{
使用（var transaction=session.BeginTransaction（））
{
UserModel currentUser=session.QueryOver（）
.Where（x=>x.UserName==newUser.UserName）
.SingleOrDefault（）；
if（currentUser==null）
{
session.Save（newUser）；
Commit（）；
}
}
}
}

这里的要点是，当从每一方的角度观察时，

有许多映射必须颠倒。与此相反：

public UserModelMap()
{
    ...
    // here we go wrong - parent column cannot be same 
    HasManyToMany(x => x.UserRole).Table("UsersRoles")
        .ParentKeyColumn("RoleId")                     // parent column must target User
        .ChildKeyColumn("UserId")                      //   not Role
        ...

public RoleModelMap()
{
    ...
    HasManyToMany(x => x.UsersInRole).Table("UsersRoles")
        .ParentKeyColumn("RoleId")                     // parent column must target Role
        .ChildKeyColumn("UserId")                      //   here is correct
        ...

因此，我们必须切换父键列的UserModel映射：

public UserModelMap()
{
    ...
    // switch them
    HasManyToMany(x => x.UserRole).Table("UsersRoles")
        .ParentKeyColumn("UserId") // instead of("RoleId")
        .ChildKeyColumn("RoleId")  // instead of ("UserId")
        ...

public RoleModelMap()
{
    ...  // stays unchanged
    HasManyToMany(x => x.UsersInRole).Table("UsersRoles")
        .ParentKeyColumn("RoleId")
        .ChildKeyColumn("UserId")
        ...

太棒了，如果有帮助的话，请享受伟大的恩希伯内特，先生；）@RadimKöhler为什么必须像那样反转？是否有文件说明原因？