Fluent NHibernate Automapping nie tworzenie liczby mnogiej nazwę tabeli

Question

Mam dwie tabele, miejsc i obiektów

map one do dwóch klas,

public Location : Entity 
{ 
    //properties 
} 

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

wszystko działa tylko dandys, dopóki nie zmieni obiekt do tego

public Facility : Location 
{ 

} 

teraz otrzymuję wyjątek od nHibernate mówiąc

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

Z jakiegoś powodu nie tworzy to liczby mnogiej tabeli w ciągu znaków sql.

Dzięki za pomoc!

EDIT

To jest mój obecny TableNameConvention

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

Kiedy Obiekt dziedziczy z jednostki, instrument działa dzięki tej metodzie. Kiedy dziedziczy od lokalizacji, nie

Edycja 2 zorientowali będę pisać wszystko ...

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

Czy ustawić 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

To stara sprawa, ale dla dobra innych, którzy potknie to patrząc na odpowiedź, można również stworzyć konwencję, która wykorzystuje wbudowany PluralizationService że pochodzi z EF:

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

    } 
}