C# ISession.Flush方法代码示例

		public void QueryUsingReadonlyProperty()
		{
			using (session = OpenSession())
			{
				Nums nums1 = new Nums {ID = 1, NumA = 1, NumB = 2};
				session.Save(nums1);

				Nums nums2 = new Nums {ID = 2, NumA = 2, NumB = 2 };
				session.Save(nums2);

				Nums nums3 = new Nums {ID = 3, NumA = 5, NumB = 2 };
				session.Save(nums3);

				session.Flush();
				session.Clear();

				var nums = session.CreateQuery("from Nums b where b.Sum > 4").List<Nums>();

				Assert.That(nums.Count, Is.EqualTo(1));
				Assert.That(nums[0].Sum, Is.EqualTo(7));

				session.Delete("from Nums");
				session.Flush();
				session.Close();
			}
		}

		public void SelectWithWhereClause()
		{
			using (session = OpenSession())
			{
				User user1 = new User();
				user1.UserName = "User1";
				session.Save(user1);

				User user2 = new User();
				user2.UserName = "User2";
				session.Save(user2);

				BlogPost post = new BlogPost();
				post.Title = "Post 1";
				post.Poster = user1;
				session.Save(post);

				session.Flush();
				session.Clear();

				User poster = (User) session.Get(typeof (User), user1.ID);

				string hql = "from BlogPost b where b.Poster = :poster";
				IList list = session.CreateQuery(hql).SetParameter("poster", poster).List();
				Assert.AreEqual(1, list.Count);
				BlogPost retrievedPost = (BlogPost) list[0];
				Assert.AreEqual(post.ID, retrievedPost.ID);
				Assert.AreEqual(user1.ID, retrievedPost.Poster.ID);

				session.Delete("from BlogPost");
				session.Delete("from User");
				session.Flush();
				session.Close();
			}
		}

        public void Init() {
            _session = _sessionFactory.OpenSession();
            foreach (var killType in new[] { typeof(ContentTypeDefinitionRecord), typeof(ContentPartDefinitionRecord), typeof(ContentFieldDefinitionRecord) }) {
                foreach (var killRecord in _session.CreateCriteria(killType).List()) {
                    _session.Delete(killRecord);
                }
            }
            _session.Flush();
            _session.Close();
            _session.Dispose();
            _session = _sessionFactory.OpenSession();

            var builder = new ContainerBuilder();
            builder.RegisterAutoMocking();
            builder.RegisterType<ContentDefinitionManager>().As<IContentDefinitionManager>();
            builder.RegisterGeneric(typeof(Repository<>)).As(typeof(IRepository<>));
            builder.RegisterType(typeof(SettingsFormatter)).As(typeof(ISettingsFormatter));
            builder.RegisterType<Signals>().As<ISignals>();
            builder.RegisterType<StubCacheManager>().As<ICacheManager>();
            builder.RegisterType<StubParallelCacheContext>().As<IParallelCacheContext>();

            _session = _sessionFactory.OpenSession();
            builder.RegisterInstance(_transactionManager = new TestTransactionManager(_session)).As<ITransactionManager>();

            _container = builder.Build();

        }

        public void Init() {
            var builder = new ContainerBuilder();
            builder.RegisterAutoMocking();
            builder.RegisterType<ContentDefinitionManager>().As<IContentDefinitionManager>();
            builder.RegisterGeneric(typeof(Repository<>)).As(typeof(IRepository<>));
            builder.RegisterType(typeof(SettingsFormatter))
                .As(typeof(IMapper<XElement, SettingsDictionary>))
                .As(typeof(IMapper<SettingsDictionary, XElement>));
            builder.RegisterType<Signals>().As<ISignals>();
            builder.RegisterType<StubCacheManager>().As<ICacheManager>();
            builder.RegisterType<StubParallelCacheContext>().As<IParallelCacheContext>();

            _container = builder.Build();

            _container.Mock<ISessionLocator>()
                .Setup(x => x.For(It.IsAny<Type>()))
                .Returns(() => _session);

            _session = _sessionFactory.OpenSession();
            foreach (var killType in new[] { typeof(ContentTypeDefinitionRecord), typeof(ContentPartDefinitionRecord), typeof(ContentFieldDefinitionRecord) }) {
                foreach (var killRecord in _session.CreateCriteria(killType).List()) {
                    _session.Delete(killRecord);
                }
            }
            _session.Flush();
        }

        public UserModel CreateUserModel(ISession session, string name)
        {
            session.Flush();
            var userModel = new UserModel();
            var user = (from p in session.Query<Tenant>() where p.Name == name select p).First();
            var otherUsers = (from p in session.Query<Tenant>() where p.Name != name && p.Instance == user.Instance select p);
            var allDebts = (from d in session.Query<Debt>() select d);
            userModel.DebtsOwedToMe = (from d in session.Query<Debt>() where d.Person.Id == user.Id && !d.Paid select d).ToList();
            userModel.DebtsIOweToPeople = (from d in session.Query<Debt>() where d.Debtor.Id == user.Id && !d.Paid select d).ToList();
            userModel.PaidDebts = (from d in session.Query<Debt>() where d.Person.Id == user.Id && d.Paid select d).ToList();

            foreach (var person in otherUsers)
            {
                var iNeedToPay = allDebts.ToList().Where(x => x.Debtor.Id == user.Id && x.Person.Id == person.Id && !x.Paid).Sum(y => y.Amount);
                var owedToMe = allDebts.ToList().Where(x => x.Person.Id == user.Id && x.Debtor.Id == person.Id && !x.Paid).Sum(y => y.Amount);

                if(iNeedToPay == 0 && owedToMe == 0 && person.Archived)
                    continue;

                userModel.Breakdown.Add(new BreakdownDto { Person = person, Total = owedToMe - iNeedToPay });
            }

            userModel.PersonId = user.Id;
            userModel.InstanceId = user.Instance;
            userModel.Tenants = (from p in NhSession.Query<Tenant>() where p.Instance == user.Instance && !p.Archived select p).ToList();
            var people = (from p in NhSession.Query<Tenant>() where p.Name != name && p.Instance == userModel.InstanceId && !p.Archived select p).ToList();
            userModel.People = (from person in people select new SelectListItem { Text = person.Name, Value = person.Id.ToString() }).ToList();
            return userModel;
        }

 public void AutoCriarBancoDeDados(ISession session)
 {
     InitSessionFactory();
     var sessionSource = new SessionSource(_fluentConfiguration);
     sessionSource.BuildSchema(session);
     session.Flush();
 }

        public void Can_insert_a_new_task_with_a_category()
        {
            using (session = NHibernateConfig.SessionFactory.OpenSession())
            {
                tag = ObjectMother.NewTag;
                tag.Description = "Test";
                session.Save(tag);
                session.Flush();
            }

            using (session = NHibernateConfig.SessionFactory.OpenSession())
            {
                task = ObjectMother.NewTask;
                task.Tags.Add(tag);
                session.Save(task);
                session.Flush();
                taskId = task.Id;
            }

            using (session = NHibernateConfig.SessionFactory.OpenSession())
            {
                task = session.Load<Task>(taskId);
                task.Tags.Should().NotBeNull();
                task.Tags.Count.Should().Be(1);
                task.Tags.First().Description.Should().Be("Test");
            }
        }

 public void RecreateDb(ISession session)
 {
     InitSessionFactory();
     var sessionSource = new SessionSource(_fluentConfiguration);
     sessionSource.BuildSchema(session);
     session.Flush();
 }

		private EntityA CreateEntityA(ISession session)
		{
			var a = new EntityA();
			session.Save(a);
			session.Flush();
			return a;
		}

        protected DatabaseFixtureSqlServer()
        {
            BeforeSetup();

            SillyContainer.SessionProvider = (() => session);
            var sillyContainer = new SillyContainer();
            ServiceLocator.SetLocatorProvider(() => sillyContainer);

            Assert.NotNull(typeof(System.Data.SQLite.SQLiteConnection));

            var cfg = new Configuration()
                .SetProperty(Environment.ConnectionDriver, typeof(SqlClientDriver).AssemblyQualifiedName)
                .SetProperty(Environment.Dialect, typeof(MsSql2008Dialect).AssemblyQualifiedName)
                .SetProperty(Environment.ConnectionString, ConnectionString)
                .SetProperty(Environment.ProxyFactoryFactoryClass, typeof(ProxyFactoryFactory).AssemblyQualifiedName)
                .SetProperty(Environment.ReleaseConnections, "on_close")
                .SetProperty(Environment.UseSecondLevelCache, "true")
                .SetProperty(Environment.UseQueryCache, "true")
                .SetProperty(Environment.CacheProvider, typeof(HashtableCacheProvider).AssemblyQualifiedName)
                .AddAssembly(typeof(User).Assembly);

            Security.Configure<User>(cfg, SecurityTableStructure.Prefix);

            factory = cfg.BuildSessionFactory();

            session = factory.OpenSession();

            new SchemaExport(cfg).Execute(false, true, false, session.Connection, null);

            session.BeginTransaction();

            SetupEntities();

            session.Flush();
        }

		private EntityB CreateEntityB(ISession session, EntityA a, EntityC c)
		{
			var b = new EntityB {A = a, C = c};
			session.Save(b);
			session.Flush();
			return b;
		}

        public void Init() {
            var builder = new ContainerBuilder();
            // builder.RegisterModule(new ImplicitCollectionSupportModule());
            builder.RegisterModule(new ContentModule());
            builder.RegisterType<DefaultContentManager>().As<IContentManager>().SingleInstance();
            builder.RegisterType<DefaultContentManagerSession>().As<IContentManagerSession>();

            builder.RegisterType<AlphaHandler>().As<IContentHandler>();
            builder.RegisterType<BetaHandler>().As<IContentHandler>();
            builder.RegisterType<GammaHandler>().As<IContentHandler>();
            builder.RegisterType<DeltaHandler>().As<IContentHandler>();
            builder.RegisterType<EpsilonHandler>().As<IContentHandler>();
            builder.RegisterType<FlavoredHandler>().As<IContentHandler>();
            builder.RegisterType<StyledHandler>().As<IContentHandler>();

            builder.RegisterGeneric(typeof(Repository<>)).As(typeof(IRepository<>));

            _session = _sessionFactory.OpenSession();
            builder.RegisterInstance(new DefaultContentManagerTests.TestSessionLocator(_session)).As<ISessionLocator>();

            _session.Delete(string.Format("from {0}", typeof(GammaRecord).FullName));
            _session.Delete(string.Format("from {0}", typeof(DeltaRecord).FullName));
            _session.Delete(string.Format("from {0}", typeof(EpsilonRecord).FullName));
            _session.Delete(string.Format("from {0}", typeof(ContentItemVersionRecord).FullName));
            _session.Delete(string.Format("from {0}", typeof(ContentItemRecord).FullName));
            _session.Delete(string.Format("from {0}", typeof(ContentTypeRecord).FullName));
            _session.Flush();
            _session.Clear();

            _container = builder.Build();
            _manager = _container.Resolve<IContentManager>();

        }

		protected override void OnSetUp()
		{
			session = OpenSession();
			tran = session.BeginTransaction();

			// save some data
			Document doc = new Document(1, "test doc");
			Image img = new Image(1, doc, "c:\a.jpg");
			Paragraph para = new Paragraph(2, doc, "Arial");
			Page p1 = new Page(1, doc);
			p1.IsActive = true;
			Page p2 = new Page(2, doc);
			p2.IsActive = false;
			Review r = new Review(10, doc, "this is a good document"); // this id is 10 on purpose (to be != docId)

			session.Save(doc);
			session.Save(img);
			session.Save(para);
			session.Save(p1);
			session.Save(p2);
			session.Save(r);

			session.Flush();
			session.Clear();
		}

        private static void FinalizeSession(ISession session)
        {
            if (session == null || !session.IsOpen)
                return;

            try
            {
                if (session.Transaction != null && session.Transaction.IsActive)
                {
                    session.Flush();
                    session.Transaction.Commit();
                }
            }
            catch (Exception)
            {
                if (session.Transaction != null)
                    session.Transaction.Rollback();

                // you'll want to log the error here or allow it to bubble up to the global error trap in Application_Error of Global.asax.
                throw;
            }
            finally
            {
                session.Close();
                session.Dispose();
            }
        }

        /// <summary>
        /// 添加用户
        /// </summary>
        /// <param name="name">用户名称</param>
        /// <param name="description">用户描述</param>
        /// <param name="state">状态</param>
        /// <returns>True-操作成功|False-操作失败</returns>
        public bool AddOrderMaster(OrderMaster orderMaster)
        {
            if (!ExistOrderMaster(orderMaster.OrderNo))
            {
                //Model.Message userinfo = new Model.Message
                //{   
                //    Color = (Message.ColorEnum)color,
                //    Type = (Extention.TypeEnum)type,
                //    TopicName = topicName,
                //    EventData = eventData
                //    //Name = name,
                //    //Description = description,
                //    //State = state
                //};
                using (_session = _sessionfactory.Session)
                {
                    _session.Save(orderMaster);
                    _session.Flush();
                }
                return true;
            }
            else
            {
                return false;
            }

        }