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;
}
protected AbstractTransaction(global::NHibernate.ITransaction adapted)
{
this.adapted = adapted;
}
public Transaction(global::NHibernate.ITransaction transaction)
{
_transaction = transaction;
}
public NHibernateTransaction(INHibernateTransaction transaction)
{
this.Transaction = transaction;
}
