NHibernate 3.2通过代码和继承实现多到任意映射

在尝试像这样映射域时，我会遇到多对多映射和继承冲突：

public class Member {
    public virtual int Id { get; set; }
    // many:
    public virtual IList<IssuedToken> IssuedTokens { get; set; }
}

public abstract class IssuedToken {
    public virtual int Id { get; set; }
    // any:
    public virtual Member Member { get; set; }
}

public class IssuedRequestToken : IssuedToken { }

public class IssuedAccessToken : IssuedToken { }

public class IssuedTokenMap : ClassMapping<IssuedToken> {
    public IssuedTokenMap() {
        Discriminator(t => {
            t.Force(true);
            t.Insert(true);
            t.Length(32);
            t.NotNullable(true);
            t.Type(NHibernateUtil.String);
            t.Column("Discriminator");
        });
    }
}

public class IssuedAccessTokenMap : SubclassMapping<IssuedAccessToken> {
    public IssuedAccessTokenMap() {
        DiscriminatorValue("IssuedAccessToken");
    }
}

public class IssuedRequestTokenMap : SubclassMapping<IssuedRequestToken> {
    public IssuedRequestTokenMap() {
        DiscriminatorValue("IssuedRequestToken");

    }
}

公共类成员{
公共虚拟整数Id{get；set；}
//许多：
公共虚拟IList IssuedTokens{get；set；}
}
公共抽象类发布完毕{
公共虚拟整数Id{get；set；}
//任何：
公共虚拟成员成员{get；set；}
}
公共类IssuedRequestToken:IssuedToken{}
公共类IssuedAccess令牌：IssuedToken{}

我将继承映射如下：

public class Member {
    public virtual int Id { get; set; }
    // many:
    public virtual IList<IssuedToken> IssuedTokens { get; set; }
}

public abstract class IssuedToken {
    public virtual int Id { get; set; }
    // any:
    public virtual Member Member { get; set; }
}

public class IssuedRequestToken : IssuedToken { }

public class IssuedAccessToken : IssuedToken { }

public class IssuedTokenMap : ClassMapping<IssuedToken> {
    public IssuedTokenMap() {
        Discriminator(t => {
            t.Force(true);
            t.Insert(true);
            t.Length(32);
            t.NotNullable(true);
            t.Type(NHibernateUtil.String);
            t.Column("Discriminator");
        });
    }
}

public class IssuedAccessTokenMap : SubclassMapping<IssuedAccessToken> {
    public IssuedAccessTokenMap() {
        DiscriminatorValue("IssuedAccessToken");
    }
}

public class IssuedRequestTokenMap : SubclassMapping<IssuedRequestToken> {
    public IssuedRequestTokenMap() {
        DiscriminatorValue("IssuedRequestToken");

    }
}

public类IssuedTokenMap:ClassMapping{
公开发行的Tokenmap（）{
鉴别器（t=>{
t、 力（真）；
t、 插入（正确）；
t、 长度（32）；
t、 不可为空（true）；
t、 类型（NHibernateUtil.String）；
t、 列（“鉴别器”）；
});
}
}
公共类IssuedAccessTokenMap:子类映射{
公共发布的访问令牌映射（）{
鉴别器值（“IssuedAccessToken”）；
}
}
公共类IssuedRequestTokenMap:子类映射{
公开发布的RequestTokenMap（）{
鉴别器值（“IssuedRequestToken”）；
}
}

现在我想映射

IssuedToken

（许多）和

成员

（任何）关系，但我不知道怎么做！你能帮我理解和绘制这种关系吗

注意：我使用的是

NHibernate 3.2

按代码映射-不是NHibernateFluent API，也不是XML，请尝试：

public class MemberMap : ClassMapping<Member> {
    public MemberMap() {

        // add a bag -or set.
        Bag(t => t.IssuedTokens,
            bag => {
                bag.Inverse(true);
                bag.Key(k => k.Column(col => col.Name("MemberId")));
            },
            c => c.ManyToAny<int>(m => {
                m.Columns(id => {
                    id.Name("MemberId");
                    id.NotNullable(true);
                }, cls => {
                    cls.Name("Discriminator");
                    cls.NotNullable(true);
                });
                m.IdType<int>();
                m.MetaType<string>();
                m.MetaValue("IssuedAccessToken", typeof(IssuedAccessToken));
                m.MetaValue("IssuedRequestToken", typeof(IssuedRequestToken));
            }));
    }
}

公共类成员映射：类映射{
公共成员映射（）{
//添加一个包或一套。
袋子（t=>t.已发行的袋子，
袋子=>{
反方向（真）；
bag.Key（k=>k.Column（col=>col.Name（“MemberId”））；
},
c=>c.ManyToAny（m=>{
m、 列（id=>{
id.Name（“成员id”）；
id.NotNullable（true）；
}，cls=>{
cls.名称（“鉴别器”）；
cls.NotNullable（true）；
});
m、 IdType（）；
m、 元类型（）；
m、 元值（“IssuedAccessToken”，类型为（IssuedAccessToken））；
m、 MetaValue（“IssuedRequestToken”，类型为（IssuedRequestToken））；
}));
}
}

以及：

公共类IssuedTokenMap:ClassMapping{
公共发行的TokenMap（）{
鉴别器（t=>{
t、 力（真）；
t、 插入（正确）；
t、 长度（32）；
t、 不可为空（true）；
t、 类型（NHibernateUtil.String）；
t、 列（“鉴别器”）；
});
//多加一
多通（t=>t.成员，t=>{
t、 列（“成员ID”）；
t、 不可为空（true）；
}); 
} 
}

试试：

公共类成员映射：类映射{
公共成员映射（）{
//添加一个包或一套。
袋子（t=>t.已发行的袋子，
袋子=>{
反方向（真）；
bag.Key（k=>k.Column（col=>col.Name（“MemberId”））；
},
c=>c.ManyToAny（m=>{
m、 列（id=>{
id.Name（“成员id”）；
id.NotNullable（true）；
}，cls=>{
cls.名称（“鉴别器”）；
cls.NotNullable（true）；
});
m、 IdType（）；
m、 元类型（）；
m、 元值（“IssuedAccessToken”，类型为（IssuedAccessToken））；
m、 MetaValue（“IssuedRequestToken”，类型为（IssuedRequestToken））；
}));
}
}

以及：

公共类IssuedTokenMap:ClassMapping{
公共发行的TokenMap（）{
鉴别器（t=>{
t、 力（真）；
t、 插入（正确）；
t、 长度（32）；
t、 不可为空（true）；
t、 类型（NHibernateUtil.String）；
t、 列（“鉴别器”）；
});
//多加一
多通（t=>t.成员，t=>{
t、 列（“成员ID”）；
t、 不可为空（true）；
}); 
} 
}