public static void Initialize()
{
NHibernateLogger.SetLoggersFactory(new NHibernateProfilerLoggerFactory());
}
static NullableType()
{
//cache this, because it was a significant performance cost
IsDebugEnabled = NHibernateLogger.For(typeof(IType).Namespace).IsDebugEnabled();
}
public Logger(System.Type type)
{
this.log = NHibernateLogger.For(type);
}
static VelocityProvider()
{
log = NHibernateLogger.For(typeof(VelocityProvider));
var configs = ConfigurationManager.GetSection("velocity") as VelocityConfig[];
}
static SharedCacheClientBase()
{
log = NHibernateLogger.For(typeof(SharedCacheClient));
}
protected override void Load(ContainerBuilder builder)
{
NHibernateLogger.SetLoggersFactory(new NLogLoggerFactory());
builder.RegisterType <AuditEventListener>().SingleInstance();
builder.RegisterAssemblyTypes(AppAssemblies.All)
.Where(x => x.Name.EndsWith("Listener") &&
x.GetInterfaces()
.Any(i => i.Namespace.Equals(typeof(IPreUpdateEventListener).Namespace)))
.AsSelf()
.SingleInstance();
builder.Register(c =>
{
var cfg = CreateConfiguration(c, _connectionString, _isTestEnvironment);
if (_recreateDatabase)
{
logger.Warn("Recreating db schema");
new SchemaExport(cfg).Execute(false, true, false);
}
return(CreateConfiguration(c, _connectionString, _isTestEnvironment));
}).SingleInstance();
builder.Register(c =>
{
var factory = Policy
.Handle <SqlException>()
.WaitAndRetry(5,
retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)),
(ex, retryIn) => logger.Warn(ex,
"Error while building session factory ... retrying in {seconds} seconds",
retryIn.TotalSeconds))
.Execute(() => c.Resolve <Configuration>()
.SetProperty("current_session_context_class", "thread_static")
.BuildSessionFactory());
return(factory);
})
.As <ISessionFactory>()
.SingleInstance();
//builder.Register(c => c.Resolve<ISessionFactory>().OpenSession()).As<ISession>().InstancePerLifetimeScope();
//builder.Register(c => c.Resolve<Lazy<ISession>>().Value).As<ISession>().InstancePerLifetimeScope();
builder.RegisterType <SessionContext>().InstancePerLifetimeScope();
builder.Register(c =>
{
var sessionFactory = c.Resolve <ISessionFactory>();
var ctx = c.Resolve <SessionContext>();
ctx.Put(c.Resolve <ILifetimeScope>());
return(new Lazy <ISession>(() =>
{
var session = sessionFactory.OpenSession();
session.BindContext(ctx);
session.BeginTransaction();
return session;
}));
}).InstancePerLifetimeScope();
builder.Register(c => c.Resolve <Lazy <ISession> >().Value).As <ISession>();
builder.RegisterType <UnitOfWork>().As <IUnitOfWork>().InstancePerLifetimeScope();
logger.Info("NHibernate components registered");
}
public void WhenNotConfiguredAndLog4NetExistsThenUseLog4NetFactory()
{
// NoLoggingNHibernateLogger is internal
Assert.That(NHibernateLogger.For("pizza").GetType().Name, Is.Not.EqualTo("NoLoggingNHibernateLogger"));
}
static void Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.ReadFrom.AppSettings()
.CreateLogger();
NHibernateLogger.SetLoggersFactory(new SerilogLoggerFactory());
NHibernateHelper nhibernateHelper = null;
try
{
var databaseType =
ConfigurationManager.AppSettings["database_type"];
if (string.IsNullOrEmpty(databaseType))
{
databaseType = "sql";
}
else
{
databaseType = databaseType.ToLowerInvariant();
}
var connectionString =
ConfigurationManager.ConnectionStrings[databaseType]
.ConnectionString;
if (string.IsNullOrWhiteSpace(connectionString))
{
throw new ConfigurationErrorsException(
"connection string can't be null");
}
if (databaseType == "sql")
{
nhibernateHelper = new NHibernateHelperSQL(connectionString);
}
else if (databaseType == "oracle")
{
nhibernateHelper = new NHibernateHelperOracle(connectionString);
}
else
{
throw new ConfigurationErrorsException(
"databaseType must be either 'sql' or 'oracle'-case insensitive");
}
nhibernateHelper.GetSessionFactory();
SeedData.Initialize(nhibernateHelper);
var nhibernateRunner = new NHibernate(nhibernateHelper);
nhibernateRunner.Run();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
finally
{
if (nhibernateHelper != null)
{
nhibernateHelper.CloseSessionFactory();
}
}
}
public ILogger CreateLogger(string categoryName)
{
return(new LoggerWrapper(NHibernateLogger.For(categoryName)));
}
public void LoggerProviderCanCreateLoggers()
{
Assert.That(NHibernateLogger.For("pizza"), Is.Not.Null);
Assert.That(NHibernateLogger.For(typeof(LoggerProviderTest)), Is.Not.Null);
}
public static ILoggerFactory UseAsNHibernateLoggerProvider(this ILoggerFactory factory)
{
NHibernateLogger.SetLoggersFactory(new MicrosoftLoggerFactory(factory));
return(factory);
}
static VelocityClient()
{
log = NHibernateLogger.For(typeof(VelocityClient));
}
/// <summary></summary>
static SessionFactoryObjectFactory()
{
log = NHibernateLogger.For(typeof(SessionFactoryObjectFactory));
log.Debug("initializing class SessionFactoryObjectFactory");
}
static SharedCacheProvider()
{
log = NHibernateLogger.For(typeof(SharedCacheProvider));
var configs = ConfigurationManager.GetSection("sharedcache") as SharedCacheConfig[];
}
public void WhenConfiguredAsNullThenNoLoggingFactoryIsUsed_Obsolete()
{
NHibernateLogger.SetLoggersFactory(default(INHibernateLoggerFactory));
Assert.That(LoggerProvider.LoggerFor("pizza"), Is.InstanceOf <NoLoggingInternalLogger>());
}
static MemCacheClient()
{
log = NHibernateLogger.For(typeof(MemCacheClient));
}
public RCommonSessionFactory(ISessionFactory sessionFactory, INHibernateLoggerFactory loggerFactory)
{
NHibernateLogger.SetLoggersFactory(loggerFactory);
this._sessionFactory = sessionFactory;
}
