static void Main(string[] args)
{
Trace.Listeners.Add(new ConsoleTraceListener());
NHibernateProfiler.Initialize();
try
{
var s = new Strategies();
//s.ex01_GetVsLoad();
//s.ex02_getThenLoadSameObject();
//s.ex03_addGetVsLoad();
s.ex04_LINQ();
//s.ex05_HQL();
//s.ex06_CriteriaQuery();
}
catch (Exception ex)
{
Trace.WriteLine("Exception");
Trace.WriteLine(ex.Message);
if (ex.InnerException != null)
{
Trace.WriteLine(ex.InnerException.Message);
}
}
Console.ReadLine();
}
private static void Main()
{
NHibernateProfiler.Initialize();
var cfg = new Configuration();
cfg.Proxy(p => p.ProxyFactoryFactory <ProxyFactoryFactory>())
.DataBaseIntegration(db => {
db.ConnectionStringName = "scratch";
db.Dialect <MsSql2008Dialect>();
db.BatchSize = 500;
})
.AddAssembly(Assembly.GetExecutingAssembly())
.SessionFactory().GenerateStatistics();
new SchemaExport(cfg).Execute(script: false, export: true, justDrop: false);
var sessionFactory = cfg.BuildSessionFactory();
using (var session = sessionFactory.OpenSession())
using (var tx = session.BeginTransaction()) {
// NHibernate code goes here
tx.Commit();
}
Console.WriteLine("Press <ENTER> to exit...");
Console.ReadLine();
}
protected void Application_Start()
{
log4net.Config.XmlConfigurator.Configure();
NHibernateProfiler.Initialize();
var bootsrapper = new MefBootstrapper();
Connect(bootsrapper.Container);
ControllerBuilder.Current.SetControllerFactory(new MefControllerFactory(bootsrapper.Container));
var dependencyResolver = System.Web.Http.GlobalConfiguration.Configuration.DependencyResolver;
System.Web.Http.GlobalConfiguration.Configuration.DependencyResolver = new MefDependencyResolver(bootsrapper.Container);
// ControllerBuilder.Current.SetControllerFactory(new MefControllerFactory(bootsrapper.Container));
// DependencyResolver.SetResolver(new MefDependencyResolver(bootsrapper.Container));
AreaRegistration.RegisterAllAreas();
RegisterTooltip.Register();
WebApiConfig.Register(GlobalConfiguration.Configuration);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters,
bootsrapper.Container.GetExportedValue <IExceptionHandlerFactory>());
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
}
public void BuildSessionFactory()
{
DatabaseFilePath = Path.Combine(Path.GetTempPath(), "Lab.ExchangeNet45.Tests.sqlite");
#if DEBUG
NHibernateProfiler.Initialize();
#endif
SessionFactory = Fluently
.Configure()
.CurrentSessionContext <ThreadStaticSessionContext>()
.Mappings(m =>
{
m.FluentMappings.AddFromAssemblyOf <NHibernateSessionFactoryFactory>();
})
.Database
(
SQLiteConfiguration.Standard
.ConnectionString($"data source={DatabaseFilePath};Version=3;New=True;BinaryGuid=False;PRAGMA synchronous=off;")
.Driver <SQLite20Driver>()
.Dialect <SQLiteDialect>()
.Provider <DriverConnectionProvider>()
.QuerySubstitutions("true 1, false 0")
.ShowSql()
.FormatSql()
.AdoNetBatchSize(250)
.IsolationLevel(IsolationLevel.ReadCommitted)
)
.ExposeConfiguration(config =>
{
config.Properties.Add("hbm2ddl.keywords", "none");
var schemaExport = new SchemaExport(config);
schemaExport.Create(true, true);
})
.BuildSessionFactory();
}
/// <summary>
/// </summary>
/// <param name="initialize"></param>
public static void InitializeHibernateProfiler(bool initialize)
{
if (initialize)
{
NHibernateProfiler.Initialize();
}
}
private static ISessionFactory initializeNH()
{
FluentConfiguration config;
#if DEBUG
config = Fluently.Configure()
.Database(MsSqlConfiguration.MsSql2008
.ShowSql()
.FormatSql()
.ConnectionString(p => p.Is(CN_STR))
// .AdoNetBatchSize(20)
.DefaultSchema("dbo"))
.Mappings(m =>
{
m.FluentMappings.AddFromAssemblyOf <PlayerMap>();
});
#else
config = Fluently.Configure()
.Database(MsSqlConfiguration.MsSql2008
.ConnectionString(p => p.Is(CN_STR))
.DefaultSchema("dbo"))
.Mappings(m =>
{
m.FluentMappings.AddFromAssemblyOf <UserMap>();
});
#endif
NHibernateProfiler.Initialize();
return(config.BuildSessionFactory());
}
public ISessionFactory GetSessionFactory()
{
NHibernateProfiler.Initialize();
var config = Fluently.Configure()
.Database(_databaseConfig)
.Mappings(m => m.AutoMappings
.Add(AutoMap.AssemblyOf <NHibernateConfiguration <SqlClientDriver> >()
.Where(type => type.Namespace != null && type.Namespace.EndsWith("Entities"))
.UseOverridesFromAssemblyOf <NHibernateConfiguration <SqlClientDriver> >()
)
)
// Ensure batching is used
.ExposeConfiguration(c => c.SetProperty(Environment.BatchSize, "10"))
// Turn off cache to make sure all calls actually go to the database
.ExposeConfiguration(c => c.SetProperty(Environment.UseQueryCache, "false"))
.ExposeConfiguration(c => c.SetProperty(Environment.UseSecondLevelCache, "false"));
if (typeof(LocalTestingReliableSql2008ClientDriver).IsAssignableFrom(typeof(T)))
{
config.ExposeConfiguration(c => c.SetProperty(Environment.TransactionStrategy,
typeof(ReliableAdoNetWithDistributedTransactionFactory).AssemblyQualifiedName));
}
var nhConfig = config.BuildConfiguration();
SchemaMetadataUpdater.QuoteTableAndColumns(nhConfig);
var validator = new SchemaValidator(nhConfig);
validator.Validate();
return(config.BuildSessionFactory());
}
public HomeController(ITaxiCarRepository taxiCarRepository, IEmployeeRepository employeeRepository, IDriverRepository driverRepository)
{
NHibernateProfiler.Initialize();
_taxiCarRepository = taxiCarRepository;
_employeeRepository = employeeRepository;
_driverRepository = driverRepository;
}
public static void Main(string[] args)
{
NHibernateProfiler.Initialize();
IRootResolver rootResolver = IocBuilder.New
.UseAutofacContainerBuilder()
.UseStove <StoveDemoBootstrapper>()
.UseStoveNullLogger()
.UseStoveNHibernate(nhCfg =>
{
nhCfg.FluentConfiguration
.Database(MsSqlConfiguration.MsSql2012.ConnectionString(nhCfg.Configuration.DefaultNameOrConnectionString))
.Mappings(m => m.FluentMappings.AddFromAssembly(Assembly.GetExecutingAssembly()));
return(nhCfg);
})
.UseStoveDefaultConnectionStringResolver()
.UseStoveDapper()
.UseStoveEventBus()
.RegisterServices(r => r.RegisterAssemblyByConvention(Assembly.GetExecutingAssembly()))
.CreateResolver();
using (rootResolver)
{
rootResolver.Resolve <ProductDomainService>().DoSomeCoolStuff();
}
NHibernateProfiler.Shutdown();
Console.ReadLine();
}
public void Post(List <Person> people)
{
try
{
NHibernateProfiler.Initialize();
var mappingconfig = new Configuration();
mappingconfig.Configure();
var sefact = mappingconfig.BuildSessionFactory();
string query;
foreach (Person p in people)
{
query = string.Format("Insert INTO Person (FirstName, LastName, DateOfBirth) VALUES ( {0}, {1}, {2} )", p.FirstName, p.LastName, p.DateOfBirth);
using (var session = sefact.OpenSession())
{
using (var tx = session.BeginTransaction())
{
IQuery q = session.CreateQuery(query);
q.List();
tx.Commit();
}
}
}
}
catch (MissingFieldException e)
{
Console.WriteLine("{0}", e.Message);
}
}
static void Main(string[] args)
{
Trace.Listeners.Add(new ConsoleTraceListener());
NHibernateProfiler.Initialize();
try
{
var s = new Strategies();
//s.ex1_CreateDatabaseNonFluent();
//s.ex2_CreateDatabaseFluent();
//s.ex3_InsertMultipleCustomers();
//s.ex4_InsertMultipleCustomersAndShowSql();
//s.ex5_QueryWithCriteria();
//s.ex5_QueryWithLinq();
//s.ex6_QueryAndUpdate();
}
catch (Exception ex)
{
Trace.WriteLine("Exception");
Trace.WriteLine(ex.Message);
if (ex.InnerException != null)
{
Trace.WriteLine(ex.InnerException.Message);
}
}
Console.ReadLine();
}
static void Main()
{
Console.WriteLine("App started");
var configuration = new Configuration().Configure();
configuration.AddAssembly(typeof(Program).Assembly);
var schemaExport = new SchemaExport(configuration);
schemaExport.Create(true, true);
Console.WriteLine();
Console.WriteLine("Database created");
using (var sessionFactory = configuration.BuildSessionFactory())
{
//var postId = SavePost(sessionFactory);
//GetPost(sessionFactory, postId);
InsertData(sessionFactory);
//// Enable profiling
//XmlConfigurator.Configure();
NHibernateProfiler.Initialize();
RunQueries(sessionFactory);
}
Console.WriteLine();
Console.WriteLine("Press any key to quit the application");
Console.ReadLine();
}
static void InitializeNHibernate()
{
NHibernateProfiler.Initialize();
cfg = new Configuration();
cfg.Configure(); // OPTIONAL: Only required if you want to read in hibernate.cfg.xml
cfg.DataBaseIntegration(x =>
{
x.ConnectionStringName = "medassets";
x.Driver <SqlClientDriver>();
x.Dialect <MsSql2008Dialect>();
x.IsolationLevel = IsolationLevel.ReadCommitted;
x.Timeout = 10;
x.BatchSize = 100;
});
cfg.SessionFactoryName("MedAssets");
cfg.SessionFactory().GenerateStatistics();
// cfg.AddAssembly(typeof (Customer).Assembly);
var autoMapCfg = new CustomAutomappingConfiguration();
var persistenceModel = AutoMap.AssemblyOf <Customer>(autoMapCfg)
.Conventions.AddFromAssemblyOf <Customer>()
.Override <Customer>(x => x.HasMany(m => m.Orders)
.BatchSize(10));
// .Cascade.AllDeleteOrphan());
cfg = Fluently.Configure(cfg)
.Mappings(x => x.FluentMappings.AddFromAssemblyOf <Customer>())
// .Mappings(x => x.AutoMappings.Add(persistenceModel))
.BuildConfiguration();
}
protected void Application_Start()
{
// Autofac IoC Register
IocConfig.Register();
// log4net
LogConfig.Register();
//WebApiConfig.Register(GlobalConfiguration.Configuration);
GlobalConfiguration.Configure(WebApiConfig.Register);
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
// 去掉Header中mvc版本的描述
MvcHandler.DisableMvcResponseHeader = true;
var config = GlobalConfiguration.Configuration;
config.Formatters.Remove(config.Formatters.XmlFormatter);
var jsonFormatter = config.Formatters.OfType <JsonMediaTypeFormatter>().First();
jsonFormatter.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
jsonFormatter.SerializerSettings.ContractResolver = new NHibernateContractResolver();
jsonFormatter.SerializerSettings.Converters.Add(new StringEnumConverter());
#if DEBUG
// Start profile
NHibernateProfiler.StartProfiler();
#endif
}
protected void Application_End()
{
#if DEBUG
NHibernateProfiler.Stop();
#endif
container.Dispose();
}
public NHibernateBase()
{
if (_sessionFactory == null)
{
var autoMappingConfiguration = AutoMap.AssemblyOf <NHibernateTests>()
.Where(type => type.Namespace.Equals("NHibernatePreview.DomainModel"))
.Conventions.AddFromAssemblyOf <NHibernateTests>()
.UseOverridesFromAssemblyOf <NHibernateTests>()
.IncludeBase <CustomerBaseWithTablePerHierarchyInheritance>();
_configuration = Fluently.Configure()
.Database(MsSqlConfiguration.MsSql2008.ConnectionString(c => c.FromConnectionStringWithKey("NHibernatePreview"))
.Raw(PropertyName.ProxyFactoryFactoryClass, typeof(ProxyFactoryFactory).AssemblyQualifiedName)
.Raw(PropertyName.Isolation, "ReadUncommitted")
.Raw(PropertyName.CurrentSessionContextClass, "thread_static")
.Raw(PropertyName.GenerateStatistics, "true")
.Raw(PropertyName.BatchSize, "50"))
.Mappings(m =>
{
m.HbmMappings.AddFromAssemblyOf <NHibernateTests>();
m.FluentMappings.AddFromAssemblyOf <NHibernateTests>();
m.AutoMappings.Add(autoMappingConfiguration);
})
.BuildConfiguration();
_sessionFactory = _configuration.BuildSessionFactory();
NHibernateProfiler.Initialize();
}
}
static void Main(string[] args)
{
Trace.Listeners.Add(new ConsoleTraceListener());
NHibernateProfiler.Initialize();
try
{
var s = new Strategies();
//s.ex1_insertCustomerWithOrders();
//s.ex2_insertCustomerWithOrders();
//s.ex3_viewCustomersForOrders();
//s.ex4_insertCustomerWithOrdersCascading();
//s.ex5_deleteCustomerCascading();
//s.ex6_fetchWithJoin();
//s.ex7_fetchFirst();
//s.ex8_fetchHorrible();
//s.ex09_noInverse();
s.ex10_Inverse();
}
catch (Exception ex)
{
Trace.WriteLine("Exception");
Trace.WriteLine(ex.Message);
if (ex.InnerException != null)
{
Trace.WriteLine(ex.InnerException.Message);
}
}
Console.ReadLine();
}
protected static ISessionFactory CreateSessionFactory(string connectionStringKey, string mappingAssembly)
{
var coreAssembly = Assembly.Load(mappingAssembly);
var configuration = Fluently.Configure()
.Database(MsSqlConfiguration.MsSql2008
.ConnectionString(c => c.FromConnectionStringWithKey(connectionStringKey)))
.ExposeConfiguration(c =>
{
c.SetProperty("generate_statistics", "true");
var entityValidationInterceptor = new EntityValidationInterceptor();
c.EventListeners.PreCollectionUpdateEventListeners = new IPreCollectionUpdateEventListener[] { entityValidationInterceptor };
c.EventListeners.PreInsertEventListeners = new IPreInsertEventListener[] { entityValidationInterceptor };
c.EventListeners.PreUpdateEventListeners = new IPreUpdateEventListener[] { entityValidationInterceptor };
})
.Mappings(m => m.FluentMappings
.AddFromAssembly(coreAssembly)
.ExportTo(Environment.CurrentDirectory))
.BuildConfiguration();
var result = configuration.BuildSessionFactory();
NHibernateProfiler.Initialize();
return(result);
}
static void InitDbScheme(IUtHelper utHelper, bool recreateDb = false)
{
JsonHelper.JsonSerialize = new NhJsonSerialize();
NHibernateProfiler.Initialize();
//FluentNhibernateConvertions.Conventions.Add(new Nb_ForeignKeyConstraintNameConvention());
//DbSettingHelper.ShowSql = true;
//DbSettingHelper.ConnString = @"Data Source=.;AttachDbFilename=|DataDirectory|\App_Data\DemoDb.mdf;Integrated Security=True;Connect Timeout=30";
var dbName = "DemoDb";
var connString = string.Format(@"Data Source=.;Initial Catalog={0};Persist Security Info=True;User ID=sa;Password=zqnb_123", dbName);
DbSettingHelper.ConnString = connString;
var sqlScriptHelper = new SqlScriptHelper();
if (recreateDb)
{
sqlScriptHelper.ReCreateDbIfExist(connString, dbName);
}
else
{
sqlScriptHelper.CreateDbIfNotExist(connString, dbName);
}
utHelper.SetUpNHibernate(recreateDb, typeof(Program));
ShowSplit("Setup Done!");
Console.WriteLine();
}
public DataTest()
{
// var captureProfilerOutput = new CaptureProfilerOutput(@"");
// captureProfilerOutput.StartListening();
NHibernateProfiler.Initialize();
}
public static void Init()
{
IWindsorContainer container = new WindsorContainer();
ComponentRegistrar.AddComponentsTo(container);
NHibernateProfiler.Initialize();
ServiceLocator.SetLocatorProvider(() => new WindsorServiceLocator(container));
}
public static void Initialise()
{
if (!_isInitialised)
{
NHibernateProfiler.Initialize();
_isInitialised = true;
}
}
public NHibernateFixture()
{
_sessionFactory = NHibernateConfigurator.SessionFactory;
NHibernateProfiler.Initialize();
SetupNHibernateSession();
}
public void Start(string mode)
{
NHibernateProfiler.Initialize();
Logger.Info("Dispatcher started");
Mode = mode;
ParseCommandLine();
ThreadPool.QueueUserWorkItem(x => Run());
}
private static ISessionFactory CreateSessionFactory()
{
var cfg = new Configuration().Configure(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "nhibernate.config"));
cfg.SetProperty(NHibernate.Cfg.Environment.ConnectionStringName, "Tekpub");
NHibernateProfiler.Initialize();
return(cfg.BuildSessionFactory());
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
NHibernateProfiler.Shutdown();
}
base.Dispose(disposing);
}
protected void Application_Start()
{
ServiceLocator.RegisterAll();
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
NHibernateProfiler.Initialize();
}
public void Initialized(NHibernate.Cfg.Configuration configuration, ISessionFactory sessionFactory)
{
if (!Enabled)
{
return;
}
NHibernateProfiler.Initialize();
}
protected override void OnSetup()
{
base.OnSetup();
NHibernateProfiler.Initialize();
SetupNHibernateSession();
SetupSystemAccountProvider();
}
public void TestCache()
{
NHibernateProfiler.Initialize();
var groupNames = new[] { "a1", "b1", "c1" };
using (var session = SessionFactory.OpenSession())
using (var tx = session.BeginTransaction())
{
session.CreateSQLQuery("delete from dbo.Registrations;delete from dbo.[Group]")
.ExecuteUpdate();
session.CreateSQLQuery("delete from dbo.[User]");
groupNames.ForEach(x =>
{
var group = new Group {
Id = Guid.NewGuid(), Name = x, Date = DateTime.UtcNow
};
session.Save(group);
});
tx.Commit();
}
using (var session = SessionFactory.OpenSession())
using (var tx = session.BeginTransaction())
{
var user = new User {
Name = "User1", Id = Guid.NewGuid(), Date = DateTime.UtcNow
};
session.Save(user);
tx.Commit();
}
using (var session = SessionFactory.OpenSession())
using (var tx = session.BeginTransaction())
{
var user = session.Query <User>().First();
var groups = GetGroups(session);
var group = groups.First();
var registration = new GroupRegistration
{
Id = Guid.NewGuid(),
User = user,
Group = group,
Date = DateTime.UtcNow
};
user.Registrations.Add(registration);
group.Registrations.Add(registration);
session.Save(registration);
session.Flush();
tx.Commit();
}
using (var session = SessionFactory.OpenSession())
{
var g = GetGroups(session);
}
using (var session = SessionFactory.OpenSession())
{
var g = GetGroups(session);
}
}
/// <summary>
/// Save prepared statement
/// </summary>
/// <param name="subject">Sql string</param>
public void SavePreparedStatement(
NHibernateProfiler.Common.Entity.PreparedStatement subject)
{
using (var _session = this.c_sessionFactory.OpenSession())
{
using (var _transaction = _session.BeginTransaction())
{
_session.Save(subject);
_transaction.Commit();
}
}
}
/// <summary>
/// Save session factory statistics
/// </summary>
/// <param name="subject"></param>
public void SaveSessionFactoryStatistics(
NHibernateProfiler.Common.Entity.Statistics.SessionFactory subject)
{
using (this.c_currentSessionFactoryStatisticsSession)
{
using (var _transaction = this.c_currentSessionFactoryStatisticsSession.BeginTransaction())
{
this.c_currentSessionFactoryStatisticsSession.SaveOrUpdate(subject);
_transaction.Commit();
}
}
}
