INamingStrategy being ignored by (Fluent) NHibernate?

Question

I am trying to write a naming strategy for NHibernate that will prefix table names based on what assembly the poco is defined in. Right now my strategy is just trying to append any prefix at all to the tables just to prove I have things wired up right.

The problem that I am encountering is that I am able to create my INamingStrategy and attach it to the NHibernate configuration object, but it never seems to get used. Here is some example coded:

private MsSqlConfiguration GetDatabaseConfiguration()
{
 var configuration = MsSqlConfiguration.MsSql2008
  .ConnectionString(ConfigFileReader.GetConnectionString(ConnectionStringKey))
  .ShowSql();                
 return configuration;
}

private FluentConfiguration GetFluentConfiguration()
{
 return Fluently.Configure().Database(GetDatabaseConfiguration())
  .Mappings(m =>
  {
   foreach (var assembly in GetAssembliesToLoadMappingsFrom())
    m.FluentMappings.AddFromAssembly(assembly);
  });
}

public global::NHibernate.Cfg.Configuration GetNHibernateConfiguration()
{
 var nHibernateConfiguration = GetFluentConfiguration().BuildConfiguration();
 var namingStrategy = GetNamingStrategy();
 if (namingStrategy != null)
  nHibernateConfiguration.SetNamingStrategy(namingStrategy);
 return nHibernateConfiguration;
}

public void Build()
{
 var schemaExport = new SchemaExport(GetNHibernateConfiguration());

 schemaExport.Create(true, true);
}

By placing a breakpoint on the return statement in GetNHibernateConfiguration(), I am able to confirm that nHibernateConfiguration.NamingStrategy contains a reference to my strategy. However, placing breakpoints in every one of the INamingStrategy implementing members of that strategy shows that non of them are ever called. This is confirmed by looking at the generated schema, which has no prefixes.

Likewise, using the same approach to create a session factory, shows that CRUD operations also ignore the strategy.

I am I missing something obvious?

I am using NHibernate 2.1.1.4000

Thanks ahead of time for any assistance. --Ken

Answer 1

I think your strategy is too complicated. If you are using FluentNHibertate just provide the TableName convention into your initialization.

e.q.:

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

and usage here:

public class AutoPersistenceModelGenerator : IAutoPersistenceModelGenerator
    {
        /// <summary>
        /// Get Conf Setup
        /// </summary>
        /// <returns>
        /// Action of AutoMappingExpressions
        /// </returns>
        private Action<AutoMappingExpressions> GetSetup()
        {
            return c =>
                {
                    c.FindIdentity = type => type.Name == "Id";
                    c.IsBaseType = this.IsBaseTypeConvention;
                };
        }

        private  Action<IConventionFinder> GetConventions() 
        {
            return c =>
                { 
                    c.Add<PrimaryKeyConvention>();
                    c.Add<ReferenceConvention>();
                    c.Add<HasManyConvention>();
                    c.Add<TableNameConvention>();
                    c.Add<PropertyNameConvention>();
                };
        }

        public AutoPersistenceModel Generate()
        {
            var model =
                new AutoPersistenceModel()
                    .AddEntityAssembly(Assembly.GetAssembly(typeof(User)))
                    .Where(
                    this.GetAutoMappingFilter).Conventions.Setup(this.GetConventions()).Setup(this.GetSetup()).
                    UseOverridesFromAssemblyOf<AutoPersistenceModelGenerator>();
            return model;
        }