public static void UsingSafeTransaction(this ISession session, Action<ISession, Action, Action> executer)
        {
            bool isSelfTransaction = false;

            ITransaction trans = null;

            if (!session.Transaction.IsActive)
            {
                isSelfTransaction = true;

                trans = session.BeginTransaction();
            }
            else
            {
                trans = session.Transaction;
            }

            executer(session, () =>
            {
                if (isSelfTransaction)
                    trans.Rollback();
            },
            () =>
            {
                if (isSelfTransaction)
                    trans.Commit();
            });
        }
Beispiel #2
0
 public static void Commit(this ISession session)
 {
     using (var tran = session.BeginTransaction())
     {
         tran.Commit();
     }
 }
        public static void DoTransactional(this ISession session, Action<ISession> action)
        {
            using (var tx = session.BeginTransaction())
            {
                action(session);

                try
                {
                    tx.Commit();
                }
                catch (GenericADOException ex)
                {
                    throw new ApplicationException(@"Code is already used ", ex);
                }
            }

            //var branchSession = NHibernateSessionManager.GetBranchSession();

            //if (branchSession == null) return;

            //using (var tx = branchSession.BeginTransaction())
            //{
            //    action(branchSession);

            //    tx.Commit();

            //    branchSession.Clear();
            //}
        }
        public static void CommitTransactionIfActive(this ISession session)
        {
            ITransaction tx = session.Transaction;

            try
            {
                if (tx != null && tx.IsActive)
                {
                    tx.Commit();
                }
            }
            catch
            {
                if (tx != null && tx.IsActive)
                {
                    tx.Rollback();
                }

                throw;
            }
            finally
            {
                if (tx != null)
                {
                    tx.Dispose();
                }
            }

            session.BeginTransaction();
        }
        /// <summary>
        /// Executes a delegate inside a DSL transaction.
        /// </summary>
        /// <param name="manager">The manager.</param>
        /// <param name="action">The action.</param>
        /// <param name="transactionName">Name of the transaction.</param>
        /// <param name="serializing">Whether the transaction is a serialization one.</param>
        public static void DoWithinTransaction(this TransactionManager manager, Action action, string transactionName, bool serializing)
        {
            Guard.NotNull(() => manager, manager);
            Guard.NotNull(() => action, action);

            var transacName = transactionName;

            if (string.IsNullOrEmpty(transacName))
            {
                transacName = string.Format(CultureInfo.CurrentCulture, Resources.TransactionManagerExtensions_DoWithinTransactionDescription,
                    action.Method.Name, DateTime.Now.ToString());
            }

            if (manager.Store.InUndoRedoOrRollback || manager.InTransaction || (manager.CurrentTransaction != null && manager.CurrentTransaction.InRollback))
            {
                // Do not create nested transaction in rollback scenarios.
                action();
            }
            else
            {
                using (var tx = manager.BeginTransaction(transacName, serializing))
                {
                    action();
                    tx.Commit();
                }
            }
        }
 public static void RunInTransaction( this IDbConnection dbConnection, Action<IDbTransaction> action )
 {
     using ( IDbTransaction dbTransaction = dbConnection.BeginTransaction() )
     {
         action( dbTransaction );
         dbTransaction.Commit();
     }
 }
Beispiel #7
0
 public static void ExecuteTransaction(this ISession session, Action work)
 {
     using (var transaction = session.BeginTransaction())
     {
         work();
         transaction.Commit();
     }
 }
 public static void WithRollback(this ISession connection, Action<ISession> action)
 {
     var transaction = connection.BeginTransaction();
     try
     {
         action(connection);
     }
     finally
     {
         transaction.Rollback();
     }
 }
 public static void EncloseInTransaction(this ISession session, Action<ISession> work)
 {
     var tx = session.BeginTransaction();
     try
     {
         work(session);
         tx.Commit();
         tx.Dispose();
     }
     catch (Exception ex)
     {
         tx.Rollback();
         throw;
     }
 }
 public static Task<string> Handle(this IStorageNode Node, string Request)
 {
     var req = JSON.Deserialize<NetworkRequest>(Request);
     switch (req.method)
     {
         case NetworkRequest.BeginTransaction:
             return Node.BeginTransaction().Then(n => n.ToString());
         case NetworkRequest.Read:
             return Node.Read(req.transactionID, req.key).Then(JSON.Serialize);
         case NetworkRequest.Commit:
             return Node.Commit(req.transactionID, req.updated, req.read).Then((n) => n.ToString());
         default:
             throw new NotImplementedException("The method " + req.method + " was not recognised.");
     }
 }
 public static void InTransaction(this ISession session, Action block)
 {
     using (var trx = session.BeginTransaction())
     {
         try
         {
             block();
             trx.Commit();
         }
         catch (Exception e)
         {
             Console.WriteLine(e);
             trx.Rollback();
             throw;
         }
     }
 }
        /// <summary>
        /// Utility extension to provide transactional capability without AOP
        /// </summary>
        /// <param name="session">The session being used</param>
        /// <param name="action">Action inside transactional scope</param>
        public static void DoTransaction(this ISession session, Action<ISession> action)
        {
            using (var transaction = session.BeginTransaction())
            {
                action(session);

                try
                {
                    transaction.Commit();
                }
                catch (Exception)
                {
                    transaction.Rollback();

                    throw;
                }
            }
        }
Beispiel #13
0
 public static void BindToCurrentContext(this ISession session)
 {
     CurrentSessionContext.Bind(session);
     session.BeginTransaction();
 }
 public static void SetupBeginTransaction(this ISession session)
 {
     session.FlushMode = FlushMode.Commit;
     session.BeginTransaction();
 }
 public static ITransaction BeginTransaction(this ISession session, TransactionIsolation level)
 {
     return session.BeginTransaction(GetIsolationLevel(level));
 }
 public static IDbTransaction EnsureTransaction(this IDbConnection conn, IsolationLevel isolationLevel)
 {
     conn.EnsureOpen();
     return conn.BeginTransaction(isolationLevel);
 }
Beispiel #17
0
        /// <summary>
        /// 指定されたデータベース接続に対して、指定の分離レベルのトランザクションを開始します。
        /// </summary>
        /// <param name="connection">トランザクションを開始するデータベース接続</param>
        /// <param name="isolationLevel">分離レベル</param>
        /// <returns>トランザクション</returns>
        private static ScopeTransaction StartTransactionCore(this IDbConnection connection, IsolationLevel? isolationLevel)
        {
            if (connection == null)
                throw new ArgumentNullException(nameof(connection));

            if (connection.State == ConnectionState.Closed)
                connection.Open();

            var transaction = isolationLevel.HasValue
                            ? connection.BeginTransaction(isolationLevel.Value)
                            : connection.BeginTransaction();
            return transaction.Wrap();
        }
        /// <summary>
        /// Runs the queries.
        /// </summary>
        /// <param name="connection">The connection.</param>
        /// <param name="queries">The queries.</param>
        /// <param name="logger">The logger.</param>
        /// <returns><c>true</c> if XXXX, <c>false</c> otherwise</returns>
        /// <exception cref="System.ArgumentNullException">queries</exception>
        public static void RunQueries(this IDbConnection connection, string[] queries, ILogger logger)
        {
            if (queries == null)
            {
                throw new ArgumentNullException("queries");
            }

            using (var tran = connection.BeginTransaction())
            {
                try
                {
                    using (var cmd = connection.CreateCommand())
                    {
                        foreach (var query in queries)
                        {
                            cmd.Transaction = tran;
                            cmd.CommandText = query;
                            cmd.ExecuteNonQuery();
                        }
                    }

                    tran.Commit();
                }
                catch (Exception e)
                {
                    logger.ErrorException("Error running queries", e);
                    tran.Rollback();
                    throw;
                }
            }
        }
 public static IDbTransaction EnsureTransaction(this IDbConnection conn)
 {
     conn.EnsureOpen();
     return conn.BeginTransaction();
 }