Esempio n. 1
0
        /// <summary>
        /// Refresh entity
        /// </summary>
        public static void RefreshStateless <T>(this T entity, ISession session) where T : IDataObject
        {
            entity.ShouldNotBeNull("entity");
            session.ShouldNotBeNull("session");

            NHWith.StatelessSession(session, stateless => stateless.Refresh(entity));
        }
Esempio n. 2
0
        /// <summary>
        /// Refresh entities
        /// </summary>
        public static void RefreshStateless <T>(this IEnumerable <T> entities, LockMode lockMode, ISession session) where T : IDataObject
        {
            if (entities.ItemExists() == false)
            {
                return;
            }

            NHWith.StatelessSession(session, stateless => entities.RunEach(entity => stateless.Refresh(entity, lockMode)));
        }
Esempio n. 3
0
        /// <summary>
        /// Refresh entities
        /// </summary>
        public static void RefreshStateless <T>(this IEnumerable <T> entities, ISession session) where T : IDataObject
        {
            if (entities.ItemExists() == false)
            {
                return;
            }
            session.ShouldNotBeNull("session");

            NHWith.StatelessSession(session, stateless => entities.RunEach(entity => stateless.Refresh(entity)));
        }
Esempio n. 4
0
        /// <summary>
        /// 엔티티를 StatelessSession을 이용하여 Update 합니다.
        /// </summary>
        /// <typeparam name="T">type of entity to update</typeparam>
        /// <param name="entity">entity to update</param>
        /// <param name="session">nhibernate current session</param>
        public static void UpdateStateless <T>(this T entity, ISession session) where T : IDataObject
        {
            entity.ShouldNotBeNull("entity");
            session.ShouldNotBeNull("session");

            if (IsDebugEnabled)
            {
                log.Debug("엔티티를 Stateless Session에서 Update 합니다... entity=[{0}], session=[{1}]", entity, session);
            }

            NHWith.StatelessSession(session, stateless => stateless.Update(entity));
        }
Esempio n. 5
0
        /// <summary>
        /// 엔티티 컬렉션을 StatelessSession을 이용하여 Delete 합니다.
        /// </summary>
        /// <typeparam name="T">type of entity to delete</typeparam>
        /// <param name="entities">collection of entity to delete</param>
        /// <param name="session">nhibernate session</param>
        public static void DeleteStateless <T>(this IEnumerable <T> entities, ISession session) where T : IDataObject
        {
            if (entities.ItemExists() == false)
            {
                return;
            }
            session.ShouldNotBeNull("session");

            if (IsDebugEnabled)
            {
                log.Debug("엔티티 컬렉션을 StatelessSession에서 삭제합니다... entities=[{0}], session=[{1}]", entities, session);
            }

            NHWith.StatelessSession(session, stateless => entities.RunEach(entity => stateless.Delete(entity)));
        }
Esempio n. 6
0
        /// <summary>
        /// 지정한 queryName의 결과셋의 엔티티들을 삭제합니다
        /// </summary>
        public static void DeleteStatelessByNamedQuery(string queryName)
        {
            queryName.ShouldNotBeWhiteSpace("queryName");

            if (IsDebugEnabled)
            {
                log.Debug("StatelessSession에서 NamedQuery를 실행하여 엔티티를 삭제합니다... queryName=[{0}]", queryName);
            }

            NHWith.StatelessSession(stateless => {
                foreach (var entity in stateless.GetNamedQuery(queryName).Enumerable())
                {
                    stateless.Delete(entity);
                }
            });
        }
Esempio n. 7
0
        /// <summary>
        /// 지정한 hql의 결과셋의 엔티티들을 삭제합니다.
        /// </summary>
        public static void DeleteStatelessByHql(string hql)
        {
            hql.ShouldNotBeWhiteSpace("hql");

            if (IsDebugEnabled)
            {
                log.Debug("StatelessSession에서 HQL에 해당되는 엔티티를 삭제합니다... hql=[{0}]", hql);
            }

            NHWith.StatelessSession(stateless => {
                foreach (var entity in stateless.CreateQuery(hql).List())
                {
                    stateless.Delete(entity);
                }
            });
        }
Esempio n. 8
0
 /// <summary>
 /// Refresh entity
 /// </summary>
 public static void RefreshStateless <T>(this T entity, LockMode lockMode) where T : IDataObject
 {
     entity.ShouldNotBeNull("entity");
     NHWith.StatelessSession(stateless => stateless.Refresh(entity, lockMode));
 }