/// <summary>
        ///     Principal método privado, realiza a criação do SessionFactory e este não deve ser criado novamente até que o domínio de aplicação seja finalizado.
        /// </summary>
        /// <returns></returns>
        protected override NH.ISessionFactory BuildSessionFactoryInternal()
        {
            FluentNH.Cfg.Db.IPersistenceConfigurer databaseConfiguration = this.BuildPersistenceConfigurer();

            Func <NH.Cfg.Configuration, NH.Cfg.Configuration> configureWithRawProperties = (config) => {
                if (this.NHibernateRawConfigurationValues != null && this.NHibernateRawConfigurationValues.Count > 0)
                {
                    foreach (var rawConfigurationValue in this.NHibernateRawConfigurationValues)
                    {
                        config.SetProperty(rawConfigurationValue.Key, rawConfigurationValue.Value);
                    }
                }
                return(config);
            };

            FluentNH.Cfg.FluentConfiguration configuration = FluentNH.Cfg.Fluently
                                                             .Configure()
                                                             .Database(databaseConfiguration)
                                                             .Cache(it =>
                                                                    it.UseQueryCache()
                                                                    .ProviderClass <NH.Cache.HashtableCacheProvider>()
                                                                    )
                                                             .Diagnostics(it =>
                                                                          it.Enable(this.EnabledDiagnostics)
                                                                          .OutputToConsole()
                                                                          )
                                                             .ExposeConfiguration(it =>
                                                                                  configureWithRawProperties(
                                                                                      it
                                                                                      .SetProperty("command_timeout", this.CommandTimeout.ToString(CultureInfo.InvariantCulture))
                                                                                      .SetProperty("adonet.batch_size", this.BatchSize.ToString(CultureInfo.InvariantCulture))
                                                                                      )
                                                                                  );

            foreach (string typeName in this.TypeNames)
            {
                Type typeInfo = Type.GetType(typeName);
                if (typeInfo == null)
                {
                    throw new ConfigurationErrorsException(string.Format(CultureInfo.InvariantCulture, "Cannot load the Type '{0}', defined in TypeNames property of FluentNHibernateSessionFactoryBuilder", typeName));
                }
                configuration.Mappings(it =>
                {
                    it.FluentMappings.AddFromAssembly(typeInfo.Assembly);
                    it.HbmMappings.AddFromAssembly(typeInfo.Assembly);
                });
            }

            NH.ISessionFactory sessionFactory = configuration.BuildSessionFactory();

            return(sessionFactory);
        }
        protected override IPersistenceConfigurer BuildPersistenceConfigurer()
        {
            var configSqlClient = this.BaseConfiguration
                                  .ConnectionString(this.ConnectionStringDiscoverer.GetConfiguration())
                                  .MaxFetchDepth(this.MaxFetchDepth)
                                  .IsolationLevel(this.DefaultIsolationLevel);

            if (this.EnabledDiagnostics)
            {
                configSqlClient = configSqlClient.ShowSql().FormatSql();
            }

            if (!string.IsNullOrWhiteSpace(this.DefaultSchema))
            {
                configSqlClient = configSqlClient.DefaultSchema(this.DefaultSchema);
            }


            FluentNH.Cfg.Db.IPersistenceConfigurer returnValue = configSqlClient;
            return(returnValue);
        }