protected override void Configure(Configuration configuration)
{
base.Configure(configuration);
configuration.SetProperty("hibernate.search.default.directory_provider", typeof(FSDirectoryProvider).AssemblyQualifiedName);
configuration.SetProperty(Environment.AnalyzerClass, typeof(StopAnalyzer).AssemblyQualifiedName);
}
/// <summary>
/// Wrapper class to produce an Ado.Net Datatable from any entity,
/// and perform SqlBulkCopy operations
/// </summary>
public SqlEntityBulkCopy(string sqlCnnString, Type entityType)
{
if (Cfg == null)
{
//Note: The NHibernate.Cfg.Configuration is meant only as an initialization-time object.
//Note: NHibernate.ISessionFactory is immutable and does not retain any association back to the Session
Cfg = new Configuration();
//Cfg.SetProperty("proxyfactory.factory_class", "NHibernate.ByteCode.Castle.ProxyFactoryFactory, NHibernate.ByteCode.Castle");
Cfg.SetProperty("dialect", "NHibernate.Dialect.MsSql2008Dialect");
Cfg.SetProperty("connection.provider", "NHibernate.Connection.DriverConnectionProvider");
Cfg.SetProperty("connection.driver_class", "NHibernate.Driver.SqlClientDriver");
Cfg.SetProperty("connection.connection_string", sqlCnnString);
//add all the mappings embedded in this assembly
Cfg.AddAssembly(typeof(SqlEntityBulkCopy).Assembly);
var sessionFactory = Cfg.BuildSessionFactory();
SessionFactoryImpl = (ISessionFactoryImplementor)sessionFactory;
}
EntityType = entityType;
//_session = SessionFactoryImpl.OpenSession();
_metaData = SessionFactoryImpl.GetClassMetadata(EntityType);
_persistentClass = Cfg.GetClassMapping(EntityType);
_sqlCnn = new SqlConnection(sqlCnnString);
_sqlBulkCopy = new SqlBulkCopy(_sqlCnn);
//Debug.WriteLine("EntityName = " + _metaData.EntityName);
//Debug.WriteLine("IdentifierPropertyName = " + _metaData.IdentifierPropertyName);
//Debug.WriteLine("IdentifierType = " + _metaData.IdentifierType);
BuildDataTable();
BuildAndMapSqlBulkCopy();
}
protected override void AlterConfiguration(Configuration config) {
config.SetProperty(NHibernate.Cfg.Environment.PrepareSql, Boolean.TrueString);
if (IsAzureSql()) {
config.SetProperty(NHibernate.Cfg.Environment.TransactionStrategy, typeof(ReliableAdoNetWithDistributedTransactionFactory).AssemblyQualifiedName);
}
}
protected override void Configure(Configuration configuration)
{
configuration.SetProperty(Environment.UseSecondLevelCache, "false");
configuration.SetProperty(Environment.UseQueryCache, "false");
configuration.SetProperty(Environment.CacheProvider, null);
configuration.SetListener(ListenerType.PostCommitDelete, new PostCommitDelete());
}
static void Main()
{
Console.Title = "Samples.CustomNhMappings.XmlMapping";
var nhConfiguration = new Configuration();
nhConfiguration.SetProperty(Environment.ConnectionProvider, "NHibernate.Connection.DriverConnectionProvider");
nhConfiguration.SetProperty(Environment.ConnectionDriver, "NHibernate.Driver.Sql2008ClientDriver");
nhConfiguration.SetProperty(Environment.Dialect, "NHibernate.Dialect.MsSql2008Dialect");
nhConfiguration.SetProperty(Environment.ConnectionStringName, "NServiceBus/Persistence");
AddMappingsFromFilesystem(nhConfiguration);
var busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.CustomNhMappings.XmlMapping");
busConfiguration.UseSerialization<JsonSerializer>();
busConfiguration.EnableInstallers();
var persistence = busConfiguration.UsePersistence<NHibernatePersistence>();
persistence.UseConfiguration(nhConfiguration);
using (var bus = Bus.Create(busConfiguration).Start())
{
var startOrder = new StartOrder
{
OrderId = "123"
};
bus.SendLocal(startOrder);
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
}
private static void ConfigureConnection(Configuration configuration, string connectionString)
{
configuration.SetProperty(Environment.Dialect, "NHibernate.Dialect.MsSql2005Dialect");
configuration.SetProperty(Environment.ConnectionDriver, "NHibernate.Driver.SqlClientDriver");
configuration.SetProperty(Environment.ConnectionProvider, "NHibernate.Connection.DriverConnectionProvider");
configuration.SetProperty(Environment.ConnectionString, connectionString);
}
static void Main()
{
Configuration nhConfiguration = new Configuration();
nhConfiguration.SetProperty(Environment.ConnectionProvider, "NHibernate.Connection.DriverConnectionProvider");
nhConfiguration.SetProperty(Environment.ConnectionDriver, "NHibernate.Driver.Sql2008ClientDriver");
nhConfiguration.SetProperty(Environment.Dialect, "NHibernate.Dialect.MsSql2008Dialect");
nhConfiguration.SetProperty(Environment.ConnectionStringName, "NServiceBus/Persistence");
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.CustomNhMappings.Default");
busConfiguration.UseSerialization<JsonSerializer>();
busConfiguration.EnableInstallers();
busConfiguration
.UsePersistence<NHibernatePersistence>()
.UseConfiguration(nhConfiguration);
using (IBus bus = Bus.Create(busConfiguration).Start())
{
bus.SendLocal(new StartOrder
{
OrderId = "123"
});
bus.SendLocal(new CompleteOrder
{
OrderId = "123"
});
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
}
static SessionFactory()
{
var connectionString = @"Data Source=.\sqlexpress2014;Initial Catalog=BlogDatabase;Integrated Security=True";
var configuration = new Configuration();
configuration.DataBaseIntegration(
x =>
{
x.ConnectionString = connectionString;
x.Driver<SqlClientDriver>();
x.Dialect<MsSql2012Dialect>();
});
configuration.SetProperty(Environment.UseQueryCache, "true");
configuration.SetProperty(Environment.UseSecondLevelCache, "true");
configuration.SetProperty(Environment.CacheProvider, typeof(SysCacheProvider).AssemblyQualifiedName);
var mapper = new ModelMapper();
mapper.AddMappings(Assembly.GetExecutingAssembly().GetExportedTypes());
mapper.BeforeMapBag += (modelInspector, member1, propertyCustomizer) =>
{
propertyCustomizer.Inverse(true);
propertyCustomizer.Cascade(Cascade.All | Cascade.DeleteOrphans);
};
mapper.BeforeMapManyToOne +=
(modelInspector, member1, propertyCustomizer) => { propertyCustomizer.NotNullable(true); };
mapper.BeforeMapProperty += (inspector, member, customizer) => customizer.NotNullable(true);
var mapping = mapper.CompileMappingForAllExplicitlyAddedEntities();
configuration.AddMapping(mapping);
sessionFactory = configuration.BuildSessionFactory();
}
/// <summary>
/// Parses the connection string and creates the NHibernate configuration
/// </summary>
/// <param name="connect">NHibernate dialect, driver and connection string separated by ';'</param>
private void ParseConnectionString(string connect)
{
// Split out the dialect, driver, and connect string
char[] split = { ';' };
string[] parts = connect.Split(split, 3);
if (parts.Length != 3)
{
// TODO: make this a real exception type
throw new Exception("Malformed Inventory connection string '" + connect + "'");
}
dialect = parts[0];
// NHibernate setup
configuration = new Configuration();
configuration.SetProperty(Environment.ConnectionProvider,
"NHibernate.Connection.DriverConnectionProvider");
configuration.SetProperty(Environment.Dialect,
"NHibernate.Dialect." + dialect);
configuration.SetProperty(Environment.ConnectionDriver,
"NHibernate.Driver." + parts[1]);
configuration.SetProperty(Environment.ConnectionString, parts[2]);
//configuration.SetProperty(Environment.ShowSql, "true");
//configuration.SetProperty(Environment.GenerateStatistics, "false");
//configuration.AddAssembly("WebDAVSharp.NHibernateStorage");
configuration.AddAssembly("ModCableBeach");
}
public static Boolean TestAccount(DatabaseAccountToken token, Boolean testMapping = false)
{
try
{
Configuration configuration = new Configuration();
configuration.SetProperty(NHibernate.Cfg.Environment.ConnectionString, token.ConnectionString);
configuration.SetProperty(NHibernate.Cfg.Environment.ConnectionDriver, String.Format("NHibernate.Driver.{0}", token.DatabaseDriver));
configuration.SetProperty(NHibernate.Cfg.Environment.Dialect, String.Format("NHibernate.Dialect.{0}", token.DatabaseDialect));
if (testMapping)
{
configuration.AddXml(token.Mapping);
using (ISessionFactory sessionFactory = configuration.BuildSessionFactory())
{
using (ISession session = sessionFactory.OpenSession())
{
return session.IsConnected;
}
}
}
else
{
using (ISessionFactory sessionFactory = configuration.BuildSessionFactory())
{
using (ISession session = sessionFactory.OpenSession())
{
return session.IsConnected;
}
}
}
}
catch (Exception ex)
{
return false;
}
}
protected override void Configure(Configuration configuration)
{
base.Configure(configuration);
configuration.SetProperty(Environment.UseQueryCache, "true");
configuration.SetProperty(Environment.CacheRegionPrefix, "criteriaquerytest");
configuration.SetProperty(Environment.UseSecondLevelCache, "true");
}
protected override void Configure(Configuration cfg)
{
base.Configure(cfg);
cfg.SetProperty(Environment.ReleaseConnections, "after_transaction");
//cfg.SetProperty(Environment.ConnectionProvider, typeof(DummyConnectionProvider).AssemblyQualifiedName);
//cfg.SetProperty(Environment.GenerateStatistics, "true");
cfg.SetProperty(Environment.BatchSize, "0");
}
public void CacheDisabled()
{
Configuration cfg = new Configuration();
cfg.SetProperty(Environment.UseSecondLevelCache, "false");
cfg.SetProperty(Environment.UseQueryCache, "false");
cfg.SetProperty(Environment.CacheProvider, null);
cfg.BuildSessionFactory().Close();
}
protected override void Configure(Configuration configuration)
{
base.Configure(configuration);
configuration.SetProperty("hibernate.search.default.directory_provider", typeof(Store.RAMDirectoryProvider).AssemblyQualifiedName);
configuration.SetProperty(Environment.AnalyzerClass, typeof(Lucene.Net.Analysis.StopAnalyzer).AssemblyQualifiedName);
configuration.SetProperty(Environment.WorkerScope, "transaction");
configuration.SetProperty(Environment.WorkerExecution, "sync"); // Note: It is WorkerPrefix in the Java version, but it must be a typo
}
private static void InitializeEnvers(NHibernate.Cfg.Configuration configuration)
{
configuration.SetProperty("nhibernate.envers.audit_table_suffix", "_Audit");
configuration.SetProperty("nhibernate.envers.revision_field_name", "Revision");
configuration.SetProperty("nhibernate.envers.revision_type_field_name", "RevisionType");
configuration.SetProperty("nhibernate.envers.store_data_at_delete", "true");
configuration.IntegrateWithEnvers(new AttributeConfiguration());
}
public static void configurarSesiones()
{
cfg = new Configuration();
cfg.SetProperty("dialect", "NHibernate.Dialect.MySQLDialect");
cfg.SetProperty("connection.driver_class", "NHibernate.Driver.MySqlDataDriver");
cfg.SetProperty("connection.connection_string", "Server='" + servidor + "';Database='" + baseDatos + "';User ID=" + usuario + ";Password="******";CharSet=utf8");
cfg.AddAssembly("SIMO_CORE");
sesiones = cfg.BuildSessionFactory();
}
public static Configuration ToConfiguration(this SessionConfiguration sessionConfiguration)
{
var configuration = new Configuration();
configuration.SetProperty(Environment.Dialect, sessionConfiguration.Dialect);
configuration.SetProperty(Environment.ConnectionDriver, sessionConfiguration.ConnectionDriver);
configuration.SetProperty(Environment.ConnectionString, sessionConfiguration.ConnectionString);
return configuration;
}
private Configuration CreateNHibernateConfig(AppConfig config)
{
var nhConfig = new Configuration();
nhConfig.SetProperty(Environment.Dialect, typeof(MsSql2008Dialect).AssemblyQualifiedName);
var connectionString = ConfigurationManager.AppSettings["SQLSERVER_CONNECTION_STRING"] ?? config.ConnectionString;
nhConfig.SetProperty(Environment.ConnectionString, connectionString);
nhConfig.AddAssembly(ThisAssembly);
return nhConfig;
}
private static void BuildSchema(Configuration cfg)
{
if (!File.Exists("catalog.db"))
new SchemaExport(cfg)
.Create(false, true);
// People advice not to use NHibernate.Cache.HashtableCacheProvider for production
cfg.SetProperty("cache.provider_class", "NHibernate.Cache.HashtableCacheProvider");
cfg.SetProperty("cache.use_second_level_cache", "true");
cfg.SetProperty("cache.use_query_cache", "true");
}
private void SetSearchProps(Configuration cfg)
{
cfg.SetProperty(
"hibernate.search.default.directory_provider",
typeof(FSDirectoryProvider)
.AssemblyQualifiedName);
cfg.SetProperty(
"hibernate.search.default.indexBase",
"~/Index");
}
protected override void Configure(Configuration configuration)
{
base.Configure(configuration);
DeleteBaseIndexDir();
FileInfo sub = BaseIndexDir;
Directory.CreateDirectory(sub.FullName);
configuration.SetProperty("hibernate.search.default.indexBase", sub.FullName);
configuration.SetProperty("hibernate.search.default.directory_provider", typeof(FSDirectoryProvider).AssemblyQualifiedName);
configuration.SetProperty(NHibernate.Search.Environment.AnalyzerClass, typeof(StopAnalyzer).AssemblyQualifiedName);
}
private static Configuration CreatConfiguration()
{
ModelMapper mapper = GetMapper();
HbmMapping mapping = mapper.CompileMappingForAllExplicitlyAddedEntities();
var configuration = new Configuration();
configuration.SetProperty(Environment.Dialect, "NHibernate.Dialect.MsSql2012Dialect");
configuration.SetProperty(Environment.ConnectionString, @"Data Source=.\sqlexpress;Initial Catalog=OrdersDatabase;Integrated Security=True");
configuration.AddMapping(mapping);
return configuration;
}
private static void Configure()
{
cfg = new Configuration();
//cfg.SetProperty("hibernate.search.default.directory_provider", typeof(RAMDirectoryProvider).AssemblyQualifiedName);
cfg.SetProperty("hibernate.search.default.directory_provider", typeof(FSDirectoryProvider).AssemblyQualifiedName);
cfg.SetProperty(NHibernate.Search.Environment.AnalyzerClass, typeof(StopAnalyzer).AssemblyQualifiedName);
cfg.SetListener(NHibernate.Event.ListenerType.PostUpdate, new FullTextIndexEventListener());
cfg.SetListener(NHibernate.Event.ListenerType.PostInsert, new FullTextIndexEventListener());
cfg.SetListener(NHibernate.Event.ListenerType.PostDelete, new FullTextIndexEventListener());
cfg.Configure();
sf = cfg.BuildSessionFactory();
}
protected override void Customize(Configuration config)
{
config.DataBaseIntegration(x =>
{
x.ConnectionString = ConnectionString;
x.Dialect<SQLiteDialect>();
x.Driver<SQLite20Driver>();
});
config.SetProperty("cache.use_second_level_cache", "false");
config.SetProperty("generate_statistics", "true");
config.SetProperty("auto-import", "false");
}
public void OpenSession()
{
var config = new Configuration();
config.SetProperty("connection.driver_class", "NHibernate.Driver.SqlClientDriver");
config.SetProperty("dialect","NHibernate.Dialect.MsSql2012Dialect");
config.SetProperty("connection.connection_string", "Data Source=localhost\\SQLEXPRESS;initial catalog=simple-db;Integrated Security=SSPI;");
config.SetProperty("connection.release_mode","on_close");
var mapper = new ApplicationMapper();
config.AddMapping(mapper.Map());
_factory = config.BuildSessionFactory();
}
static ISessionFactory ConfigureSessionFactory()
{
var cfg = new Configuration();
cfg.SetProperty("dialect", "NHibernate.Dialect.MsSql2008Dialect");
cfg.SetProperty("connection.provider", "NHibernate.Connection.DriverConnectionProvider, NHibernate");
cfg.SetProperty("connection.connection_string_name", "TinySheets");
cfg.SetProperty("proxyfactory.factory_class", "NHibernate.ByteCode.Castle.ProxyFactoryFactory, NHibernate.ByteCode.Castle");
cfg.AddAssembly(typeof(NHibernateModule).Assembly);
return cfg.BuildSessionFactory();
}
public void Setup()
{
_cfg = new Configuration();
_cfg.SetProperty("connection.provider", "NHibernate.Connection.DriverConnectionProvider");
_cfg.SetProperty("connection.driver_class", "NHibernate.Driver.SqlClientDriver");
_cfg.SetProperty("connection.connection_string", _connectionString);
_cfg.SetProperty("dialect", "NHibernate.Dialect.MsSql2005Dialect");
_cfg.SetProperty("default_schema", "bus");
_cfg.AddAssembly(typeof (NHibernateSagaRepository<>).Assembly);
_cfg.AddAssembly(typeof (RegisterUserStateMachine).Assembly);
_cfg.AddAssembly(typeof (SagaRepository_Specs).Assembly);
}
public static ISessionFactory CreateSessionFactory()
{
Configuration config;
ISessionFactory factory;
HttpContext currentContext = HttpContext.Current;
cAppConfig oApp;
Utility oUtil = new Utility();
config = new NHibernate.Cfg.Configuration();
if (HttpContext.Current == null)
{
oApp = new cAppConfig(ConfigFileType.AppConfig);
config.SetProperty("hibernate.connection.connection_string", oApp.GetValue("hibernate.connection.connection_string"));
}
else
{
oApp = new cAppConfig(ConfigFileType.WebConfig);
// string strDesEnc = oUtil.Decrypt(oApp.GetValue("hibernate.connection.connection_string"));
config.SetProperty("hibernate.connection.connection_string", oApp.GetValue("hibernate.connection.connection_string"));
}
if (config == null)
{
throw new InvalidOperationException("NHibernate configuration is null.");
}
if (HttpContext.Current == null)
{
config.SetProperty("hibernate.connection.connection_string", oApp.GetValue("hibernate.connection.connection_string"));
}
config.AddAssembly("Business");
factory = config.BuildSessionFactory();
if (currentContext != null)
{
currentContext.Items[KEY_NHIBERNATE_FACTORY] = factory;
}
if (factory == null)
{
throw new InvalidOperationException("Call to Configuration.BuildSessionFactory() returned null.");
}
else
{
return(factory);
}
}
protected override void AddMappings(Configuration configuration)
{
var xml = "<?xml version=\"1.0\" encoding=\"utf-8\" ?><hibernate-mapping xmlns=\"urn:nhibernate-mapping-2.2\" namespace=\"NHibernate.Test.VersionTest.Db\" assembly=\"NHibernate.Test\"><class name=\"ProductWithVersionAndLazyProperty\"><id name=\"Id\" generator=\"assigned\"/><version name=\"Version\" generated=\"always\" unsaved-value=\"null\" type=\"BinaryBlob\" access=\"nosetter.camelcase-underscore\"><column name=\"version\" not-null=\"false\" sql-type=\"timestamp\" /></version><property name=\"Summary\" lazy=\"true\"/></class></hibernate-mapping>";
var doc = new XmlDocument();
doc.LoadXml(xml);
configuration.AddDocument(doc);
base.AddMappings(configuration);
configuration.SetProperty(NHibernate.Cfg.Environment.Hbm2ddlAuto, SchemaAutoAction.Recreate.ToString());
configuration.SetProperty(NHibernate.Cfg.Environment.FormatSql, Boolean.TrueString);
configuration.SetProperty(NHibernate.Cfg.Environment.ShowSql, Boolean.TrueString);
}
/// <summary>
/// Initializes a new instance of the <see cref="TemporaryDatabase"/> class.
/// </summary>
public TemporaryDatabase()
{
_database = new TemporarySqlDatabase();
var configuration = new Configuration();
configuration.SetInterceptor(new PostSaveInterceptor());
configuration.SetProperty("connection.provider", "NHibernate.Connection.DriverConnectionProvider");
configuration.SetProperty("connection.driver_class", "NHibernate.Driver.SqlClientDriver");
configuration.SetProperty("connection.connection_string", _database.ConnectionString);
configuration.SetProperty("dialect", "NHibernate.Dialect.MsSql2005Dialect");
configuration.SetProperty("show_sql", "true");
configuration.AddAssembly(typeof(IRepository).Assembly);
_sessionFactory = configuration.BuildSessionFactory();
var upgradeManager = new DatabaseManager(_database.ConnectionString);
upgradeManager.PerformUpgrade();
}
/// <summary>
/// Initializes a new instance of the <see cref="TestableDatabase"/> class.
/// </summary>
public TestableDatabase()
{
_database = new TemporarySqlDatabase();
var configuration = new Configuration();
configuration.SetInterceptor(new PostSaveInterceptor());
configuration.SetProperty("connection.provider", "NHibernate.Connection.DriverConnectionProvider");
configuration.SetProperty("connection.driver_class", "NHibernate.Driver.SqlClientDriver");
configuration.SetProperty("connection.connection_string", _database.ConnectionString);
configuration.SetProperty("dialect", "NHibernate.Dialect.MsSql2005Dialect");
configuration.SetProperty("show_sql", "true");
configuration.AddMappingsFromAssembly(Cms.Domain.Properties.AssemblyReference.Assembly);
_sessionFactory = configuration.BuildSessionFactory();
var upgradeManager = new ApplicationDatabase(_database.ConnectionString);
upgradeManager.PerformUpgrade();
}
/// <summary>Adds properties to NHibernate configuration.</summary>
/// <param name="cfg"></param>
protected virtual void AddProperties(NHibernate.Cfg.Configuration cfg)
{
foreach (KeyValuePair <string, string> pair in Properties)
{
cfg.SetProperty(pair.Key, pair.Value);
}
}
public NHibernate.Cfg.Configuration BuildConfiguration(string connectionString, bool debug = false)
{
var configuration = new NHibernate.Cfg.Configuration();
configuration.SetProperty(Environment.ShowSql, "false");
//configure NH to use ISet from .NET instead of from Iesi.Collections
//configuration.SetProperty(Environment.CollectionTypeFactoryClass, typeof (Net4CollectionTypeFactory).AssemblyQualifiedName);
var builder = Fluently
.Configure(configuration)
.ProxyFactoryFactory <DefaultProxyFactoryFactory>()
.Database(MsSqlConfiguration.MsSql2008.ConnectionString(connectionString)
//.ShowSql()
//.FormatSql()
.Dialect <MsSql2008Dialect>()
)
.ExposeConfiguration(c =>
{
c.SetProperty(Environment.BatchSize, BatchSize.ToString(CultureInfo.InvariantCulture));
c.SetProperty("hbm2ddl.keywords", "auto-quote");
if (debug)
{
c.SetProperty(Environment.ShowSql, "true");
c.SetProperty(Environment.FormatSql, "true");
c.SetProperty("LogSqlInConsole", "true");
}
else
{
c.SetProperty(Environment.ShowSql, "false");
c.SetProperty(Environment.FormatSql, "false");
c.SetProperty("LogSqlInConsole", "false");
}
c.SetProperty("nhibernate-logger", typeof(NLogFactory).AssemblyQualifiedName);
})
.Mappings(m =>
{
var model = AutoMap.Assemblies(new AppAutomappingCfg(), _assemblies);
m.AutoMappings.Add(model);
})
;
if (debug)
{
builder = builder.ExposeConfiguration(cfg =>
{
const string schemaPath = @"c:\temp\nh_mappings_export\schema.sql";
using (var file = File.Open(schemaPath, FileMode.CreateNew))
using (var writer = new StreamWriter(file))
{
var se = new SchemaExport(cfg);
se.Create(writer, false);
}
});
}
_config = builder
.BuildConfiguration();
return(_config);
}
protected override void Configure(Configuration configuration)
{
if (Dialect is MsSql2005Dialect)
configuration.SetProperty(Environment.Dialect, typeof(CustomDialect).AssemblyQualifiedName);
else
appliesToThisDialect = false;
}
static NHSession()
{
NHibernate.Cfg.Configuration config = new NHibernate.Cfg.Configuration().Configure();
config.SetProperty("connection.connection_string", ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString);
sessionfactory = config.BuildSessionFactory();
}
/// <summary>Adds properties to NHibernate configuration.</summary>
/// <param name="cfg"></param>
protected virtual void AddProperties(NHibernate.Cfg.Configuration cfg)
{
cfg.LinqToHqlGeneratorsRegistry <WhereDetailHqlGeneratorRegistry>();
foreach (KeyValuePair <string, string> pair in Properties)
{
cfg.SetProperty(pair.Key, pair.Value);
}
}
static async Task AsyncMain()
{
Console.Title = "Samples.SQLNHibernateOutboxEF.Receiver";
var connectionString = @"Data Source=.\SqlExpress;Database=nservicebus;Integrated Security=True";
var startupSql = File.ReadAllText("Startup.sql");
await SqlHelper.ExecuteSql(connectionString, startupSql)
.ConfigureAwait(false);
var hibernateConfig = new Configuration();
hibernateConfig.DataBaseIntegration(x =>
{
x.ConnectionStringName = "NServiceBus/Persistence";
x.Dialect <MsSql2012Dialect>();
});
hibernateConfig.SetProperty("default_schema", "receiver");
var endpointConfiguration = new EndpointConfiguration("Samples.SQLNHibernateOutboxEF.Receiver");
endpointConfiguration.UseSerialization <JsonSerializer>();
endpointConfiguration.EnableInstallers();
endpointConfiguration.SendFailedMessagesTo("error");
#region ReceiverConfiguration
var transport = endpointConfiguration.UseTransport <SqlServerTransport>();
var routing = transport.Routing();
routing.RouteToEndpoint(typeof(OrderAccepted).Assembly, "Samples.SQLNHibernateOutboxEF.Sender");
routing.RegisterPublisher(typeof(OrderAccepted).Assembly, "Samples.SQLNHibernateOutboxEF.Sender");
transport.DefaultSchema("receiver");
transport.UseSchemaForEndpoint("Samples.SQLNHibernateOutboxEF.Sender", "sender");
transport.UseSchemaForQueue("error", "dbo");
transport.UseSchemaForQueue("audit", "dbo");
endpointConfiguration
.UsePersistence <NHibernatePersistence>();
endpointConfiguration.EnableOutbox();
#endregion
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
Console.WriteLine("Press any key to exit");
Console.ReadKey();
await endpointInstance.Stop()
.ConfigureAwait(false);
}
public static ISession GetSession()
{
try
{
if (_sessionFactory == null)
{
lock (typeof(NHibernateHelper))
{
if (_sessionFactory == null)
{
Configuration cfg = new Configuration();
string connectionString = "Server=GMEPN000749\\SQLSERVER;Database=TESTE;Trusted_Connection=True;";
NHibernate.Cfg.Configuration nHibernateConfiguration = new NHibernate.Cfg.Configuration();
nHibernateConfiguration.SetProperty(NHibernate.Cfg.Environment.ProxyFactoryFactoryClass, typeof(NHibernate.ByteCode.Castle.ProxyFactoryFactory).AssemblyQualifiedName);
nHibernateConfiguration.SetProperty(NHibernate.Cfg.Environment.Dialect, typeof(NHibernate.Dialect.MsSql2008Dialect).AssemblyQualifiedName);
nHibernateConfiguration.SetProperty(NHibernate.Cfg.Environment.ConnectionString, connectionString);
nHibernateConfiguration.SetProperty(NHibernate.Cfg.Environment.ShowSql, "true");
nHibernateConfiguration.AddAssembly("MapeamentoOR");
//objProperties.Add("proxyfactory.factory_class", "NHibernate.ByteCode.Castle.ProxyFactoryFactory, NHibernate.ByteCode.Castle");
ISessionFactory oneISessionFactory = nHibernateConfiguration
.BuildSessionFactory();
//cfg.AddProperties("")
//cfg.AddAssembly("MapeamentoOR");
//_sessionFactory = cfg.BuildSessionFactory();
return(oneISessionFactory.OpenSession());
}
}
}
}
catch (Exception e) {
}
return(null);
}
static void Main()
{
SqlHelper.CreateDatabase(ConfigurationManager.ConnectionStrings["NServiceBus/Persistence"].ConnectionString);
Configuration nhConfiguration = new Configuration();
nhConfiguration.SetProperty(Environment.ConnectionProvider, "NHibernate.Connection.DriverConnectionProvider");
nhConfiguration.SetProperty(Environment.ConnectionDriver, "NHibernate.Driver.Sql2008ClientDriver");
nhConfiguration.SetProperty(Environment.Dialect, "NHibernate.Dialect.MsSql2008Dialect");
nhConfiguration.SetProperty(Environment.ConnectionStringName, "NServiceBus/Persistence");
BusConfiguration busConfiguration = new BusConfiguration();
busConfiguration.EndpointName("Samples.CustomNhMappings.Default");
busConfiguration.UseSerialization <JsonSerializer>();
busConfiguration.EnableInstallers();
//busConfiguration.Transactions().DisableDistributedTransactions();
busConfiguration
.UsePersistence <NHibernatePersistence>()
.UseConfiguration(nhConfiguration);
using (IBus bus = Bus.Create(busConfiguration).Start())
{
Parallel.For(0, 1000, i =>
{
bus.SendLocal(new StartOrder
{
OrderId = "123"
});
bus.SendLocal(new CompleteOrder
{
OrderId = "123"
});
});
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
}
static async Task AsyncMain1()
{
Console.Title = "Samples.PubSub.Publisher";
var endpointConfiguration = new EndpointConfiguration("Samples.PubSub.Publisher");
//endpointConfiguration.UsePersistence<LearningPersistence>();
//endpointConfiguration.UseTransport<LearningTransport>();
//Persistence
var persistence = endpointConfiguration.UsePersistence <NHibernatePersistence>();
var nhConfig = new NHibernate.Cfg.Configuration();
nhConfig.SetProperty(NHibernate.Cfg.Environment.ConnectionProvider, "NHibernate.Connection.DriverConnectionProvider");
nhConfig.SetProperty(NHibernate.Cfg.Environment.ConnectionDriver, "NHibernate.Driver.Sql2008ClientDriver");
nhConfig.SetProperty(NHibernate.Cfg.Environment.Dialect, "NHibernate.Dialect.MsSql2008Dialect");
nhConfig.SetProperty(NHibernate.Cfg.Environment.ConnectionString, ConfigurationManager.ConnectionStrings["NSB_AWS.NHibernatePersistence"].ConnectionString);
nhConfig.SetProperty(NHibernate.Cfg.Environment.DefaultSchema, "nsb");
persistence.UseConfiguration(nhConfig);
//Transport
var transport = endpointConfiguration.UseTransport <SqlServerTransport>()
.ConnectionString(ConfigurationManager.ConnectionStrings["NSB_AWS.SqlServerTransport"].ConnectionString);
transport.DefaultSchema("nsb");
var routing = transport.Routing();
routing.RegisterPublisher(typeof(OrderPlaced), "Samples.PubSub.Publisher");
endpointConfiguration.SendFailedMessagesTo("error");
endpointConfiguration.EnableInstallers();
var endpointInstance = await Endpoint.Start(endpointConfiguration)
.ConfigureAwait(false);
await Start(endpointInstance)
.ConfigureAwait(false);
await endpointInstance.Stop()
.ConfigureAwait(false);
}
protected SessionFactoryProvider(IConfiguration configuration, string nick, IInterceptor interceptor)
{
connectionInfo = configuration.GetSection("db")
.Get <ConnectionInfo[]>()
.SingleOrDefault(ci => ci.Nick == nick && ci.DbServerType == ServerType);
if (connectionInfo == null)
{
throw new InvalidOperationException($"Connection with name {nick} is not found");
}
nhConfig = new NhConfiguration();
nhConfig.CurrentSessionContext <ThreadLocalSessionContext>();
nhConfig.SetProperty(Environment.SessionFactoryName, nick);
nhConfig.Interceptor = interceptor ?? new EmptyInterceptor();
nhConfig.SetProperty(Environment.UseSecondLevelCache, "false");
Logger.LogDebug("NHibernate configuration: " + $"DbNick: {nhConfig.GetProperty(Environment.SessionFactoryName)}, "
+ $"UseSecondLevelCache: {nhConfig.GetProperty(Environment.UseSecondLevelCache)}, "
+ $"CacheDefaultExpiration: {nhConfig.GetProperty(Environment.CacheDefaultExpiration)}");
Nick = nick;
IsSkipHealthCheckEntity = connectionInfo.IsSkipHealthCheckEntity;
}
/// <summary>
///
/// </summary>
/// <param name="properties"></param>
/// <param name="resources"></param>
public void Configure(NameValueCollection properties, IDictionary resources)
{
string mapping = string.Empty;
try
{
NHibernate.Cfg.Configuration config = new NHibernate.Cfg.Configuration();
// Set the connection string retrieve on the datasource
config.SetProperty(CONNECTION_STRING, (resources["DataSource"] as DataSource).ConnectionString);
foreach (DictionaryEntry entry in resources)
{
if ((entry.Key.ToString()).StartsWith("class."))
{
config.AddClass(Resources.TypeForName(entry.Value.ToString()));
}
if ((entry.Key.ToString()) == "mapping")
{
mapping = entry.Value.ToString();
}
config.SetProperty(entry.Key.ToString(), entry.Value.ToString());
}
if (mapping.Length > 0)
{
config.AddAssembly(mapping);
}
_factory = config.BuildSessionFactory();
}
catch (Exception e)
{
throw new ConfigurationException(string.Format("DaoManager could not configure NHibernateDaoSessionHandler. Cause: {0}", e.Message), e);
}
}
public static ISessionFactory GetSessionFactory()
{
var configuration = new NHibernate.Cfg.Configuration();
configuration.Configure();
configuration.AddAssembly(typeof(SessionFactoryFactory).Assembly.GetName().Name);
configuration.SetProperty(Environment.ConnectionString,
ConfigurationManager.ConnectionStrings["ProjectTemplate"].ConnectionString);
log4net.Config.XmlConfigurator.Configure();
var sessionFactory = configuration.BuildSessionFactory();
return(sessionFactory);
}
static void Main()
{
Console.Title = "Samples.SQLNHibernateOutboxEF.Receiver";
var connectionString = @"Data Source=.\SqlExpress;Database=nservicebus;Integrated Security=True";
var startupSql = File.ReadAllText("Startup.sql");
SqlHelper.ExecuteSql(connectionString, startupSql);
var hibernateConfig = new Configuration();
hibernateConfig.DataBaseIntegration(
dataBaseIntegration: configurationProperties =>
{
configurationProperties.ConnectionStringName = "NServiceBus/Persistence";
configurationProperties.Dialect <MsSql2012Dialect>();
});
hibernateConfig.SetProperty("default_schema", "receiver");
var busConfiguration = new BusConfiguration();
busConfiguration.UseSerialization <JsonSerializer>();
busConfiguration.EndpointName("Samples.SQLNHibernateOutboxEF.Receiver");
#region ReceiverConfiguration
var transport = busConfiguration.UseTransport <SqlServerTransport>();
var connectionInfo = EndpointConnectionInfo.For("Samples.SQLNHibernateOutboxEF.Sender")
.UseSchema("sender");
transport.UseSpecificConnectionInformation(connectionInfo);
transport.DefaultSchema("receiver");
var persistence = busConfiguration.UsePersistence <NHibernatePersistence>();
persistence.RegisterManagedSessionInTheContainer();
busConfiguration.EnableOutbox();
#endregion
using (Bus.Create(busConfiguration).Start())
{
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
}
public static void ResetSessionFactory()
{
Configuration config;
HttpContext currentContext = HttpContext.Current;
cAppConfig oApp = new cAppConfig(ConfigFileType.AppConfig);
config = new NHibernate.Cfg.Configuration();
config.SetProperty("hibernate.connection.connection_string", oApp.GetValue("hibernate.connection.connection_string"));
config.AddAssembly("Business");
NHibernateHttpModule.m_factory = config.BuildSessionFactory();
NHibernateHttpModule.m_session = NHibernateHttpModule.m_factory.OpenSession();
if (NHibernateHttpModule.m_factory == null)
{
throw new InvalidOperationException("Call to Configuration.BuildSessionFactory() returned null.");
}
}
private static void OptimizePerformance(NHConfig.Configuration configuration)
{
configuration
.SetProperty(NHConfig.Environment.FormatSql, bool.FalseString)
.SetProperty(NHConfig.Environment.GenerateStatistics, bool.FalseString)
.SetProperty(NHConfig.Environment.Hbm2ddlKeyWords, Hbm2DDLKeyWords.None.ToString())
.SetProperty(NHConfig.Environment.PrepareSql, bool.TrueString)
.SetProperty(NHConfig.Environment.PropertyBytecodeProvider, BytecodeProviderType.Lcg.ToString())
.SetProperty(NHConfig.Environment.PropertyUseReflectionOptimizer, bool.TrueString)
.SetProperty(NHConfig.Environment.QueryStartupChecking, bool.FalseString)
.SetProperty(NHConfig.Environment.ShowSql, bool.TrueString)
.SetProperty(NHConfig.Environment.UseProxyValidator, bool.FalseString)
.SetProperty(NHConfig.Environment.UseSecondLevelCache, bool.FalseString)
.SetProperty(NHConfig.Environment.UseSqlComments, bool.FalseString)
.SetProperty(NHConfig.Environment.UseQueryCache, bool.FalseString)
.SetProperty(NHConfig.Environment.WrapResultSets, bool.TrueString);
// remove support for pre & post load event listeners to improve performance
configuration.EventListeners.PostLoadEventListeners = new IPostLoadEventListener[0];
configuration.EventListeners.PreLoadEventListeners = new IPreLoadEventListener[0];
}
private static NHConfig.Configuration BuildConfiguration()
{
var configuration = new NHConfig.Configuration();
configuration
.SetProperty(NHConfig.Environment.ConnectionDriver, typeof(SQLite20Driver).AssemblyQualifiedName)
.SetProperty(NHConfig.Environment.Dialect, typeof(SQLiteDialect).AssemblyQualifiedName)
.SetProperty(NHConfig.Environment.QuerySubstitutions, QuerySubstitutions)
.SetProperty(NHConfig.Environment.CurrentSessionContextClass, typeof(ThreadStaticSessionContext).AssemblyQualifiedName)
.SetProperty(NHConfig.Environment.ProxyFactoryFactoryClass, typeof(DefaultProxyFactoryFactory).AssemblyQualifiedName)
.SetProperty(NHConfig.Environment.Isolation, IsolationLevel.ReadCommitted.ToString())
.SetProperty(NHConfig.Environment.ConnectionString, InMemoryConnectionString);
var mappings = BuildMappings();
configuration.AddMapping(mappings);
OptimizePerformance(configuration);
return(configuration);
}
public NHibernate.Cfg.Configuration Configure()
{
var config = new NHibernate.Cfg.Configuration();
config.SetProperty(Environment.ReleaseConnections, "on_close")
.SetProperty(Environment.Dialect, typeof(NHibernate.Spatial.Dialect.MsSql2008GeographyDialect).AssemblyQualifiedName)
.SetProperty(Environment.ConnectionDriver, typeof(NHibernate.Driver.SqlClientDriver).AssemblyQualifiedName);
var modelMapper = new ModelMapper(new ModelInspector());
modelMapper.AddMappings(typeof(ModelInspector).Assembly.GetExportedTypes());
var mapping = modelMapper.CompileMappingForAllExplicitlyAddedEntities();
config.AddMapping(mapping);
config.SetListener(NHibernate.Event.ListenerType.PostUpdate, new FullTextIndexEventListener());
config.SetListener(NHibernate.Event.ListenerType.PostInsert, new FullTextIndexEventListener());
config.SetListener(NHibernate.Event.ListenerType.PostDelete, new FullTextIndexEventListener());
return(config);
}
/// <summary>
/// Initializes a new instance of the <see cref="NHibernateRegistry" /> class.
/// Конструктор
/// </summary>
public NHibernateRegistry()
{
var configuration = new Configuration();
configuration.Configure();
var defaultConnectionString = ConfigurationManager.ConnectionStrings["default"];
configuration.SetProperty(Environment.ConnectionString, defaultConnectionString.ConnectionString);
configuration.CurrentSessionContext <SmartSessionContext>();
var sessionFactory = configuration.BuildSessionFactory();
ForSingletonOf <ISessionFactory>().Use(sessionFactory);
var manager = new ManagerSessionFactorys();
manager.SetDefaultFactory(sessionFactory);
if (ConfigManager.PoolNhibernateSection != null)
{
foreach (var file in ConfigManager.PoolNhibernateSection.FileNameConfigaration.Cast <FileNameElement>())
{
configuration = new Configuration();
var filename = file.FileNameConfiguration;
if (!File.Exists(file.FileNameConfiguration))
{
filename = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, file.FileNameConfiguration);
}
configuration.Configure(filename);
var connectionString = ConfigurationManager.ConnectionStrings[file.FileNameConfiguration];
configuration.SetProperty(Environment.ConnectionString, connectionString.ConnectionString);
configuration.CurrentSessionContext <SmartSessionContext>();
sessionFactory = configuration.BuildSessionFactory();
manager.AddSessionFactory(file.FileNameConfiguration, sessionFactory);
}
}
ForSingletonOf <IManagerSessionFactorys>().Use(manager);
}
static void Main(string[] args)
{
var hibernateConfig = new Configuration();
hibernateConfig.DataBaseIntegration(x =>
{
x.ConnectionStringName = "NServiceBus/Persistence";
x.Dialect <MsSql2012Dialect>();
});
#region NHibernate
hibernateConfig.SetProperty("default_schema", "receiver");
#endregion
var mapper = new ModelMapper();
mapper.AddMapping <OrderMap>();
hibernateConfig.AddMapping(mapper.CompileMappingForAllExplicitlyAddedEntities());
new SchemaExport(hibernateConfig).Execute(false, true, false);
#region ReceiverConfiguration
var busConfig = new BusConfiguration();
busConfig.UseTransport <SqlServerTransport>().DefaultSchema("receiver")
.UseSpecificConnectionInformation(endpoint =>
{
var schema = endpoint.Split(new[] { '.' }, StringSplitOptions.RemoveEmptyEntries)[0].ToLowerInvariant();
return(ConnectionInfo.Create().UseSchema(schema));
});
busConfig.UsePersistence <NHibernatePersistence>().UseConfiguration(hibernateConfig);
#endregion
using (Bus.Create(busConfig).Start())
{
Console.WriteLine("Press <enter> to exit");
Console.ReadLine();
}
}
public static Configuration LinqToHqlGeneratorsRegistry <TLinqToHqlGeneratorsRegistry>(this Configuration configuration) where TLinqToHqlGeneratorsRegistry : ILinqToHqlGeneratorsRegistry
{
configuration.SetProperty(Environment.LinqToHqlGeneratorsRegistry, typeof(TLinqToHqlGeneratorsRegistry).AssemblyQualifiedName);
return(configuration);
}
/// <summary>
/// Initialize the SessionFactory for the given or the
/// default location.
/// </summary>
public virtual void AfterPropertiesSet()
{
// Create Configuration instance.
Configuration config = NewConfiguration();
if (this.dbProvider != null)
{
config.SetProperty(Environment.ConnectionString, dbProvider.ConnectionString);
config.SetProperty(Environment.ConnectionProvider, typeof(DbProviderWrapper).AssemblyQualifiedName);
configTimeDbProvider = this.dbProvider;
}
if (ExposeTransactionAwareSessionFactory)
{
// Set ICurrentSessionContext implementation,
// providing the Spring-managed ISession s current Session.
// Can be overridden by a custom value for the corresponding Hibernate property
config.SetProperty(Environment.CurrentSessionContextClass, typeof(SpringSessionContext).AssemblyQualifiedName);
}
if (this.entityInterceptor != null)
{
// Set given entity interceptor at SessionFactory level.
config.SetInterceptor(this.entityInterceptor);
}
if (this.namingStrategy != null)
{
// Pass given naming strategy to Hibernate Configuration.
config.SetNamingStrategy(this.namingStrategy);
}
#if NH_2_1
if (this.typeDefinitions != null)
{
// Register specified Hibernate type definitions.
IDictionary <string, string> typedProperties = new Dictionary <string, string>();
foreach (DictionaryEntry entry in hibernateProperties)
{
typedProperties.Add((string)entry.Key, (string)entry.Value);
}
Dialect dialect = Dialect.GetDialect(typedProperties);
Mappings mappings = config.CreateMappings(dialect);
for (int i = 0; i < this.typeDefinitions.Length; i++)
{
IObjectDefinition typeDef = this.typeDefinitions[i];
Dictionary <string, string> typedParamMap = new Dictionary <string, string>();
foreach (DictionaryEntry entry in typeDef.PropertyValues)
{
typedParamMap.Add((string)entry.Key, (string)entry.Value);
}
mappings.AddTypeDef(typeDef.ObjectTypeName, typeDef.ObjectTypeName, typedParamMap);
}
}
#endif
if (this.filterDefinitions != null)
{
// Register specified NHibernate FilterDefinitions.
for (int i = 0; i < this.filterDefinitions.Length; i++)
{
config.AddFilterDefinition(this.filterDefinitions[i]);
}
}
#if NH_2_1
// check whether proxy factory has been initialized
if (config.GetProperty(Environment.ProxyFactoryFactoryClass) == null &&
(hibernateProperties == null || !hibernateProperties.Contains(Environment.ProxyFactoryFactoryClass)))
{
// nothing set by user, lets use Spring.NET's proxy factory factory
#region Logging
if (log.IsInfoEnabled)
{
log.Info("Setting proxy factory to Spring provided one as user did not specify any");
}
#endregion
config.Properties.Add(
Environment.ProxyFactoryFactoryClass, typeof(Bytecode.ProxyFactoryFactory).AssemblyQualifiedName);
}
#endif
if (this.hibernateProperties != null)
{
if (config.GetProperty(Environment.ConnectionProvider) != null &&
hibernateProperties.Contains(Environment.ConnectionProvider))
{
#region Logging
if (log.IsInfoEnabled)
{
log.Info("Overriding use of Spring's Hibernate Connection Provider with [" +
hibernateProperties[Environment.ConnectionProvider] + "]");
}
#endregion
config.Properties.Remove(Environment.ConnectionProvider);
}
Dictionary <string, string> genericHibernateProperties = new Dictionary <string, string>();
foreach (DictionaryEntry entry in hibernateProperties)
{
genericHibernateProperties.Add((string)entry.Key, (string)entry.Value);
}
config.AddProperties(genericHibernateProperties);
}
if (this.mappingAssemblies != null)
{
foreach (string assemblyName in mappingAssemblies)
{
config.AddAssembly(assemblyName);
}
}
if (this.mappingResources != null)
{
IResourceLoader loader = this.ResourceLoader;
if (loader == null)
{
loader = this.applicationContext;
}
foreach (string resourceName in mappingResources)
{
config.AddInputStream(loader.GetResource(resourceName).InputStream);
}
}
if (configFilenames != null)
{
foreach (string configFilename in configFilenames)
{
config.Configure(configFilename);
}
}
#if NH_2_1
// Tell Hibernate to eagerly compile the mappings that we registered,
// for availability of the mapping information in further processing.
PostProcessMappings(config);
config.BuildMappings();
if (this.entityCacheStrategies != null)
{
// Register cache strategies for mapped entities.
foreach (string className in this.entityCacheStrategies.Keys)
{
String[] strategyAndRegion = StringUtils.CommaDelimitedListToStringArray(this.entityCacheStrategies.GetProperty(className));
if (strategyAndRegion.Length > 1)
{
config.SetCacheConcurrencyStrategy(className, strategyAndRegion[0], strategyAndRegion[1]);
}
else if (strategyAndRegion.Length > 0)
{
config.SetCacheConcurrencyStrategy(className, strategyAndRegion[0]);
}
}
}
if (this.collectionCacheStrategies != null)
{
// Register cache strategies for mapped collections.
foreach (string collRole in collectionCacheStrategies.Keys)
{
string[] strategyAndRegion = StringUtils.CommaDelimitedListToStringArray(this.collectionCacheStrategies.GetProperty(collRole));
if (strategyAndRegion.Length > 1)
{
throw new Exception("Collection cache concurrency strategy region definition not supported yet");
//config.SetCollectionCacheConcurrencyStrategy(collRole, strategyAndRegion[0], strategyAndRegion[1]);
}
else if (strategyAndRegion.Length > 0)
{
config.SetCollectionCacheConcurrencyStrategy(collRole, strategyAndRegion[0]);
}
}
}
#endif
if (this.eventListeners != null)
{
// Register specified NHibernate event listeners.
foreach (DictionaryEntry entry in eventListeners)
{
ListenerType listenerType;
try
{
listenerType = (ListenerType)Enum.Parse(typeof(ListenerType), (string)entry.Key);
}
catch
{
throw new ArgumentException(string.Format("Unable to parse string '{0}' as valid {1}", entry.Key, typeof(ListenerType)));
}
object listenerObject = entry.Value;
if (listenerObject is ICollection)
{
ICollection listeners = (ICollection)listenerObject;
EventListeners listenerRegistry = config.EventListeners;
// create the array and check that types are valid at the same time
ArrayList items = new ArrayList(listeners);
object[] listenerArray = (object[])items.ToArray(listenerRegistry.GetListenerClassFor(listenerType));
config.SetListeners(listenerType, listenerArray);
}
else
{
config.SetListener(listenerType, listenerObject);
}
}
}
// Perform custom post-processing in subclasses.
PostProcessConfiguration(config);
#if NH_2_1
if (BytecodeProvider != null)
{
// set custom IBytecodeProvider
Environment.BytecodeProvider = BytecodeProvider;
}
else
{
// use Spring's as default
// Environment.BytecodeProvider = new Bytecode.BytecodeProvider(this.applicationContext);
}
#endif
// Build SessionFactory instance.
log.Info("Building new Hibernate SessionFactory");
this.configuration = config;
this.sessionFactory = NewSessionFactory(config);
AfterSessionFactoryCreation();
// set config time DB provider back to null
configTimeDbProvider = null;
}
protected override void Configure(NHibernate.Cfg.Configuration configuration)
{
configuration.SetProperty(Environment.FormatSql, "false");
}
public virtual EndpointConfiguration BuildConfig()
{
GCSettings.LatencyMode = GCLatencyMode.Batch; // https://docs.microsoft.com/en-us/dotnet/standard/garbage-collection/latency
ServicePointManager.Expect100Continue = false;
ServicePointManager.UseNagleAlgorithm = false;
ServicePointManager.DefaultConnectionLimit = 125; // Querying of DefaultConnectionLimit on dotnet core does not return assigned value
//logger
ConfigureNsbLogger();
//endpoint name
if (string.IsNullOrEmpty(_configEndpointName))
{
throw new ArgumentNullException(_configEndpointName, "Endpoint name cannot be null");
}
var endpointConfiguration = new EndpointConfiguration(_configEndpointName);
endpointConfiguration.LimitMessageProcessingConcurrencyTo(Environment.ProcessorCount * 4);
if (_isSendOnly)
{
endpointConfiguration.SendOnly();
}
//Transport
var transportType = TransportType.Sqs;
//serializer
endpointConfiguration.UseSerialization <XmlSerializer>();
var connectionString = "Server=.;Initial Catalog=support/20180629;Integrated Security=True";
var persistence = endpointConfiguration.UsePersistence <NHibernatePersistence>();
var nhConfig = new NHibernate.Cfg.Configuration();
nhConfig.SetProperty(NHibernate.Cfg.Environment.ConnectionProvider, typeof(NHibernate.Connection.DriverConnectionProvider).FullName);
nhConfig.SetProperty(NHibernate.Cfg.Environment.ConnectionDriver, typeof(NHibernate.Driver.Sql2008ClientDriver).FullName);
nhConfig.SetProperty(NHibernate.Cfg.Environment.Dialect, typeof(NHibernate.Dialect.MsSql2012Dialect).FullName);
nhConfig.SetProperty(NHibernate.Cfg.Environment.ConnectionString, connectionString);
nhConfig.SetProperty(NHibernate.Cfg.Environment.DefaultSchema, "dbo");
persistence.UseConfiguration(nhConfig);
persistence.EnableCachingForSubscriptionStorage(TimeSpan.FromSeconds(10));
endpointConfiguration.SendFailedMessagesTo("error");
//endpointConfiguration.AuditProcessedMessagesTo("audit");
//endpointConfiguration.EnableOutbox();
switch (transportType)
{
case TransportType.Sql:
{
var transport = endpointConfiguration.UseTransport <SqlServerTransport>();
transport.ConnectionString(connectionString);
transport.DefaultSchema("dbo");
transport.Transactions(TransportTransactionMode.ReceiveOnly);
BuildEndpointSQLRouting(transport.Routing());
break;
}
case TransportType.Sqs:
{
var region = RegionEndpoint.EUWest1;
var S3BucketName = "ramon-sqs";
var S3KeyPrefix = "support/20180629";
var transport = endpointConfiguration.UseTransport <SqsTransport>();
transport.ClientFactory(() => new AmazonSQSClient(
new AmazonSQSConfig
{
RegionEndpoint = region,
MaxErrorRetry = 2,
}));
var s3Configuration = transport.S3(S3BucketName, S3KeyPrefix);
s3Configuration.ClientFactory(() => new AmazonS3Client(
new AmazonS3Config
{
RegionEndpoint = region
}));
//Routing
BuildEndpointSQSRouting(transport.Routing());
transport.QueueNamePrefix("ramon-support-20180629-");
break;
}
case TransportType.Learning:
{
endpointConfiguration.UsePersistence <LearningPersistence>();
var transport = endpointConfiguration.UseTransport <LearningTransport>();
endpointConfiguration.DisableFeature <TimeoutManager>(); // REVIEW: Why are you disabling the timeout manager??
BuildEndpointLearningRouting(transport.Routing());
break;
}
default:
throw new Exception("Unexpected Case");
}
//Auto installer
//#if DEBUG
endpointConfiguration.EnableInstallers();
//#else
// endpointConfiguration.DisableInstallers();
//#endif
var performanceCounters = endpointConfiguration.EnableWindowsPerformanceCounters();
performanceCounters.EnableSLAPerformanceCounters(TimeSpan.FromSeconds(100));
return(endpointConfiguration);
}
protected override void Configure(NHCfg.Configuration configuration)
{
configuration.SetProperty(NHCfg.Environment.UseSecondLevelCache, "true");
configuration.SetProperty(NHCfg.Environment.GenerateStatistics, "true");
}
/// <summary>
/// Main NHibernate configuration method.
/// It configures NHibernate in an opinionated way, with an option to override various small NHibernate settings by overriding
/// other virtual methods.
/// This method can be overridden to completely customize NHibernate configuration.
/// </summary>
/// <param name="shouldMapDtos">See the constructor</param>
/// <param name="configurationFileName">See the constructor</param>
/// <param name="connectionString">See the constructor</param>
/// <param name="sessionFactory">NHibernate session factory</param>
/// <param name="configuration">NHibernate configuration</param>
protected virtual void ConfigureNhibernate(
bool shouldMapDtos,
string configurationFileName,
string connectionString,
out ISessionFactory sessionFactory,
out Configuration configuration
)
{
configuration = new Configuration();
if (string.IsNullOrWhiteSpace(configurationFileName))
{
configuration.Configure();
}
else
{
configuration.Configure(configurationFileName);
}
var assembliesToMap = GetAssembliesToMap();
var isTypeDto = GetIsTypeDtoFunc();
var autoPersistenceModel = AutoMap.Assemblies(
GetAutomappingConfiguration(shouldMapDtos, isTypeDto),
assembliesToMap
);
GetIncludeBaseTypes().Each(x => autoPersistenceModel.IncludeBase(x));
GetIgnoreBaseTypes().Each(x => autoPersistenceModel.IgnoreBase(x));
assembliesToMap.Each(x => autoPersistenceModel.UseOverridesFromAssembly(x));
_configureConventions();
configuration.SetNamingStrategy(GetNamingStrategy());
var fluentConfiguration = Fluently.Configure(configuration)
.Mappings(x =>
{
var mappingsContainer = x.AutoMappings.Add(autoPersistenceModel);
var exportNhibernateMappingsPath = GetExportNhibernateMappingsPath();
if (!string.IsNullOrWhiteSpace(exportNhibernateMappingsPath))
{
mappingsContainer.ExportTo(exportNhibernateMappingsPath);
}
});
if (!string.IsNullOrWhiteSpace(connectionString))
{
configuration.SetProperty(Environment.ConnectionString, connectionString);
}
AdditionalConfiguration(configuration);
sessionFactory = fluentConfiguration.BuildSessionFactory();
void _configureConventions()
{
if (ShouldUseDefaultConventions())
{
DisableLazyLoadForDtosConvention.Initialize(isTypeDto);
HasManyConvention.Initialize(
GetCollectionCascadeInstanceAction(),
GetBackingFieldNameFromPropertyNameFunc(),
GetCollectionInstanceAccessAction()
);
PrimaryKeyConvention.Initialize(GetIdentityHiLoMaxLo());
var disabledConventions = GetDisabledConventions();
var conventionTypes = Assembly.GetExecutingAssembly().GetTypes()
.Where(type => typeof(IConvention).IsAssignableFrom(type) &&
!type.IsInterface &&
!disabledConventions.Contains(type))
.ToList();
conventionTypes.Each(conventionType => autoPersistenceModel.Conventions.Add(conventionType));
}
GetAssembliesWithAdditionalConventions().Each(assembly => autoPersistenceModel.Conventions.AddAssembly(assembly));
GetAdditionalConventions().Each(conventionType => autoPersistenceModel.Conventions.Add(conventionType));
}
}
public static Configuration CurrentSessionContext <TCurrentSessionContext>(this Configuration configuration) where TCurrentSessionContext : ICurrentSessionContext
{
configuration.SetProperty(Environment.CurrentSessionContextClass, typeof(TCurrentSessionContext).AssemblyQualifiedName);
return(configuration);
}
public static Configuration SessionFactoryName(this Configuration configuration, string sessionFactoryName)
{
configuration.SetProperty(Environment.SessionFactoryName, sessionFactoryName);
return(configuration);
}
/// <summary>
/// Initialize the SessionFactory for the given or the
/// default location.
/// </summary>
public virtual void AfterPropertiesSet()
{
// Create Configuration instance.
Configuration config = NewConfiguration();
if (this.dbProvider != null)
{
config.SetProperty(Environment.ConnectionString, dbProvider.ConnectionString);
config.SetProperty(Environment.ConnectionProvider, typeof(DbProviderWrapper).AssemblyQualifiedName);
configTimeDbProvider = this.dbProvider;
}
if (ExposeTransactionAwareSessionFactory)
{
// Set ICurrentSessionContext implementation,
// providing the Spring-managed ISession s current Session.
// Can be overridden by a custom value for the corresponding Hibernate property
// config.SetProperty(Environment.CurrentSessionContextClass, typeof(SpringSessionContext).AssemblyQualifiedName);
config.SetProperty(Environment.CurrentSessionContextClass, typeof(WcfOperationSessionContext).AssemblyQualifiedName);
}
if (this.entityInterceptor != null)
{
// Set given entity interceptor at SessionFactory level.
config.SetInterceptor(this.entityInterceptor);
}
if (this.namingStrategy != null)
{
// Pass given naming strategy to Hibernate Configuration.
config.SetNamingStrategy(this.namingStrategy);
}
if (this.filterDefinitions != null)
{
// Register specified NHibernate FilterDefinitions.
for (int i = 0; i < this.filterDefinitions.Length; i++)
{
config.AddFilterDefinition(this.filterDefinitions[i]);
}
}
if (this.hibernateProperties != null)
{
if (config.GetProperty(Environment.ConnectionProvider) != null &&
hibernateProperties.Contains(Environment.ConnectionProvider))
{
#region Logging
if (log.IsInfoEnabled)
{
log.Info("Overriding use of Spring's Hibernate Connection Provider with [" +
hibernateProperties[Environment.ConnectionProvider] + "]");
}
#endregion
config.Properties.Remove(Environment.ConnectionProvider);
}
Dictionary <string, string> genericHibernateProperties = new Dictionary <string, string>();
foreach (DictionaryEntry entry in hibernateProperties)
{
genericHibernateProperties.Add((string)entry.Key, (string)entry.Value);
}
config.AddProperties(genericHibernateProperties);
}
if (this.mappingAssemblies != null)
{
foreach (string assemblyName in mappingAssemblies)
{
config.AddAssembly(assemblyName);
}
}
if (this.mappingResources != null)
{
IResourceLoader loader = this.ResourceLoader;
if (loader == null)
{
loader = this.applicationContext;
}
foreach (string resourceName in mappingResources)
{
config.AddInputStream(loader.GetResource(resourceName).InputStream);
}
}
if (configFilenames != null)
{
foreach (string configFilename in configFilenames)
{
config.Configure(configFilename);
}
}
if (this.eventListeners != null)
{
// Register specified NHibernate event listeners.
foreach (DictionaryEntry entry in eventListeners)
{
ListenerType listenerType;
try
{
listenerType = (ListenerType)Enum.Parse(typeof(ListenerType), (string)entry.Key);
}
catch
{
throw new ArgumentException(string.Format("Unable to parse string '{0}' as valid {1}", entry.Key, typeof(ListenerType)));
}
object listenerObject = entry.Value;
if (listenerObject is ICollection)
{
ICollection listeners = (ICollection)listenerObject;
EventListeners listenerRegistry = config.EventListeners;
// create the array and check that types are valid at the same time
ArrayList items = new ArrayList(listeners);
object[] listenerArray = (object[])items.ToArray(listenerRegistry.GetListenerClassFor(listenerType));
config.SetListeners(listenerType, listenerArray);
}
else
{
config.SetListener(listenerType, listenerObject);
}
}
}
// Perform custom post-processing in subclasses.
PostProcessConfiguration(config);
// Build SessionFactory instance.
log.Info("Building new Hibernate SessionFactory");
this.configuration = config;
this.sessionFactory = NewSessionFactory(config);
AfterSessionFactoryCreation();
// set config time DB provider back to null
configTimeDbProvider = null;
}
public static Configuration LinqQueryProvider <TQueryProvider>(this Configuration configuration) where TQueryProvider : INhQueryProvider
{
configuration.SetProperty(Environment.QueryLinqProvider, typeof(TQueryProvider).AssemblyQualifiedName);
return(configuration);
}
