public static Configuration GetConfiguration() { FluentConfiguration fluentConfig = Fluently.Configure() .Database( MsSqlConfiguration.MsSql2008.Dialect <MsSql2008Dialect>() //SQLiteConfiguration.Standard.Dialect<SQLiteDialect>() .ConnectionString(x => x.FromConnectionStringWithKey("CheatSheets")) ) .ProxyFactoryFactory <ProxyFactoryFactory>() .Mappings(m => { m.FluentMappings.AddFromAssemblyOf <NHibernateConfigurator>(); m.AutoMappings.Add( AutoMap .AssemblyOf <Entity>().Where(type => !type.IsAbstract && typeof(Entity).IsAssignableFrom(type)) .Conventions.AddFromAssemblyOf <NamingConvention>() .Conventions.Add( PrimaryKey.Name.Is(x => "ID"), DefaultLazy.Always(), ForeignKey.Format(FormatFkName) //naming for FK columns ) ); }) .ExposeConfiguration(config => config.Properties.Add("use_proxy_validator", "false")); Configuration cfg = fluentConfig.BuildConfiguration(); cfg.EventListeners.SaveEventListeners = new ISaveOrUpdateEventListener[] { new NHibernateAuditSaveListener() }; cfg.EventListeners.SaveOrUpdateEventListeners = new ISaveOrUpdateEventListener[] { new NHibernateAuditSaveListener() }; return(cfg); }
public void InitializeFactory() { if (!_isInitialized) { FluentConfiguration conf = Fluently.Configure() .Database(MySQLConfiguration.Standard.ConnectionString(_connection)) .CurrentSessionContext <ThreadLocalSessionContext>() .Mappings(map => { map.FluentMappings.Conventions.Add( new EnumConvention(), new CascadeAllConvention(), new ColumnNameConvention(), new TableNameConvention(), LazyLoad.Never() ); map.FluentMappings.AddFromAssemblyOf <EmployeeMap>(); }) .ExposeConfiguration(x => { x.SetInterceptor(new SqlStatementInterceptor()); x.EventListeners.PreInsertEventListeners = new IPreInsertEventListener[] { new EntityService() }; }); if (!_writeOnly) { conf.ExposeConfiguration(config => new SchemaUpdate(conf.BuildConfiguration()).Execute(true, true)); } _sessionFactory = conf.BuildSessionFactory(); _isInitialized = true; } }
public Configuration GetConfiguration() { var NHibernateAssembly = Assembly.Load("Naftan.Maintenance.NHibernate"); var DomainAssembly = Assembly.Load("Naftan.Maintenance.Domain"); var CommonAssembly = Assembly.Load("Naftan.Common"); var msSqlDatabase = MsSqlConfiguration.MsSql2008 .UseOuterJoin() .ShowSql() .FormatSql() // !!!ВНИМАНИЕ Аккуратнее с настойками базы данных для тестов. Если указать рабочую(боевую) базу данных, то ВСЕ РАБОЧИЕ ДАННЫЕ БУДУТ УДАЛЕНЫ !!! .ConnectionString("data source = db2; initial catalog = maintenance_test; integrated security = SSPI;") .UseReflectionOptimizer() .AdoNetBatchSize(100); var automapping = AutoMap.Assemblies(new AutomappingConfig(), CommonAssembly, DomainAssembly) .Conventions.AddAssembly(CommonAssembly) .AddMappingsFromAssembly(NHibernateAssembly) .UseOverridesFromAssembly(NHibernateAssembly); FluentConfiguration cfg = Fluently.Configure() .Database(msSqlDatabase) .Mappings(x => x.AutoMappings.Add(automapping) ); var configuration = cfg.BuildConfiguration(); return(configuration); }
public ISessionFactory GetFactory() { if (factory == null) { Assembly assembly = GetAssembly(); DbConnectionStringBuilder connStringBuilder = GetConnectionStringBuilder(); FluentConfiguration configuration = Fluently.Configure() .Database(MsSqlConfiguration.MsSql2012.ConnectionString(connStringBuilder.ConnectionString).ShowSql()) .Mappings(m => m.FluentMappings.AddFromAssembly(assembly)); if (createSchema) { SchemaUpdate(connStringBuilder, configuration.BuildConfiguration()); } factory = configuration.BuildSessionFactory(); if (factory == null) { throw new InvalidOperationException("BuildSessionFactory is null."); } } return(factory); }
private static void UpdateDatabaseSchemaUsing(FluentConfiguration fluentConfiguration) { var configuration = fluentConfiguration.BuildConfiguration(); new SchemaUpdate(configuration) .Execute(false, true); }
/// <summary> /// Only development phase usage do not use production code /// </summary> /// <param name="factoryKey"></param> private void BuildSchemaByDroping(string factoryKey) { var filePath = Directory.GetFiles(AppDomain.CurrentDomain.BaseDirectory, factoryKey + ".NHibernate.config")?.FirstOrDefault(); if (string.IsNullOrEmpty(filePath)) { Console.WriteLine(factoryKey + ".NHibernate.config file not found for BuildSchemaDroping!"); return; } var nHibernateMappingAssembly = GetAssemblyName(filePath); var cfg = new global::NHibernate.Cfg.Configuration(); cfg.Configure(filePath); FluentConfiguration a = Fluently.Configure(cfg).Mappings(m => { var assembly = Assembly.Load(nHibernateMappingAssembly); m.HbmMappings.AddFromAssembly(assembly); m.FluentMappings.AddFromAssembly(assembly).Conventions.AddAssembly(assembly); }); SchemaExport schema = new SchemaExport(a.BuildConfiguration()); if (schema != null) { schema.Execute(true, true, false); } }
private ISessionFactory CreateSessionFactory() { FluentConfiguration fluentConfiguration = Fluently.Configure(); IPersistenceConfigurer sqlConfiguration = CreateSqlConfiguration(); if (sqlConfiguration != null) { fluentConfiguration = fluentConfiguration.Database(sqlConfiguration); } mappingResolver.AddAvailableMappings(fluentConfiguration); var eventListenerHelper = new EventListenerHelper(securityService); var saveOrUpdateEventListener = new SaveOrUpdateEventListener(eventListenerHelper); var deleteEventListener = new DeleteEventListener(eventListenerHelper); fluentConfiguration = fluentConfiguration .Mappings(m => m.FluentMappings .Conventions.Add(ForeignKey.EndsWith("Id")) .Conventions.Add <EnumConvention>()) .ExposeConfiguration(c => c.SetProperty("show_sql", "false")) .ExposeConfiguration(c => c.SetListener(ListenerType.Delete, deleteEventListener)) .ExposeConfiguration(c => c.SetListener(ListenerType.SaveUpdate, saveOrUpdateEventListener)) .ExposeConfiguration(c => c.SetListener(ListenerType.Save, saveOrUpdateEventListener)) .ExposeConfiguration(c => c.SetListener(ListenerType.Update, saveOrUpdateEventListener)); return(fluentConfiguration .BuildConfiguration() .BuildSessionFactory()); }
public Configuration GetConfiguration() { var NHibernateAssembly = Assembly.Load("Naftan.Maintenance.NHibernate"); var DomainAssembly = Assembly.Load("Naftan.Maintenance.Domain"); var CommonAssembly = Assembly.Load("Naftan.Common"); var msSqlDatabase = MsSqlConfiguration.MsSql2008 .UseOuterJoin() .ConnectionString(s => s.FromConnectionStringWithKey("maintenance")) .UseReflectionOptimizer() .AdoNetBatchSize(100); var automapping = AutoMap.Assemblies(new AutomappingConfig(), CommonAssembly, DomainAssembly) .Conventions.AddAssembly(CommonAssembly) .AddMappingsFromAssembly(NHibernateAssembly) .UseOverridesFromAssembly(NHibernateAssembly); FluentConfiguration cfg = Fluently.Configure() .Database(msSqlDatabase) .Mappings(x => x.AutoMappings.Add(automapping) ); var configuration = cfg.BuildConfiguration(); return(configuration); }
private static ISession CreateSession(this FluentConfiguration configuration) { var session = configuration.BuildSessionFactory().OpenSession(); new SchemaExport(savedConfiguration ?? configuration.BuildConfiguration()) .Execute(true, true, false, session.Connection, Console.Out); return(session); }
public void Initialize(IContainer container) { var typeDiscoverer = container.Get <ITypeDiscoverer>(); FluentConfiguration.Mappings(m => DiscoverClassMapsAndAddAssemblies(typeDiscoverer, m)); Configuration = FluentConfiguration.BuildConfiguration(); SessionFactory = Configuration.BuildSessionFactory(); }
public static ISession GetInMemorySession() { var session = Factory.OpenSession(); HibernatingRhinos.Profiler.Appender.NHibernate.NHibernateProfiler.Initialize(); new SchemaExport(Config.BuildConfiguration()) .Execute(false, true, false, session.Connection, null); return(session); }
public static CoreNHibernate.ISessionFactory CreateSessionFactory(DBTypes dbType) { FluentConfiguration config = Fluently.Configure(); switch (dbType) { case DBTypes.Oracle: config = OracleHelper.ConfigurationFactory(); break; case DBTypes.MSSQL: config = MsSqlHelper.ConfigurationFactory(); break; case DBTypes.SQLite: config = SQLiteHelper.ConfigurationFactory(); break; case DBTypes.MySQL: default: throw new NotImplementedException("Not implemented yet..."); } var enversConf = new EnversNHibernate.Configuration.Fluent.FluentConfiguration(); List <Type> domainEntities = Assembly.GetAssembly(typeof(Clients)).GetTypes() // Assembly.Load("bilisimHR.DataLayer.Core").GetTypes() .Where(t => (typeof(Entity <int>).IsAssignableFrom(t) && !t.IsGenericType)) .ToList(); foreach (Type type in domainEntities) { enversConf.Audit(type); } CoreNHibernate.Cfg.Configuration cfg = new CoreNHibernate.Cfg.Configuration(); cfg = config.BuildConfiguration(); cfg.BuildMappings(); cfg.SetInterceptor(new TrackingInterceptor()); //Envers RevType Values //0(ADD), 1(MODIFY) and 2(DELETE) ConfigurationKey.AuditTableSuffix.SetUserValue(cfg, "_LOG"); IRevisionInfoService revInfoService = new RevisionInfoService(); // Service Locator Registry ServiceLocator.RegisterService(revInfoService); ServiceLocator.RegisterService(new HttpRequestMessageService()); enversConf.SetRevisionEntity <CustomRevInfo>(e => e.Id, e => e.RevisionDate, new CustomRevInfoListener()); cfg.IntegrateWithEnvers(enversConf); config.ExposeConfiguration(exp => new SchemaUpdate(cfg).Execute(false, true)) .ExposeConfiguration(c => { c.CurrentSessionContext <CoreNHibernate.Context.CallSessionContext>(); }); //config.ExposeConfiguration(exp => new SchemaExport(cfg).Execute(true, true, false)); return(config.BuildSessionFactory()); }
private static ISessionFactory ConfigureSessionFactory() { if (ShouldRecreateDb()) { CreateDatabase(); } FluentConfiguration configuration = CreateNHibernateConfiguration(); return(configuration.BuildConfiguration().BuildSessionFactory()); }
public NhibernateManagerDataBase(FluentConfiguration builderConfiguration) { Guard.NotNull("fluentConfiguration", builderConfiguration); var configuration = builderConfiguration.BuildConfiguration(); this.schemaExport = new SchemaExport(configuration); this.schemaUpdate = new SchemaUpdate(configuration); this.schemaValidate = new SchemaValidator(configuration); }
public static void ConfigureIncodingNhDataServices(this IServiceCollection services, Type entityType, string path, Func <FluentConfiguration, FluentConfiguration> builderConfigure) { services.AddSingleton <IUnitOfWorkFactory, NhibernateUnitOfWorkFactory>(); // string path = Path.Combine(AppContext.BaseDirectory, string.Format("fluently_{0}_{1}.cfg", version, //#if DEBUG // new string(connectionString.ToCharArray().Select(r => Char.IsLetterOrDigit(r) ? r : 'a').ToArray()) //#else // "" //#endif // )); Func <Configuration> config = () => { FluentConfiguration fluently = Fluently.Configure(); fluently = builderConfigure(fluently); fluently = fluently .Mappings(configuration => configuration.FluentMappings .Add(typeof(DelayToSchedulerNhMap)) .AddFromAssembly(entityType.Assembly)); return(fluently.BuildConfiguration()); }; //var dbContext = FileCaching.Evaluate(path, () => //{ //Func<string, IncDbContext> incDbContext = (cs) => //{ // var dbContextOptionsBuilder = new DbContextOptionsBuilder<IncDbContext>(); // builderConfigure(dbContextOptionsBuilder); // return new IncDbContext(dbContextOptionsBuilder.Options, entityType.Assembly); //}; // return incDbContext; //}); //incDbContext(connectionString).Database.EnsureCreated(); NhibernateSessionFactory sessionFactory = new NhibernateSessionFactory(config, path); services.AddSingleton <INhibernateSessionFactory>(sessionFactory); //var container = new Container(); //container.Register<IDispatcher, DefaultDispatcher>(); //container.Register<IUnitOfWorkFactory, NhibernateUnitOfWorkFactory>(Lifestyle.Singleton); //Configuration cfg = NhibernatePersist.CreateDefault(entityType, connectionString, version); //container.RegisterSingleton<INhibernateSessionFactory>(() => //{ // FluentConfiguration configure = Fluently.Configure(cfg); // return new NhibernateSessionFactory(configure); //}); //container.Register<IUnitOfWorkFactory, NhibernateUnitOfWorkFactory>(Lifestyle.Singleton); }
public static void BuildSchema() { try { new SchemaExport(_config.BuildConfiguration()).Create(false, true); } catch (Exception ex) { Logger.Log(ex.Message, Logger.LogType.Error, typeof(SessionFactory)); } }
private static void UpdateDatabaseSchemaUsing(FluentConfiguration fluentConfiguration, ISessionFactory factory) { var configuration = fluentConfiguration.BuildConfiguration(); using (var session = factory.OpenSession()) { var export = new SchemaExport(configuration); export.Execute(true, true, false, session.Connection, null); session.Flush(); } }
public static void BuildSchema() { CreateDatabaseDirectoryIfNotExist(); if (DatabaseExists) { DropDatabase(); } new SchemaExport(_configuration.BuildConfiguration()) .Create(false, true); }
public void ValidateSchema() { SchemaValidator validator = new SchemaValidator(_fluentConfiguration.BuildConfiguration()); validator.Validate(); try { } catch (HibernateException ex) { Trace.WriteLine(ex.Message); } }
public void SetupDb(Assembly migrationAssembly = null) { SqlCeDbHelper.CreateDatabaseFile(DatabaseFilename); if (migrationAssembly == null) { new SchemaExport(Config.BuildConfiguration()).Execute(true, true, false); } else { var migrator = new Migrator.Migrator("SqlServerCE", "Data Source=" + DatabaseFilename, migrationAssembly, true); migrator.MigrateToLastVersion(); } }
static ISessionFactory CreateNHibernateSessionFactory() { FluentConfiguration fc = Fluently.Configure() .Database(MsSqlConfiguration.MsSql2012.ConnectionString("Server=.\\SQLEXPRESS;Database=NHibernateTests;Trusted_Connection=True;")) .Mappings(m => { m.FluentMappings .AddFromAssembly(Assembly.GetExecutingAssembly()); }); var config = fc.BuildConfiguration(); return(config.SetProperty(NHibernate.Cfg.Environment.ReleaseConnections, "on_close") .BuildSessionFactory()); }
public static void MappingTablenames(FluentConfiguration cfg, Type t, string newtablename = "") { if (newtablename == "") { return; } foreach (PersistentClass persistClass in cfg.BuildConfiguration().ClassMappings) { if (persistClass.MappedClass == t) { persistClass.Table.Name = newtablename; } } }
public Configuration GetConfiguration() { SQLiteConfiguration persistenceConfigurer = SQLiteConfiguration.Standard .Dialect <MySQLiteDialect>() .InMemory() .ShowSql(); FluentConfiguration cfg = Fluently.Configure() .Database(persistenceConfigurer) .ExposeConfiguration(ExtendConfiguration) .ProxyFactoryFactory <DefaultProxyFactoryFactory>() .Mappings(mappings); return(cfg.BuildConfiguration()); }
/// <summary> /// Пооверить структуру таблиц. /// </summary> /// <returns></returns> public virtual DbContext ValidateSchema() { try { FluentConfiguration dbConfig = Configure(); NH.Cfg.Configuration config = dbConfig.BuildConfiguration(); var schema = new SchemaValidator(config); schema.Validate(); return(new DbContext(this, dbConfig.BuildSessionFactory())); } catch (Exception ex) { throw new DatabaseException($"Некорректная структура таблиц БД: {this}.", ex); } }
public Configuration GetConfiguration() { MsSqlConfiguration config = MsSqlConfiguration.MsSql2008 .ConnectionString(x => x.FromConnectionStringWithKey("Main")) .UseReflectionOptimizer() .AdoNetBatchSize(100); FluentConfiguration fluentConfiguration = Fluently.Configure() .CurrentSessionContext <ThreadStaticSessionContext>() .Database(config) .Mappings(x => x.FluentMappings.AddFromAssemblyOf <LjuserMap>() .Conventions.AddFromAssemblyOf <TableNameConvention>()) .ExposeConfiguration(c => c.SetProperty("generate_statistics", "true") .SetProperty("adonet.batch_size", "100")); return(fluentConfiguration .BuildConfiguration()); }
public void Regist(bool buildHbmFile, string exportHbmFolder) { IEnumerable <Assembly> fluentAssemblies = GetFluenAssembly(); IEnumerable <Assembly> nhAssembilies = GetHbmXmlFile(); foreach (Type type in _regType.Keys) { OrnamentContext.DaoFactory.Regist(type, _regType[type]); } SessionManager.Regist("default", () => { var config = new Configuration(); string configFileName = ConfigurationManager.AppSettings["nhConfig"]; if (String.IsNullOrEmpty(configFileName)) { throw new ArgumentNullException( "nhConfig section can't be find in the config file. please set it up in the appSettiong section."); } config.Configure(ApplicationHelper.MapPath(configFileName)); FluentConfiguration result = Fluently.Configure(config); foreach (Assembly assembly in fluentAssemblies) { if (buildHbmFile) { Assembly assembly1 = assembly; result.Mappings(s => s.FluentMappings.AddFromAssembly(assembly1) .ExportTo(exportHbmFolder)); } else { result.Mappings(s => s.FluentMappings.AddFromAssembly(assembly)); } } foreach (Assembly assembly in nhAssembilies) { result.Mappings(s => s.HbmMappings.AddFromAssembly(assembly)); } return(result.BuildConfiguration()); }); }
private void Boot_PreInitModules(object sender, BootstrapperEventArgs e) { string connectionStr = ConfigurationManager.ConnectionStrings["MsSql"].ConnectionString; FluentConfiguration config = Fluently.Configure(); foreach (Nefarian.Configuration.ModuleConfiguration module in e.Configuration.Modules) { config.Mappings(x => x.FluentMappings.AddFromAssembly(module.ModuleType.Assembly)); } //config.Database(FluentNHibernate.Cfg.Db.MsSqlConfiguration.MsSql2008.ConnectionString(connectionStr)); config.Database(FluentNHibernate.Cfg.Db.MySQLConfiguration.Standard.ConnectionString(connectionStr)); config.CurrentSessionContext("wcf_operation"); ISessionFactory sessionFactory; bool debugSQL = true; bool.TryParse(ConfigurationManager.AppSettings["DebugSQL"], out debugSQL); if (debugSQL) { NHibernate.Cfg.Configuration nhibernateConfig = config.BuildConfiguration(); nhibernateConfig.Properties["show_sql"] = "true"; nhibernateConfig.Properties["format_sql"] = "true"; sessionFactory = nhibernateConfig.BuildSessionFactory(); } else { sessionFactory = config.BuildSessionFactory(); } IUnityContainer appContainer = Nefarian.Core.WebServiceSite.GetAppContainer(); appContainer.RegisterInstance <ISessionFactory>("Lilac", sessionFactory); ExchangeCenter exchange = new ExchangeCenter(); appContainer.RegisterInstance <ExchangeCenter>(exchange); MessagePublisher publisher = new MessagePublisher(); appContainer.RegisterInstance <MessagePublisher>(publisher); log4net.Config.XmlConfigurator.Configure(); ILog log = LogManager.GetLogger("Lilac"); appContainer.RegisterInstance <ILog>(log); }
private ISessionFactory CreateSessionFactory() { Configuration initialConfiguration = this.GetConfiguration() .OrFail(nameof(this.GetConfiguration) + "()"); FluentConfiguration fluentConfiguration = Fluently.Configure(initialConfiguration) //.CurrentSessionContext<CurrentSessionContext>() //.Mappings( // m => m.FluentMappings // .Add<GusContractorSnapshot.Map>() // .Add<GusContractorLog.Map>() //) ; Library[] libraries = this.Librarian.OrFail(nameof(this.Librarian)) .GetLibraries(); IConvention[] conventions = this.GetConventions() .OrFail(nameof(this.Conventions)); Type[] entities = this.GetEntities() .ToArray(); var automappingConfiguration = new AutomappingConfiguration(entities); foreach (Library library in libraries) { Assembly assembly = library.GetAssembly(); AutoPersistenceModel assemblyMappings = AutoMap.Assembly(assembly, automappingConfiguration); assemblyMappings.Conventions.Add(conventions); assemblyMappings.UseOverridesFromAssembly(assembly); assemblyMappings.IgnoreBase <Entity>(); fluentConfiguration.Mappings(m => { m.FluentMappings.Conventions.Add(conventions); m.AutoMappings.Add(assemblyMappings); }); } this.configuration = fluentConfiguration.BuildConfiguration(); return(fluentConfiguration.BuildSessionFactory()); }
/// <summary> /// Método privado estático encargado de la configuración de nHibernate con Fluent. /// </summary> /// <param name="nHibernateConfigFile"> /// Parámetro que indica la ruta del fichero de configuración de nhibernate. /// </param> /// <param name="mappingAssemblies"> /// Parámetro que indica la lista de ensamblados a mapear. /// </param> /// <returns> /// Devuelve la configuración <see cref="Configuration"/> correspondiente. /// </returns> private static Configuration FluentlyConfigureNHiberante(List <Assembly> mappingAssemblies) { // Configuramos Fluent. FluentConfiguration fluentConfiguration = Fluently.Configure(new Configuration().Configure()); fluentConfiguration.Mappings(m => { m.FluentMappings.Conventions.AddAssembly(typeof(Configurator).Assembly); foreach (Assembly mappingAssembly in mappingAssemblies) { m.FluentMappings.Conventions.AddAssembly(mappingAssembly); } }) .Mappings(m => { foreach (Assembly mappingAssembly in mappingAssemblies) { m.FluentMappings.AddFromAssembly(mappingAssembly); } }) .Mappings(m => { foreach (Assembly mappingAssembly in mappingAssemblies) { m.HbmMappings.AddFromAssembly(mappingAssembly); } }); // Añadimos configuraciones. fluentConfiguration.ExposeConfiguration(c => c.Properties.Add(NHibernate.Cfg.Environment.BatchSize, "100")) .ExposeConfiguration(c => c.Properties.Add(NHibernate.Cfg.Environment.UseProxyValidator, "true")); PropertyInfo pinfo = typeof(FluentConfiguration).GetProperty("Configuration", BindingFlags.Instance | BindingFlags.NonPublic); nhConfiguration = pinfo.GetValue(fluentConfiguration, null) as Configuration; Configuration builtConfiguration = fluentConfiguration.BuildConfiguration(); // Devolvemos la respuesta. return(builtConfiguration); }
private ISessionFactory BuildSessionFactory() { Assembly currentAssembly = Assembly.GetAssembly(this.GetType()); FluentConfiguration fc = Fluently.Configure() .Database(MsSqlConfiguration.MsSql2012.ConnectionString(_ConnectionString)) .Mappings( m => { m.FluentMappings .AddFromAssembly(currentAssembly) .Conventions .Add <StringSqlTypeConvention>(); m.HbmMappings.AddFromAssembly(currentAssembly); } ); return(fc.BuildConfiguration() .SetProperty(NHibernateEnvironment.ReleaseConnections, "on_close") .BuildSessionFactory()); }