private static Configuration GetConfiguracao()
{
Configuration cfg = new Configuration();
try
{
cfg.Configure().SetProperty("connection.connection_string", Sistema._conexaoBanco);
/** Classes Mapeadas */
cfg.AddInputStream(NHibernate.Mapping.Attributes.HbmSerializer.Default.Serialize(typeof(Produto)));
cfg.AddInputStream(NHibernate.Mapping.Attributes.HbmSerializer.Default.Serialize(typeof(Cliente)));
cfg.AddInputStream(NHibernate.Mapping.Attributes.HbmSerializer.Default.Serialize(typeof(HistoricoEstoque)));
cfg.AddInputStream(NHibernate.Mapping.Attributes.HbmSerializer.Default.Serialize(typeof(Ingrediente)));
cfg.AddInputStream(NHibernate.Mapping.Attributes.HbmSerializer.Default.Serialize(typeof(IngredienteProduto)));
cfg.AddInputStream(NHibernate.Mapping.Attributes.HbmSerializer.Default.Serialize(typeof(Usuario)));
cfg.AddInputStream(NHibernate.Mapping.Attributes.HbmSerializer.Default.Serialize(typeof(Venda)));
cfg.AddInputStream(NHibernate.Mapping.Attributes.HbmSerializer.Default.Serialize(typeof(VendaProduto)));
}
catch (Exception e)
{
Console.Write("Código: " + e.Source + " | Mensagem" + e.Message);
Sistema.logErro("Código: " + e.Source + " | Mensagem" + e.InnerException.Message);
throw new Exception("Erro geral: " + e.InnerException.Message);
}
return cfg;
}
private static void OpenSession()
{
Configuration = new Configuration().Configure();
Configuration.AddAssembly(Assembly.GetExecutingAssembly());
Configuration.AddInputStream(HbmSerializer.Default.Serialize(Assembly.GetExecutingAssembly()));
sessionFactory = Configuration.BuildSessionFactory();
}
private static void CreateMappingsFromAttributesAndAddToConfiguration(Configuration cfg)
{
HbmSerializer.Default.Validate = true;
HbmSerializer.Default.HbmDefaultAccess = "field.camelcase";
using (MemoryStream stream = HbmSerializer.Default.Serialize(Assembly.GetExecutingAssembly()))
{
cfg.AddInputStream(stream);
}
}
/// <summary>
/// 使用默认的配置文件注册（默认文件名：hibernate.cfg.xml）
/// </summary>
/// <param name="asm">带有映射关系Attribute的程序集</param>
public void Register(Assembly asm)
{
var cfg = new Configuration();
cfg.Configure();
HbmSerializer.Default.Validate = true; // Enable validation (optional)
// Here, we serialize all decorated classes (but you can also do it class by class)
cfg.AddInputStream(
HbmSerializer.Default.Serialize(asm));
// Now you can use this configuration to build your SessionFactory...
_sessionFactory = cfg.BuildSessionFactory();
}
VulDataBank()
{
Configuration cfg = new Configuration();
cfg.Configure();
HbmSerializer.Default.Validate = true; // Enable validation (optional)
// alle klassen serializeren van de assembly BadmintonORM
cfg.AddInputStream(HbmSerializer.Default.Serialize(typeof(ORMLid).Assembly));
sessionFactory = cfg.BuildSessionFactory();
}
ISession OpenSession()
{
NHibernate.Cfg.Configuration cfg = new NHibernate.Cfg.Configuration();
cfg.Configure("hibernate-attr.cfg.xml");
NHibernate.Mapping.Attributes.HbmSerializer.Default.Validate = true; // Enable validation (optional)
cfg.AddInputStream(NHibernate.Mapping.Attributes.HbmSerializer.Default.Serialize(System.Reflection.Assembly.GetAssembly(typeof(DeliveryOrder))));
ISessionFactory f = cfg.BuildSessionFactory();
return(f.OpenSession());
}
public ORMBadmintonDAO()
{
cfg = new Configuration();
cfg.Configure();
HbmSerializer.Default.Validate = true; // Enable validation (optional)
// alle klassen serializeren
//cfg.AddInputStream(HbmSerializer.Default.Serialize(System.Reflection.Assembly.GetExecutingAssembly()));
cfg.AddInputStream(HbmSerializer.Default.Serialize(typeof(ORMLid).Assembly));
sessionFactory = cfg.BuildSessionFactory();
}
static void AddAttributeMappings(Configuration nhConfiguration)
{
HbmSerializer hbmSerializer = new HbmSerializer
{
Validate = true
};
using (MemoryStream stream = hbmSerializer.Serialize(typeof(Program).Assembly))
{
nhConfiguration.AddInputStream(stream);
}
}
private static Configuration GetConfiguracao()
{
Configuration cfg = new Configuration();
try
{
cfg.Configure();
/** Classes Mapeadas */
cfg.AddInputStream(NHibernate.Mapping.Attributes.HbmSerializer.Default.Serialize(typeof(Aluno)));
cfg.AddInputStream(NHibernate.Mapping.Attributes.HbmSerializer.Default.Serialize(typeof(Usuario)));
}
catch (RepositorioException e)
{
Console.Write("Código: "+e.Source+" | Mensagem"+e.Message);
throw new RepositorioException("Hibernate não conseguiu carregar configurações do banco de dados");
}
catch (Exception e)
{
Console.Write("Código: " + e.Source + " | Mensagem" + e.Message);
throw new RepositorioException("Erro geral: "+e.Message);
}
return cfg;
}
static LiveSqliteSchema()
{
var config = new Configuration();
config.SetProperty(Environment.Dialect, "NHibernate.Dialect.SQLiteDialect");
config.AddInputStream(HbmSerializer.Default.Serialize(Assembly.Load("tanzer.lotto.core")));
Dialect dialect = Dialect.GetDialect(config.Properties);
// pause at critical moments; row COUNT; rollback journal; isolation level
// @sa http://www.sqlite.org/pragma.html
script = "PRAGMA synchronous=FALSE;PRAGMA count_changes=FALSE;PRAGMA journal_mode=FALSE;PRAGMA read_uncommitted=TRUE;";
script += String.Join(";", config.GenerateDropSchemaScript(dialect));
script += ";";
script += String.Join(";", config.GenerateSchemaCreationScript(dialect));
script += ";";
}
protected override void PostProcessConfiguration(Configuration config)
{
base.PostProcessConfiguration(config);
MemoryStream stream = new MemoryStream();
HbmSerializer.Default.Validate = true;
foreach (string modelAssemblyName in ModelAssemblyName)
{
Assembly assembly = Assembly.Load(modelAssemblyName);
HbmSerializer.Default.Serialize(stream, assembly);
stream.Position = 0;
config.AddInputStream(stream);
}
}
static NHibernateHelper()
{
Configuration config = new NHibernate.Cfg.Configuration().Configure(ConfigFilePath);
using (var stream = new MemoryStream())
{
HbmSerializer.Default.Serialize(stream, System.Reflection.Assembly.Load("Jieshai.Data"));
stream.Position = 0;
config.AddInputStream(stream);
}
sessionFactory = config.BuildSessionFactory();
}
public void init(String dbPath, bool create)
{
IDictionary<String, String> settings = new Dictionary<String, String>();
settings.Add("dialect", "NHibernate.Dialect.SQLiteDialect");
settings.Add("connection.provider", "NHibernate.Connection.DriverConnectionProvider");
settings.Add("connection.driver_class", "NHibernate.Driver.SQLite20Driver");
settings.Add("connection.connection_string", "Data Source=" + dbPath + ";Version=3");
settings.Add("hbm2ddl.auto", create ? "create" : "update");
try
{
cf = new Configuration();
cf.Properties = settings;
NHibernate.Mapping.Attributes.HbmSerializer.Default.Validate = true;
using (FileStream fs = File.Create(@"f:\temp\nhibernate.xml"))
{
System.IO.MemoryStream stream1 = new System.IO.MemoryStream();
NHibernate.Mapping.Attributes.HbmSerializer.Default.Serialize(
stream1, System.Reflection.Assembly.GetExecutingAssembly());
stream1.Position = 0;
stream1.WriteTo(fs);
stream1.Close();
}
System.IO.MemoryStream stream = new System.IO.MemoryStream();
NHibernate.Mapping.Attributes.HbmSerializer.Default.Serialize(
stream, System.Reflection.Assembly.GetExecutingAssembly());
stream.Position = 0;
cf.AddInputStream(stream);
sessionFactory = cf.BuildSessionFactory();
}
catch (System.Exception ex)
{
String err = ex.StackTrace;
Console.WriteLine(ex.Message);
Console.WriteLine(err);
if (ex.InnerException != null)
{
Console.WriteLine(ex.InnerException.Message);
Console.WriteLine(ex.InnerException.StackTrace);
}
throw;
}
}
private bool AddedMappingFromHbmResource(ItemDefinition definition, NHibernate.Cfg.Configuration cfg)
{
if (!TryLocatingHbmResources)
{
return(false);
}
Stream hbmXmlStream = definition.ItemType.Assembly.GetManifestResourceStream(definition.ItemType.FullName + ".hbm.xml");
if (hbmXmlStream == null)
{
return(false);
}
using (hbmXmlStream)
{
cfg.AddInputStream(hbmXmlStream);
return(true);
}
}
static Configuration ConfigureByCode()
{
Configuration cfg = new Configuration();
cfg.Properties[Environment.ConnectionProvider] =
"NHibernate.Connection.DriverConnectionProvider";
cfg.Properties[Environment.Dialect] =
"NHibernate.Dialect.MsSql2000Dialect";
cfg.Properties[Environment.ConnectionDriver] =
"NHibernate.Driver.SqlClientDriver";
cfg.Properties[Environment.ConnectionString] =
"Data Source=.\\SQLEXPRESS;Initial Catalog=HelloNHibernate;Integrated Security=SSPI";
cfg.AddAssembly(Assembly.GetCallingAssembly());
HbmSerializer.Default.Validate = true;
using (MemoryStream stream =
HbmSerializer.Default.Serialize(
Assembly.GetExecutingAssembly()))
cfg.AddInputStream(stream);
return cfg;
}
public void Open()
{
_database = new DatabaseManager();
_database.Recreate();
IDictionary<string, string> properties = SqlHelper.Provider.CreateNhibernateProperties();
properties["connection.provider"] = "NHibernate.Connection.DriverConnectionProvider";
properties["connection.connection_string"] = _database.Connection.ConnectionString;
properties["connection.release_mode"] = "on_close";
properties["proxyfactory.factory_class"] = "NHibernate.ByteCode.Castle.ProxyFactoryFactory, NHibernate.ByteCode.Castle";
Configuration configuration = new Configuration();
configuration.AddProperties(properties);
HbmSerializer.Default.Validate = true;
MemoryStream stream = HbmSerializer.Default.Serialize(typeof(NorthwindEmployee).Assembly);
stream.Position = 0;
configuration.AddInputStream(stream);
stream.Close();
_sessionFactory = configuration.BuildSessionFactory();
}
/// <summary>
/// updated the NHibernate confuguration
/// </summary>
private void updateConfuguration( )
{
try
{
cfg.DataBaseIntegration(x =>
{
x.ConnectionString = DatabaseConfiguration.Instance
.GetConnectionString();
x.Driver <OleDbDriver>();
x.Dialect <Oracle10gDialect>();
x.GetType()
.GetMethod("Driver")
.MakeGenericMethod(DatabaseConfiguration.Instance.Driver)
.Invoke(x, null);
x.GetType()
.GetMethod("Dialect")
.MakeGenericMethod(DatabaseConfiguration.Instance.Dialect)
.Invoke(x, null);
});
var serializer = new HbmSerializer()
{
Validate = true
};
using (var stream = serializer.Serialize(DatabaseConfiguration.
Instance.GetAssembly()))
{
cfg.AddInputStream(stream);
}
}
catch (DatabaseException)
{
throw;
}
catch (Exception ex)
{
throw (new DatabaseException(ex, "Updating the configuration failed!"));
}
}
/// <summary>
/// Instatiates or returns a static instance of the NHibernate Session Factory
/// </summary>
/// <param name="connectionString">The database connection string in case the NHibernate COnfiguration has not yet been allocated</param>
/// <returns>The static instance of the session factory</returns>
public static ISessionFactory BuildSessionFactory(NHC.Configuration nhibernateConfiguration, System.Reflection.Assembly mappingAssembly)
{
// Only try to allocate if the sessionFactory is null
if (NHibernateSessionFactory.sessionFactory == null)
{
// Lock so more than 1 thread can't do the configuration
lock (sessionFactoryLock)
{
try
{
// Since threads held up by the lock will go to this next line, make one more check to see if it isn't null
// if it is, then this is that same original thread that grabbed the lock, go ahead and allocate
// If not then another thread already allocated an instance to just bow out.
if (NHibernateSessionFactory.sessionFactory == null)
{
if (nhibernateConfiguration != null)
{
// Enable validation (optional)
// Here, we serialize all decorated classes (but you can also do it class by class)
NHM.HbmSerializer.Default.Validate = true;
nhibernateConfiguration.AddInputStream(NHM.HbmSerializer.Default.Serialize(mappingAssembly));
NHibernateSessionFactory.sessionFactory = nhibernateConfiguration.BuildSessionFactory();
}
else
{
LogManager.GetLogger().Error("Missing Nhibernate Configuration");
}
}
}
catch (Exception e)
{
LogManager.GetLogger().Error(e);
}
}
}
return(NHibernateSessionFactory.sessionFactory);
}
public static Configuration GetConfiguration(String path, SrmSettings settings)
{
Configuration configuration = new Configuration()
.SetProperty("dialect", typeof(NHibernate.Dialect.SQLiteDialect).AssemblyQualifiedName) // Not L10N
.SetProperty("connection.connection_string", new SQLiteConnectionStringBuilder // Not L10N
{
DataSource = path
}.ToString())
.SetProperty("connection.driver_class", typeof(NHibernate.Driver.SQLite20Driver).AssemblyQualifiedName); // Not L10N
Assembly assembly = typeof(SessionFactoryFactory).Assembly;
configuration.SetProperty("connection.provider", typeof(NHibernate.Connection.DriverConnectionProvider).AssemblyQualifiedName); // Not L10N
configuration.AddInputStream(assembly.GetManifestResourceStream(typeof(SessionFactoryFactory).Namespace + ".mapping.xml")); // Not L10N
if (settings != null)
AddRatioColumns(configuration, settings);
AddAnnotations(configuration, settings, AnnotationDef.AnnotationTarget.protein, typeof(DbProtein));
AddAnnotations(configuration, settings, AnnotationDef.AnnotationTarget.peptide, typeof(DbPeptide));
AddAnnotations(configuration, settings, AnnotationDef.AnnotationTarget.precursor, typeof(DbPrecursor));
AddAnnotations(configuration, settings, AnnotationDef.AnnotationTarget.transition, typeof(DbTransition));
AddAnnotations(configuration, settings, AnnotationDef.AnnotationTarget.replicate, typeof(DbProteinResult));
AddAnnotations(configuration, settings, AnnotationDef.AnnotationTarget.precursor_result, typeof(DbPrecursorResult));
AddAnnotations(configuration, settings, AnnotationDef.AnnotationTarget.transition_result, typeof(DbTransitionResult));
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;
}
static Configuration BuildConfigFromClasses()
{
NHibernate.Cfg.Environment.UseReflectionOptimizer = false;
Configuration cfg = new Configuration()
.Configure()
.AddFile("ItemQueries.hbm.xml");
// Use NHibernate.Mapping.Attributes to create mapping information about our entities
#if DEBUG
HbmSerializer.Default.Validate = true; // Enable validation (optional)
HbmSerializer.Default.Serialize(
typeof(User).Assembly, "Mapping.hbm.xml");
#endif
using (System.IO.MemoryStream stream =
HbmSerializer.Default.Serialize(
typeof(User).Assembly))
cfg.AddInputStream(stream); // Send the mapping information to NHibernate configuration
return cfg;
}
/// <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;
}
public void DoNothing()
{
ConfigurableResourceLoader loader = new ConfigurableResourceLoader();
Configuration c = new Configuration();
String resourceName =
"assembly://Spring.Data.NHibernate21.Integration.Tests/Spring.Data.NHibernate/TestObject.hbm.xml";
c.AddInputStream(loader.GetResource(resourceName).InputStream);
ISessionFactory sf = c.BuildSessionFactory();
}
public static Configuration GetConfiguration(DatabaseTypeEnum databaseTypeEnum, SessionFactoryFlags flags)
{
Assembly assembly = typeof(SessionFactoryFactory).Assembly;
var configuration = new Configuration()
.SetProperty("dialect", GetDialectClass(databaseTypeEnum).AssemblyQualifiedName)
.SetProperty("connection.driver_class", GetDriverClass(databaseTypeEnum).AssemblyQualifiedName)
.SetProperty("connection.provider",
typeof (NHibernate.Connection.DriverConnectionProvider).AssemblyQualifiedName)
.SetProperty("command_timeout", "1800");
if (databaseTypeEnum == DatabaseTypeEnum.mysql)
{
configuration.SetProperty("sessionVariables", "storage_engine=InnoDB");
}
configuration.AddInputStream(assembly.GetManifestResourceStream("pwiz.Topograph.Data.mapping.xml"));
return configuration;
}
/// <summary>
/// Serialize declared objects into the configuration of NHibernate.
/// </summary>
/// <param name="configuration">Nhibernate configuration</param>
private void SerializeDomainObjects(Configuration configuration)
{
HbmSerializer.Default.Validate = true;
configuration.AddInputStream(HbmSerializer.Default.Serialize(typeof (CampaignType)));
configuration.AddInputStream(HbmSerializer.Default.Serialize(typeof (Customer)));
configuration.AddInputStream(HbmSerializer.Default.Serialize(typeof (Company)));
configuration.AddInputStream(HbmSerializer.Default.Serialize(typeof (Campaign)));
configuration.AddInputStream(HbmSerializer.Default.Serialize(typeof (Mission)));
configuration.AddInputStream(HbmSerializer.Default.Serialize(typeof (Subscription)));
configuration.AddInputStream(HbmSerializer.Default.Serialize(typeof (Target)));
}
public static Configuration ConfigureMappings(Configuration configuration, Type typeDb, string schemaFilename = DEFAULT_SCHEMA_FILENAME)
{
Assembly assembly = typeDb.Assembly;
return configuration.AddInputStream(
assembly.GetManifestResourceStream(typeDb.Namespace + "." + schemaFilename)); // Not L10N
}
