Question

我有一个非常大的数据库，我必须使用NHibernate 3.3.1 byCode映射映射两个实体（请考虑到我没有使用FluentNHibernate，但是内置映射）

实体通过唯一密钥而不是主键存在多对多关系。

以下是我的例子

    public class Achievable : Entity
    {
        public Achievable()
        {
            Uniqueidentifier = Guid.NewGuid();
        }

        public virtual string Name { get; set; }

        public virtual Guid Uniqueidentifier { get; set; }

        public virtual IList<Kitting> Kittings { get; set; }
    }

    public class Kitting : Entity
    {
        public virtual string Name { get; set; }

        public virtual IList<Achievable> Achievables { get; set; }
    }

所以我必须使用第三个表AchievableKittings通过Uniqueidentifier属性将Achievable表链接到Kitting

我编写了以下映射类：

public class AchievableMap : ClassMapping<Achievable>
{
    public AchievableMap()
    {
        Property(x => x.Name);
        Property(x => x.Uniqueidentifier, m =>
                                              {
                                                  m.Unique(true);
                                                  m.NotNullable(true);
                                              });

        Bag(x => x.Kittings, m =>
                                 {
                                     m.Table("AchievableKittings");
                                     m.Cascade(Cascade.Persist);
                                     m.Inverse(false);
                                     m.Key(k => 
                                     {
                                         k.PropertyRef(x => x.Uniqueidentifier);
                                         k.Column("aUniqueindentifier");
                                         k.ForeignKey("FK_Achievable_uniqueidentifier");
                                     });
                                 }, r => r.ManyToMany(m =>
                                                          {
                                                              m.Column("kittingId");
                                                              m.ForeignKey("FK_Kitting_kittingId");
                                                          }));
    }
}

public class KittingMap : ClassMapping<Kitting>
{
    public KittingMap()
    {
        Property(x => x.Name);

        Bag(x => x.Achievables, m =>
                                    {
                                        m.Table("AchievableKittings");
                                        m.Inverse(true);
                                        m.Key(k =>
                                                  {
                                                      k.Column("kittingId");
                                                      k.ForeignKey("FK_Kitting_kittingId");
                                                  });
                                    }, r => r.ManyToMany(m =>
                                                             {
                                                                 m.Column("aUniqueindentifier");
                                                                 m.ForeignKey("FK_Achievable_uniqueidentifier");
                                                             }));
    }
}

它接缝NHibernate忽略k.PropertyRef（x =＆gt; x.Uniqueidentifier）语句。我的主键是由身份生成的bigint。现在，当Nhiebrnate尝试创建数据库时，它会为AchievableKittings创建FK密钥，以实现可实现的primaryKey，但不能创建属性参考的独立标识符

alter table AchievableKittings 
    add constraint FK_Achievable_uniqueidentifier 
    foreign key (aUniqueindentifier) 
    references Achievable

当然它会抛出异常：

Column 'Achievable.AchievableId' is not the same data type as referencing column 'AchievableKittings.aUniqueindentifier' in foreign key 'FK_Achievable_uniqueidentifier'.

使用FluentNhibernate能够以正确的方式映射它。不幸的是我无法在当前项目中使用FluentNhibernate。

有人可以帮我解决这个问题。

Answer 1

我是这样做的，总是使用套装

Set(x => x.Users, d =>
        {
            d.Schema("dbo");
            d.Inverse(false);
            d.Access(Accessor.Property);
            d.Table("UsersRoles");
            d.Key(c => c.Column("RoleId"));
        }, r => r.ManyToMany(c => { c.Class(typeof(User)); c.Column(n => n.Name("UserId")); }));

NHibernate 3.3.1通过代码与property-ref进行多对多关系映射

1 个答案: