public static IUnitOfWorkFactory CreateUnitOfWorkFactory(
IInterceptUnitOfWork interceptor = null,
IAuditConfiguration auditConfiguration = null,
IDateTime dateTime = null,
IUserContext userContext = null)
{
var logger = new ConsoleLogger {
DebugLoggingIsEnabled = false
};
var databaseConfigurer = new SqlServerDatabaseConfigurer()
.ConnectionStringName("Persistence");
var mapperConfigurer = new ByCodeMapperConfigurer()
.RegisterEntitiesFromAssembly(Assembly.GetExecutingAssembly());
var configuration = new NHibernateConfiguration(logger);
configuration.RegisterConfigurer(databaseConfigurer);
configuration.RegisterConfigurer(mapperConfigurer);
configuration.RegisterConfigurer(new ProxyConfigurer <CastleProxyFactoryFactory>());
IInterceptUnitOfWork[] interceptors = null;
if (interceptor != null)
{
interceptors = new[] { interceptor };
}
return(new NHibernateUnitOfWork.Factory(configuration, interceptors, auditConfiguration, dateTime, userContext, logger));
}
public void ShouldMap()
{
var sessionFactory = new NHibernateConfiguration().Configure().BuildSessionFactory();
using (var session = sessionFactory.OpenSession())
{
using (var transaction = session.BeginTransaction())
{
var createdUser = new User {
GooglePlusId = "some id?", Name = "user name"
};
var playlist = new Playlist("boss songs")
{
User = createdUser
};
createdUser.AddPlaylist(playlist);
session.Save(createdUser);
session.Flush();
session.Clear();
var savedUser = session.Get <User>(createdUser.Id);
Assert.That(savedUser.Id, Is.Not.EqualTo(Guid.Empty));
Assert.That(savedUser.GooglePlusId, Is.EqualTo(createdUser.GooglePlusId));
Assert.That(savedUser.Name, Is.EqualTo(createdUser.Name));
Assert.That(savedUser.Playlists, Has.Count.EqualTo(2));
Assert.That(session.Query <Playlist>().Where(p => p.User == savedUser).ToList(), Has.Count.EqualTo(2));
transaction.Rollback();
}
}
}
public void InitNHib()
{
//configure logging
//if (!log.Logger.Repository.Configured)
//{
// XmlConfigurator.Configure();
//}
string configFile = "hibernate.cfg.xml";
var connString = Configuration.GetConnectionString("SampleAppDB");
var conn1 = new NHibConfigOptions()
{
ConnectionName = "DEV3",
ConnectionString = connString,
FluentAssemblies = new List <Assembly> {
Assembly.GetAssembly(typeof(Department))
}
};
NHibernateConfiguration.Initialize(new List <NHibConfigOptions>()
{
conn1
});
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddDbContext <ApplicationDbContext>(options =>
options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));
services.AddIdentity <ApplicationUser, IdentityRole>()
.AddEntityFrameworkStores <ApplicationDbContext>()
.AddDefaultTokenProviders();
// Add application services.
services.AddTransient <IEmailSender, EmailSender>();
services.AddSingleton <IHttpContextAccessor, HttpContextAccessor>();
services.AddSingleton <NHibernateSessionStorage, NHibernateSessionStorage>();
//services.AddTransient(x => (NHibernate.ISession)x.GetRequiredService<NHibernateSessionStorage>().RetrieveSession());
services.AddScoped(x => NHibernateConfiguration.CreateAndOpenSession());
//services.AddTransient<TodoRepository, TodoRepository>();
services.AddScoped <TransactionAttribute>();
IEnumerable <Type> repositories = Assembly.GetExecutingAssembly().GetTypes().Where(IsRepository);
foreach (Type type in repositories)
{
services.AddTransient(type, type);
}
services.AddMvc(options => { options.UseHtmlEncodeModelBinding(); });
services.AddSingleton <ITempDataProvider, CookieTempDataProvider>();
services.AddSession();
services.AddMemoryCache();
services.AddDistributedMemoryCache();
InitializeNHibernate();
}
public NHibernateConfiguration CreateShard(string alias)
{
var configuration = new NHibernateConfiguration();
_configurations[alias] = configuration;
return(configuration);
}
protected override void Load(ContainerBuilder builder)
{
base.Load(builder);
var nhConfiguration = new NHibernateConfiguration(ConnectionString);
builder.Register(c => nhConfiguration.GetSessionFactory()).As<ISessionFactory>().SingleInstance();
builder.Register(c => c.Resolve<ISessionFactory>().OpenSession()).As<ISession>().InstancePerHttpRequest();
}
public static ContainerBootstrapper Bootstrap()
{
var container = new WindsorContainer().
Install(FromAssembly.This());
container.Register(Component.For <IDocumentMapper>().ImplementedBy <DocumentMapper>());
//container.AddFacility<FactorySupportFacility>();
container.Register(Component.For <ISessionFactory>()
.UsingFactoryMethod(() => NHibernateConfiguration.CreateSessionFactory()));
container.Register(Component.For <ISession>()
.UsingFactoryMethod(kernel => kernel.Resolve <ISessionFactory>().OpenSession())
.LifestylePerWebRequest());
container.Register(Component.For <ITransaction>()
.UsingFactoryMethod(kernel => kernel.Resolve <ISession>().BeginTransaction())
.LifestylePerWebRequest());
container.Register(Component.For <IUserRepository>()
.ImplementedBy <UserRepository>()
.LifeStyle.Transient);
container.Register(Component.For <IDocumentRepository>()
.ImplementedBy <DocumentRepository>()
.LifeStyle.Transient);
container.Register(Component.For <IUnitOfWork>()
.ImplementedBy <UnitOfWork>()
.LifeStyle.Transient);
return(new ContainerBootstrapper(container));
}
/// <summary>
/// Initializes NHibernate. Adds the mappings based on the assembly, initializes the session factory and opens
/// a long-running global session
/// </summary>
private void InitializeNHibernate()
{
NHibernateConfiguration.Configure();
NHibernateConfiguration.AddAssembly(typeof(Entity).Assembly);
new SchemaUpdate(NHibernateConfiguration).Execute(false, true);
SessionFactory = NHibernateConfiguration.BuildSessionFactory();
GlobalSession = SessionFactory.OpenSession();
}
private SessionFactory()
{
var connectionStringName = ConfigurationManager.AppSettings["Database"];
var connectionString = ConfigurationManager.ConnectionStrings[connectionStringName].ConnectionString;
factory = NHibernateConfiguration.CreateSessionFactory(
MySQLConfiguration.Standard.ConnectionString(connectionString));
}
protected override void Load(ContainerBuilder builder)
{
base.Load(builder);
var nhConfiguration = new NHibernateConfiguration(ConnectionString);
builder.Register(c => nhConfiguration.GetSessionFactory()).As <ISessionFactory>().SingleInstance();
builder.Register(c => c.Resolve <ISessionFactory>().OpenSession()).As <ISession>().InstancePerHttpRequest();
}
public void SetUp()
{
_configurationService = new FakeConfigurationService();
_configurationService.ConnectionString = @"Data Source=tcp:[database-server];Initial Catalog=[database];User ID=[database user];Password=[database password];";
_dbConfiguration = new NHibernateConfiguration(_configurationService);
_sessionFactory = _dbConfiguration.CreateSessionFactory();
_repository = new NHibernateRepository(_sessionFactory.OpenSession());
}
public void ShouldMap()
{
var sessionFactory = new NHibernateConfiguration().Configure().BuildSessionFactory();
using (var session = sessionFactory.OpenSession())
{
using (var transaction = session.BeginTransaction())
{
var createdUser = new User {
GooglePlusId = "some id?", Name = "user name"
};
session.Save(createdUser);
var playlist2 = new Playlist("users second playlist")
{
User = createdUser,
Sequence = 200,
};
var video = new Video
{
Id = "some id",
Author = "video author",
Duration = 90,
HighDefinition = true,
Title = "my video",
};
session.Save(video);
var playlistItem = new PlaylistItem
{
Cid = "cid",
Playlist = playlist2,
Video = video,
Sequence = 300,
Title = "My playlist item",
};
playlist2.AddItem(playlistItem);
session.Save(playlist2);
session.Flush();
session.Clear();
var savedPlaylistItem = session.Get <PlaylistItem>(playlistItem.Id);
Assert.That(savedPlaylistItem.Title, Is.EqualTo("My playlist item"));
Assert.That(savedPlaylistItem.Id, Is.Not.EqualTo(Guid.Empty));
Assert.That(savedPlaylistItem.Sequence, Is.EqualTo(300));
Assert.That(savedPlaylistItem.Video, Is.EqualTo(playlistItem.Video));
transaction.Rollback();
}
}
}
public static void Configure(ContainerBuilder builder)
{
//var session = NHibernateConfiguration.OpenSession ();
//builder.Register (c => {
// return NHibernateConfiguration.OpenSession ();
//}).As <ISession>().InstancePerLifetimeScope ();
builder.Register(c => NHibernateConfiguration.OpenSession()).As <ISession>();
builder.RegisterType <MyInfrastructureService> ().AsImplementedInterfaces();
}
public RespositoryTestBase()
{
NHibernateConfiguration.Init(
SQLiteConfiguration.Standard.UsingFile("test_GetOrganized"),
//MsSqlConfiguration.MsSql2008.ConnectionString(
//builder => builder.Server("localhost").Database("test_GetOrganized").TrustedConnection()),
RebuildDatabase
);
session = NHibernateConfiguration.CreateAndOpenSession();
}
public void FixtureSetUp()
{
//ConfigurationManager.ConnectionStrings.Add ();
foreach (ConnectionStringSettings str in ConfigurationManager.ConnectionStrings)
{
Console.WriteLine("{0}: {1}", str.Name, str.ConnectionString);
}
ConfigurationManager.ConnectionStrings.Add(new ConnectionStringSettings("DefaultConnection", "Server=localhost;Database=koshiyam;Uid=uniuser;Pwd=unipass;"));
_session = NHibernateConfiguration.OpenSession();
_schema = new SchemaExport(NHibernateConfiguration.NHConfiguration);
}
public UnitOfWork(ISession session)
{
if (session != null)
{
_session = session.IsOpen ? session : throw new ObjectDisposedException(nameof(session));
_isPassedSession = true;
}
else
{
_session = NHibernateConfiguration.OpenSession();
}
}
public void BeforeEach()
{
Scope = Container.BeginLifetimeScope();
try {
Controller = Scope.Resolve <TController> ();
} catch (Exception ex) {
Console.WriteLine(ex);
}
Session = NHibernateConfiguration.OpenSession();
Controller.Request = new System.Net.Http.HttpRequestMessage();
Controller.Request.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, new HttpConfiguration());
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
var sessionFactory = NHibernateConfiguration.CreateFactory();
ControllerBuilder.Current.SetControllerFactory(new WindsorControllerFactory(sessionFactory));
ModelBinders.Binders.Add(typeof(Cart), new CartModelBinder());
}
protected void Application_Start()
{
log4net.Config.XmlConfigurator.Configure();
AreaRegistration.RegisterAllAreas();
WebApiConfig.Register(GlobalConfiguration.Configuration);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
DependencyResolverConfig.SetDependencyResolver();
NHibernateConfiguration.BuildSessionFactory();
}
protected override void ConfigureContainer()
{
base.ConfigureContainer();
Container.Configure(cfg => {
cfg.For <IEmailService>().Use <SmtpEmailService>();
cfg.For <ISessionFactory>().Singleton().Use(() => NHibernateConfiguration.Factory());
cfg.For <IMessageModule>().Singleton().Use <NHibernateMessageModule>();
cfg.For <INHibernateSessionProvider>().Use <NHibernateMessageModule>();
cfg.For <ISession>().Use(ctx => ctx.GetInstance <INHibernateSessionProvider>().CurrentSession);
//cfg.For(typeof(ISagaPersister<>)).Singleton().Use(typeof(InMemorySagaPersister<>));
cfg.For(typeof(ISagaPersister <>)).Use(typeof(NHibernateSagaPersister <>));
});
}
public void Init()
{
ConfigurationManager.ConnectionStrings.Add(
new ConnectionStringSettings("DefaultConnection", "Server=localhost;Database=koshiyam;Uid=uniuser;Pwd=unipass;")
);
Session = NHibernateConfiguration.OpenSession();
var builder = new ContainerBuilder();
builder.RegisterApiControllers(Assembly.GetAssembly(typeof(Startup)));
AutofacInfrastructureConfiguration.Configure(builder);
AutofacDomainConfiguration.Configure(builder);
Container = builder.Build();
}
/// <summary>
/// Load your modules or register your services here!
/// </summary>
/// <param name="kernel">The kernel.</param>
private static void RegisterServices(IKernel kernel)
{
ISessionFactory factory = NHibernateConfiguration.BuildSessionFactory();
kernel.Bind <ISessionFactory>()
.ToConstant(factory)
.InSingletonScope();
kernel.Bind <ISession>()
.ToMethod(x => x.Kernel.Get <ISessionFactory>().OpenSession())
.InRequestScope();
//The first and last filter to run for each NHibernateController action
kernel.BindFilter <NHibernateTransactionFilter>(FilterScope.Action, 0)
.When((ctx, a) => ctx.Controller is NHibernateController);
}
public ISessionFactory BuildSessionFactory()
{
if (IsConnectedToDatabase && _dataProviderInfo != null)
{
_configuration = new Configuration()
.SetProperty(Environment.Dialect, _dataProviderInfo.NHibernateDialect)
.SetProperty(Environment.ConnectionDriver, _dataProviderInfo.NHibernateConnectionDriver)
.SetProperty(Environment.ConnectionString, Connection.ConnectionString)
.AddAssembly(ApplicationProperties.PokerHandMappingAssemblyName)
.AddAssembly(ApplicationProperties.DatabaseSetupMappingAssemblyName);
return(NHibernateConfiguration.BuildSessionFactory());
}
return(null);
}
public void ShouldMap()
{
var sessionFactory = new NHibernateConfiguration().Configure().BuildSessionFactory();
using (var session = sessionFactory.OpenSession())
{
using (var transaction = session.BeginTransaction())
{
var createdUser = new User {
GooglePlusId = "some id?", Name = "user name"
};
session.Save(createdUser);
var playlist2 = new Playlist("users second playlist")
{
User = createdUser,
Sequence = 200,
};
var playlistItem = new PlaylistItem
{
Cid = "cid",
Playlist = playlist2,
Video = new Video(),
Sequence = 200,
};
playlist2.AddItem(playlistItem);
var playlistId = session.Save(playlist2);
session.Flush();
session.Clear();
var savedPlaylist = session.Get <Playlist>(playlistId);
Assert.That(savedPlaylist.Title, Is.EqualTo("users second playlist"));
Assert.That(savedPlaylist.Id, Is.Not.EqualTo(Guid.Empty));
Assert.That(savedPlaylist.Sequence, Is.EqualTo(200));
Assert.That(savedPlaylist.Items, Has.Exactly(1).EqualTo(playlistItem));
transaction.Rollback();
}
}
}
private void CompareSchema(string subSetConnectionString, params INHibernateConfigurer[] configurers)
{
var superSetConnectionString = ConfigurationManager.ConnectionStrings["Persistence"].ConnectionString;
SqlServerSchema.Prepare(subSetConnectionString);
var configuration = new NHibernateConfiguration(new ConsoleLogger {
DebugLoggingIsEnabled = false
});
foreach (var configurer in configurers)
{
configuration.RegisterConfigurer(configurer);
}
configuration.CreateSchema();
SqlServerSchema.AssertContained(new ConsoleLogger(), superSetConnectionString, subSetConnectionString, false);
}
protected void Application_Start()
{
#region MVC
GlobalConfiguration.Configure(WebApiConfig.Register);
WebApiFilterConfig.RegisterGlobalFilters(GlobalConfiguration.Configuration.Filters);
#endregion
#region Logging
Environment.SetEnvironmentVariable("APPLICATION_PHYSICAL_PATH", HostingEnvironment.ApplicationPhysicalPath);
Log.Logger = new LoggerConfiguration().ReadFrom.AppSettings().CreateLogger();
#endregion
#region NHibernate
NHibernateConfiguration.Initialize(typeof(UserMap).Assembly, "Refugee", "web");
#endregion
#region Unity
UnityConfig.Initialize();
#endregion
#region Object-Object Mapping
Mapper.Initialize();
#endregion
#region Validators
ValidatorOptions.CascadeMode = CascadeMode.StopOnFirstFailure;
#endregion
}
private void InitializeNHibernate()
{
if (!wasNHibernateInitialized)
{
lock (lockObject)
{
if (!wasNHibernateInitialized)
{
NHibernateConfiguration.Init(
SQLiteConfiguration.Standard.UsingFile("test_GetOrganized"),
//MsSqlConfiguration.MsSql2008.ConnectionString(
//builder => builder.Server("localhost").Database("test_GetOrganized").TrustedConnection()),
RebuildDatabase
);
wasNHibernateInitialized = true;
}
}
}
}
public void ShouldMap()
{
var sessionFactory = new NHibernateConfiguration().Configure().BuildSessionFactory();
using (var session = sessionFactory.OpenSession())
{
using (var transaction = session.BeginTransaction())
{
new PersistenceSpecification <Video>(session)
.CheckProperty(v => v.Author, "author")
.CheckProperty(v => v.Duration, 90)
.CheckProperty(v => v.HighDefinition, true)
.CheckProperty(v => v.Id, "some id")
.CheckProperty(v => v.Title, "title")
.VerifyTheMappings();
transaction.Rollback();
}
}
}
public void Setup()
{
try
{
var sessionFactory =
NHibernateConfiguration.CreateSessionFactory(SQLiteConfiguration.Standard.InMemory().ShowSql(),
NHibernateConfigurationConfigurationOptions.None);
Assert.IsNotNull(sessionFactory);
session = sessionFactory.OpenSession();
var config = NHibernateConfiguration.Config;
new SchemaExport(config).Execute(false, true, false, session.Connection, null);
}
catch (FluentConfigurationException e)
{
Assert.Fail(e.Message + Environment.NewLine +
"inner: " + e.InnerException?.Message + e.InnerException?.ToString() + Environment.NewLine +
"potential reasons: " + string.Join(";", e.PotentialReasons) + Environment.NewLine +
"e stacktrace: " + e.StackTrace);
}
}
public void ShouldMap()
{
var sessionFactory = new NHibernateConfiguration().Configure().BuildSessionFactory();
using (var session = sessionFactory.OpenSession())
{
using (session.BeginTransaction())
{
var sampleOccurenceTime = DateTime.Today;
new PersistenceSpecification <Error>(session)
.CheckProperty(e => e.LineNumber, 1)
.CheckProperty(e => e.Message, "testmessage")
.CheckProperty(e => e.OperatingSystem, "operating system")
.CheckProperty(e => e.TimeOccurred, sampleOccurenceTime)
.CheckProperty(e => e.Url, "url")
.CheckProperty(e => e.Architecture, "astrological")
.VerifyTheMappings();
}
}
}
static void Main(string[] args)
{
log4net.Config.XmlConfigurator.Configure(new System.IO.FileInfo("log4net.config"));
Configuration nhCfg = null;
using (var sf = NHibernateConfiguration.BuildSessionFactory(cfg =>
{
cfg.DataBaseIntegration(x =>
{
x.ConnectionProvider <NHibernate.Connection.DriverConnectionProvider>();
x.Dialect <NHibernate.Dialect.MsSql2012Dialect>();
x.Driver <NHibernate.Driver.SqlClientDriver>();
x.ConnectionString = connectionString;
//x.LogSqlInConsole = true;
x.LogFormattedSql = true;
x.KeywordsAutoImport = NHibernate.Cfg.Hbm2DDLKeyWords.AutoQuote;
});
cfg.SetProperty(NHibernate.Cfg.Environment.DefaultSchema, "dbo");
}, "../../Schemas", cfg => nhCfg = cfg))
{
Console.WriteLine("Connection: " + connectionString);
if (Confirm("Connection looks good?"))
{
if (Confirm("Drop and Create New Tables?"))
{
new SchemaExport(nhCfg).Create(true, true);
}
if (Confirm("Generate Test Data?"))
{
CreateTestData(sf);
}
}
}
Console.WriteLine("Press Any Key to Exit");
Console.ReadKey();
}
public void FixtureSetup()
{
var connectionString = ConfigurationManager.ConnectionStrings["GlossaryDataSource"].ConnectionString;
using (IAnnouncer announcer = new TextWriterAnnouncer(Console.Out))
{
IRunnerContext migrationContext = new RunnerContext(announcer)
{
Connection = connectionString,
Database = "SqlServer2008",
Target = Assembly.GetAssembly(typeof(NHibernateConfiguration)).FullName
};
new TaskExecutor(migrationContext).Execute();
}
var nhConfiguration = new NHibernateConfiguration(connectionString);
_sessionFactory = nhConfiguration.GetSessionFactory();
_session = _sessionFactory.OpenSession();
_repository = new GlossaryRepository(_sessionFactory.OpenSession());
}
public static void Main(string[] args)
{
var nhc = new NHibernateConfiguration();
nhc.CreateSessionFactory();
}
