private void EnsureTransaction() { if (transaction == null || !transaction.IsActive || transaction.WasCommitted || transaction.WasRolledBack) { transaction = session.BeginTransaction(); } }
/// <summary> /// Occurs after the action method is invoked. /// </summary> /// <param name="actionExecutedContext">The action executed context.</param> public override void OnActionExecuted(HttpActionExecutedContext actionExecutedContext) { base.OnActionExecuted(actionExecutedContext); string effectiveFactoryKey = this.GetEffectiveFactoryKey(); global::NHibernate.ITransaction currentTransaction = NHibernateSession.CurrentFor(effectiveFactoryKey).Transaction; try { if (currentTransaction.IsActive) { if (actionExecutedContext.Exception != null) { currentTransaction.Rollback(); } else { currentTransaction.Commit(); } } } finally { currentTransaction.Dispose(); } }
void global::NHibernate.IInterceptor.BeforeTransactionCompletion(global::NHibernate.ITransaction tx) { foreach (var item in _interceptors) { item.Value.BeforeTransactionCompletion(tx); } }
public NHTransaction(global::NHibernate.ITransaction nhTransaction) { Debug.Assert(nhTransaction != null); _nhTransaction = nhTransaction; _session = SessionFactory.GetCurrentSession(); }
private void BeginTransaction() { if (this.transaction == null) { this.transaction = this.session.BeginTransaction(); } }
#pragma warning disable 1591 void global::NHibernate.IInterceptor.AfterTransactionBegin(global::NHibernate.ITransaction tx) { foreach (var item in _interceptors) { item.Value.AfterTransactionBegin(tx); } }
public void Dispose() { if ( this.Transaction != null ) { (this.Transaction as IDisposable).Dispose(); this.Transaction = null; } }
public override ITransaction NewTransaction(IsolationLevel isolationLevel) { System.Data.IsolationLevel adaptedIsolationLevel = isolationLevelDictionary[isolationLevel]; global::NHibernate.ITransaction adaptedTransaction = adapted.BeginTransaction(adaptedIsolationLevel); NHibernateStatefulTransaction transaction = new NHibernateStatefulTransaction(adaptedTransaction, adapted); return(transaction); }
public NhTransaction(ITransaction transaction, TransactionCloseType closeType) : base(closeType) { if (transaction == null) throw new ArgumentNullException("transaction"); _transaction = transaction; }
public void Dispose() { if (this.Transaction != null) { (this.Transaction as IDisposable).Dispose(); this.Transaction = null; } }
public void GetTransaction_gets_existing_transaction_if_active([Frozen] IGetsNHibernateTransaction wrapped, ISession session, PreferExistingNativeTransactionDecorator sut, global::NHibernate.ITransaction expected) { Mock.Get(session).SetupGet(x => x.Transaction).Returns(expected); Mock.Get(expected).SetupGet(x => x.IsActive).Returns(true); Assert.That(() => sut.GetTransaction(session), Is.SameAs(expected)); }
private void EnsureTransaction() { // start new transaction if // 1) No transaction is initiated yet // 2) Existing transaction isn't active // 3) Existing transaction was committed // 4) Existing transaction was rolled back if (transaction == null || !transaction.IsActive || transaction.WasCommitted || transaction.WasRolledBack) { transaction = session.BeginTransaction(); } }
public void Commit() { using (global::NHibernate.ITransaction transaction = Session.BeginTransaction()) { try { transaction.Commit(); } catch (StaleObjectStateException ex) { transaction.Rollback(); throw new ConflictException("In the final, the change was detected by competition.", ex); } catch { transaction.Rollback(); throw; } } }
protected override void DisposeCore() { transientEntities.Clear(); if (transaction != null) { if (transaction.IsActive) { transaction.Rollback(); } transaction.Dispose(); transaction = null; } if (session != null) { if (session.IsOpen) { session.Close(); } session.Dispose(); } }
public NHibernateTransaction(INHibernateTransaction transaction) { this.Transaction = transaction; }
/// <summary> /// Default Constructor. /// Creates a new instance of the <see cref="NHTransaction"/> instance. /// </summary> /// <param name="transaction">The underlying NHibernate.ITransaction instance.</param> public NHTransaction(global::NHibernate.ITransaction transaction) { Guard.Against <ArgumentNullException>(transaction == null, "Expected a non null NHibernate.ITransaction instance."); _transaction = transaction; }
public void GetTransaction_creates_transaction_from_wrapped_if_transaction_not_active([Frozen] IGetsNHibernateTransaction wrapped, ISession session, PreferExistingNativeTransactionDecorator sut, global::NHibernate.ITransaction expected, global::NHibernate.ITransaction other) { Mock.Get(session).SetupGet(x => x.Transaction).Returns(other); Mock.Get(other).SetupGet(x => x.IsActive).Returns(false); Mock.Get(wrapped).Setup(x => x.GetTransaction(session)).Returns(expected); Assert.That(() => sut.GetTransaction(session), Is.SameAs(expected)); }
/// <summary> /// <para>Initialises this instance with a new <see cref="NHibernate.ITransaction"/>.</para> /// </summary> /// <param name="transaction"> /// A <see cref="NHibernate.ITransaction"/> /// </param> public NHibernateRepositoryTransaction (global::NHibernate.ITransaction transaction) { this.NHibernateTransaction = transaction; }
public NHibernateStatefulTransaction(global::NHibernate.ITransaction adapted, global::NHibernate.ISession session) : base(adapted) { this.session = session; }
public NHibernateStatelessTransaction(global::NHibernate.ITransaction adapted) : base(adapted) { }
/// <summary> /// Simple .ctor /// </summary> /// <param name="tx"></param> public HibernateTransaction(global::NHibernate.ITransaction tx) { _transaction = tx; }
/// <summary> /// Default Constructor. /// Creates a new instance of the <see cref="NHTransaction"/> instance. /// </summary> /// <param name="transaction">The underlying NHibernate.ITransaction instance.</param> public NHTransaction(global::NHibernate.ITransaction transaction) { Guard.Against<ArgumentNullException>(transaction == null, "Expected a non null NHibernate.ITransaction instance."); _transaction = transaction; }
protected AbstractTransaction(global::NHibernate.ITransaction adapted) { this.adapted = adapted; }
public void GetTransaction_creates_transaction_from_session(ISession session, NativeTransactionFactory sut, global::NHibernate.ITransaction expected) { Mock.Get(session).Setup(x => x.BeginTransaction()).Returns(expected); Assert.That(() => sut.GetTransaction(session), Is.SameAs(expected)); }
/// <summary> /// <para>Initialises this instance with a new <see cref="NHibernate.ITransaction"/>.</para> /// </summary> /// <param name="transaction"> /// A <see cref="NHibernate.ITransaction"/> /// </param> public NHibernateRepositoryTransaction(global::NHibernate.ITransaction transaction) { this.NHibernateTransaction = transaction; }
public Transaction(global::NHibernate.ITransaction transaction) { _transaction = transaction; }