许多实体到一个路口表NHibernate的造型(Many entities to one junct

我想是能够说明的集合在我的NHibernate的应用程序添加到任何我的主要实体。我可以看到你可以如何与每个实体一个单独的结表做到这一点。不过，我想能够避免这一点，只有一个路口表 - 这是可能的。

下面是到目前为止的代码，但是这将导致所有的注意事项正在加载每一个实体，我只想要加载的笔记特定实体。什么是我需要采取其他办法？

    public class Entity
    {
        public virtual int Id { get; set; }
    }

    public class EntityType1 : Entity
    {
        public EntityType1()
        {
            Notes = new List<Note>();
        }
        public virtual string EntityTypeName { get; set; }
        public virtual IList<Note> Notes {get;set;}
    }

    public class EntityType2 : Entity
    {
        public EntityType2()
        {
            Notes = new List<Note>();
        }
        public virtual string EntityType2Name { get; set; }
        public virtual IList<Note> Notes { get; set; }
    }

    public class Note
    {
        public virtual int Id { get; set; }
        public virtual IList<Entity> Entities { get; set; }
        public virtual string NoteText { get; set; }
    }
}

namespace FluentNHib.Mappings
{
    public class EntityMap : ClassMap<Entity>
    {
        public EntityMap()
        {
            Id(m => m.Id);
        }
    }
    public class EntityType1Map : ClassMap<EntityType1>
    {
        public EntityType1Map()
        {
            Id(m => m.Id);
            Map(m => m.EntityTypeName1);
            HasManyToMany(m => m.Notes).Table("EntityToNotes")
            .ParentKeyColumn("EntityId")
            .ChildKeyColumn("NoteId")
            .LazyLoad()
            .Cascade.SaveUpdate();
        }
    }

    public class EntityType2Map : ClassMap<EntityType2>
    {
        public EntityType2Map()
        {
            Id(m => m.Id);
            Map(m => m.EntityType2ame);
            HasManyToMany(m => m.Notes).Table("EntityToNotes")
            .ParentKeyColumn("EntityId")
            .ChildKeyColumn("NoteId")
            .LazyLoad()
            .Cascade.SaveUpdate();

        }
    }

    public class NoteMap : ClassMap<Note>
    {
        public NoteMap()
        {
            Id(m => m.Id);
            Map(m => m.NoteText);
        }
    }

我不知道真正的问题是什么：

... ...但是这将导致所有Notes加载每一个实体，我只想要加载的笔记特定实体...

在延迟加载的问题？或实际上是ENTITY1和ENTITY2可以具有相同的ID，所以引用混合？ （我希望，这应该是下面的答案的一部分）

无论如何，我会说，我们就可以实现你需要的东西：映射Note只用一个表EntityToNotes。 这是很好的。

但是，在一般情况下，我会从使用descourage你many-to-many 。这只是我自己的感觉，经验。下面是更多的解释一些链接：

我做很多很多不正确的使用功能NHibernate的时候？
NHibernate的你怎么一个交叉引用表映射到一个袋子？
NHibernate的：如何代表了一个一对多的关系，许多一对多的关系？

解决方案的草案：

所以，首先，我们要为两列扩展表“EntityToNotes”

EntityToNoteId列-我们需要一个新的配对对象主键
Discriminator列

鉴别器字段将被用于（几乎像一个标准继承）

插入Discriminator创建过程中价值
过滤TE IList<Notes>每实体

这可能是配对实体（包括一个抽象的基地集聚共同的东西）

public abstract class EntityToNote<TEntity>
{
    public abstract string Discriminator { get; set; }

    public virtual TEntity Entity {get;set;}
    public virtual Note    Note   {get;set;}
}
// the pairing objects
public class EntityType1ToNote : EntityToNote<EntityType1>
{
    string _discriminator = "EntityType1"; // here we set the discriminator
    public virtual string Discriminator
    {
        get { return _discriminator; }
        set { _discriminator = value; }
    }
...
// Similar for other pairing objects

实体现在将参照配对对象的列表

public class EntityType1 : Entity
{
    public virtual IList<EntityType1ToNote> Notes {get;set;}
    ...

public class EntityType2 : Entity
{
    public virtual IList<EntityType2ToNote> Notes { get; set; }
    ...

这里是映射的片段（所有其他实体将有通常的映射，包括ClassMaps为EntityType1ToNote ， EntityType2ToNote ...）

public class EntityType1Map : ClassMap<EntityType1>
{
    public EntityType1Map()
    {
        Id(m => m.Id);
        Map(m => m.EntityTypeName1);
        HasMany(m => m.Notes)
          // this "table" setting is redundant, it will come from EntityType1ToNote
          //.Table("EntityToNotes")
          .KeyColumn("EntityId")
          // here is the trick, that only related rows will be selected
          .Where("Discriminator = 'EntityType1'")
          .Cascade.AllDeleteOrphan();
    }
}

当我试图提供的链接来解释，我们获得了这样一个不少。大多使用上的配对表中多个列的能力-例如， Discriminator （以后我们可以有更多的像列SortBy ......），我们就可以使用功能强大的子查询与搜索-看到质疑的hasMany参考

而且，事实上，配对可以通过真正的继承映射......但这里的主要观点是：与其many-to-many我们介绍了配对对象，并获得了很多