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(); }); }
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(); } }
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; } } }
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); }
/// <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(); }