Fluent NHibernate Automapping non creare plurale nome della tabella

Question

Ho due tabelle, luoghi e strutture

Essi mappano due classi,

public Location : Entity 
{ 
    //properties 
} 

public Facility : Entity 
{ 
    public virtual Location Location { get; set; } 
} 

tutto funziona da dandy, fino a cambiare la funzione per questo

public Facility : Location 
{ 

} 

Ora ottengo un'eccezione da NHibernate dicendo

NHibernate.ADOException was unhandled by user code 
    Message=could not execute query 
InnerException: System.Data.SqlClient.SqlException 
     Message=Invalid object name 'Facility'. 

Per qualche motivo non sta creando il nome plurale della tabella nella stringa sql.

Grazie per qualsiasi aiuto!

EDIT

Questo è il mio attuale TableNameConvention

public class TableNameConvention : IClassConvention 
{ 
    public void Apply(FluentNHibernate.Conventions.Instances.IClassInstance instance) 
    { 
     instance.Table(Inflector.Net.Inflector.Pluralize(instance.EntityType.Name)); 
    } 
} 

Quando Struttura eredita da Entità, il Fondo viene eseguito attraverso questo metodo. Quando si eredita da posizione, lo fa non

Edit 2 Ho pensato di inviare tutto ...

public class AutoPersistenceModelGenerator : IAutoPersistenceModelGenerator 
{ 

    #region IAutoPersistenceModelGenerator Members 

    public AutoPersistenceModel Generate() 
    { 
     var mappings = new AutoPersistenceModel(); 
     mappings.AddEntityAssembly(typeof(Person).Assembly).Where(GetAutoMappingFilter); 
     mappings.Conventions.Setup(GetConventions()); 
     mappings.Setup(GetSetup()); 
     mappings.IgnoreBase<Entity>(); 
     mappings.IgnoreBase(typeof(EntityWithTypedId<>)); 
     mappings.UseOverridesFromAssemblyOf<AutoPersistenceModelGenerator>(); 

     return mappings; 

    } 

    #endregion 

    private Action<AutoMappingExpressions> GetSetup() 
    { 
     return c => 
     { 
      c.FindIdentity = type => type.Name == "Id"; 
     }; 
    } 

    private Action<IConventionFinder> GetConventions() 
    { 
     return c => 
     { 
      c.Add<BHP.DEC.Data.NHibernateMaps.Conventions.ForeignKeyConvention>(); 
      c.Add<BHP.DEC.Data.NHibernateMaps.Conventions.HasManyConvention>(); 
      c.Add<BHP.DEC.Data.NHibernateMaps.Conventions.HasManyToManyConvention>(); 
      c.Add<BHP.DEC.Data.NHibernateMaps.Conventions.ManyToManyTableNameConvention>(); 
      c.Add<BHP.DEC.Data.NHibernateMaps.Conventions.PrimaryKeyConvention>(); 
      c.Add<BHP.DEC.Data.NHibernateMaps.Conventions.ReferenceConvention>(); 
      c.Add<BHP.DEC.Data.NHibernateMaps.Conventions.TableNameConvention>(); 
     }; 
    } 

    /// <summary> 
    /// Provides a filter for only including types which inherit from the IEntityWithTypedId interface. 
    /// </summary> 

    private bool GetAutoMappingFilter(Type t) 
    { 
     return t.GetInterfaces().Any(x => 
             x.IsGenericType && 
             x.GetGenericTypeDefinition() == typeof(IEntityWithTypedId<>)); 
    } 
} 

Answer 1

Avete impostare un convention?

public class TableNameConvention : IClassConvention 
{ 
    public void Apply(FluentNHibernate.Conventions.Instances.IClassInstance instance) 
    { 
     string typeName = instance.EntityType.Name; 

     instance.Table(Inflector.Net.Inflector.Pluralize(typeName)); 
    } 
} 

Answer 2

Questa è una vecchia questione, ma per il bene di altri che imbattervi in ​​questo alla ricerca di una risposta, è anche possibile creare una convenzione che utilizza il built-in PluralizationService che viene fornito con EF:

public class TableNameConvention : IClassConvention 
{ 
    public void Apply(IClassInstance instance) 
    { 
     string typeName = instance.EntityType.Name; 
     instance.Table(PluralizationService.CreateService(CultureInfo.CurrentCulture).Pluralize(typeName)); 

    } 
}