Fluent NHibernate使用子类关系自动继承

我在使用Fluent NHibernate自动化继承时遇到了问题 . 下面是我的实体设置（简称为简称） . 我已经将Fluent NHibernate配置为使用discriminator列为层次结构创建1个类 . 自动化似乎正常工作，因为当我生成数据库时，创建一个名为“AddressBase”的表，其中一个鉴别器列表示每行的地址类型 .

问题在于，当我在UserAccount类上调用方法“GetPrimaryBillingAddress（）”时，NHibernate正在创建一个查看Billing和Shipping Addresses的查询，而不仅仅是查询Billing Addresses . 它根本没有考虑到鉴别器 . 我假设我可以设置某种配置，但无法找到任何东西 .

public abstract class AddressBase : ActiveRecord<AddressBase>
{
    public virtual long Id { get; set; }

    public virtual string Address1 { get; set; }

}

public class AddressBilling : AddressBase
{
    public class TypedQuery : ActiveRecordQuery<AddressBilling> { }

    public virtual bool IsPrimary { get; set; }
}

public class AddressShipping : AddressBase
{
    public class TypedQuery : ActiveRecordQuery<AddressShipping> { }

    [Display(Name = "Is Primary")]
    public virtual bool IsPrimary { get; set; }

}

public class UserAccount : ActiveRecord<UserAccount>
{
    public virtual long Id { get; set; }

    public virtual IList<AddressBilling> BillingAddresses { get; set; }
    public virtual IList<AddressShipping> ShippingAddresses { get; set; }

    public UserAccount()
    {
        BillingAddresses = new List<AddressBilling>();
        ShippingAddresses = new List<AddressShipping>();
    }

    public virtual AddressBilling GetPrimaryBillingAddress()
    {
        if (BillingAddresses.Any(x => x.IsPrimary))
        {
            return BillingAddresses.Single(x => x.IsPrimary);
        }

        return BillingAddresses.FirstOrDefault();
    }

    public virtual AddressShipping GetPrimaryShippingAddress()
    {
        if (ShippingAddresses.Any(x => x.IsPrimary)) {
            return ShippingAddresses.Single(x => x.IsPrimary);            
        }

        return ShippingAddresses.FirstOrDefault();
    }

}

UPDATE: 这是自动化中使用的映射覆盖函数：

private static FluentConfiguration GetFluentConfiguration(string connectionStringName = "CS")
{
        var autoMapping = AutoMap
            .AssemblyOf<Product>(new Mapping.AutoMappingConfiguration())
            .Conventions.Setup(c =>
            {
                c.Add<Mapping.ForeignKeyConvention>();
                c.Add<Mapping.DiscriminatorConvention>();
            })
            .IgnoreBase<AddressBilling.TypedQuery>()
            .IgnoreBase<AddressShipping.TypedQuery>()
            .IncludeBase<AddressBase>();

        return Fluently.Configure()
            .Database(MsSqlConfiguration.MsSql2005.ConnectionString(c => c.FromConnectionStringWithKey(connectionStringName)))
            .Mappings(m => m.AutoMappings.Add(autoMapping));
}

public class AutoMappingConfiguration : DefaultAutomappingConfiguration
{
    public override bool ShouldMap(Type type)
    {
        var isStatic = type.IsAbstract && type.IsSealed;

        return type.Namespace == typeof(Entities.Product).Namespace && !isStatic;
    }

    public override bool IsDiscriminated(Type type)
    {

        if (type == (typeof(Entities.AddressBase))) {
            return true;
        }

        return false;
    }

    public override string GetDiscriminatorColumn(Type type)
    {
        return "Type";
    }

public class DiscriminatorConvention : ISubclassConvention
{
    public void Apply(ISubclassInstance instance)
    {
        //Address 
        if (instance.Name == typeof(AddressBilling).AssemblyQualifiedName)
        {
            instance.DiscriminatorValue(Enums.AddressType.BillingAddress);
        } 
        else if (instance.Name == typeof(AddressShipping).AssemblyQualifiedName)
        {
            instance.DiscriminatorValue(Enums.AddressType.ShippingAddress);
        }
    }
}

谢谢！