private bool EnlistSessionIfHasTransactionActive(String key, SqlMapper sqlMap)
{
if (!_kernel.HasComponent(typeof(ITransactionManager)))
{
return(false);
}
bool enlisted = false;
if (key == null)
{
key = "iBATIS.DataMapper";
}
ITransactionManager manager = (ITransactionManager)_kernel[typeof(ITransactionManager)];
Transaction transaction = manager.CurrentTransaction;
if (transaction != null)
{
if (!transaction.Context.Contains(key))
{
transaction.Context[key] = true;
transaction.Enlist(new ResourceSqlMapAdapter(sqlMap.BeginTransaction(false)));
transaction.RegisterSynchronization(new SqlMapKeeper(sqlMap));
enlisted = true;
}
}
_kernel.ReleaseComponent(manager);
return(enlisted);
}
private bool EnlistSessionIfHasTransactionActive(String key, ISession session)
{
if (!_kernel.HasComponent(typeof(ITransactionManager)))
{
return(false);
}
bool enlisted = false;
ITransactionManager manager = (ITransactionManager)_kernel[typeof(ITransactionManager)];
Transaction transaction = manager.CurrentTransaction;
if (transaction != null)
{
if (!transaction.Context.Contains(key))
{
transaction.Context[key] = true;
transaction.Enlist(new ResourceSessionAdapter(session.BeginTransaction()));
transaction.RegisterSynchronization(new SessionKeeper(session, key));
enlisted = true;
}
}
_kernel.ReleaseComponent(manager);
return(enlisted);
}
public void NewTransactionBeforeUsingSession()
{
ISessionManager manager = (ISessionManager)
container[typeof(ISessionManager)];
ITransactionManager tmanager = (ITransactionManager)
container[typeof(ITransactionManager)];
ITransaction transaction = tmanager.CreateTransaction(
TransactionMode.Requires, IsolationMode.Serializable);
transaction.Begin();
ISession session = manager.OpenSession();
Assert.IsNotNull(session);
Assert.IsNotNull(session.Transaction);
transaction.Commit();
Assert.IsTrue(session.Transaction.WasCommitted);
Assert.IsTrue(session.IsConnected);
session.Dispose();
Assert.IsTrue((container[typeof(ISessionStore)]
as ISessionStore).IsCurrentActivityEmptyFor(Constants.DefaultAlias));
}
public ISession OpenSession(String alias)
{
if (alias == null)
{
throw new ArgumentNullException("alias");
}
ITransaction transaction = ObtainCurrentTransaction();
bool weAreSessionOwner = false;
SessionDelegate wrapped = sessionStore.FindCompatibleSession(alias);
ISession session;
if (wrapped == null)
{
session = CreateSession(alias); weAreSessionOwner = true;
wrapped = WrapSession(transaction != null, session);
sessionStore.Store(alias, wrapped);
EnlistIfNecessary(weAreSessionOwner, transaction, wrapped);
}
else
{
EnlistIfNecessary(weAreSessionOwner, transaction, wrapped);
wrapped = WrapSession(true, wrapped.InnerSession);
}
return(wrapped);
}
/// <summary>
/// Enlists if necessary.
/// </summary>
/// <param name="weAreSessionOwner">if set to <c>true</c> [we are session owner].</param>
/// <param name="transaction">The transaction.</param>
/// <param name="session">The session.</param>
/// <returns></returns>
protected bool EnlistIfNecessary(bool weAreSessionOwner,
ITransaction transaction,
StatelessSessionDelegate session)
{
if (transaction == null)
{
return(false);
}
var list = (IList <IStatelessSession>)transaction.Context["nh.statelessSession.enlisted"];
bool shouldEnlist;
if (list == null)
{
list = new List <IStatelessSession>();
shouldEnlist = true;
}
else
{
shouldEnlist = true;
foreach (var s in list)
{
if (StatelessSessionDelegate.AreEqual(session, s))
{
shouldEnlist = false;
break;
}
}
}
if (shouldEnlist)
{
if (session.Transaction == null || !session.Transaction.IsActive)
{
transaction.Context["nh.statelessSession.enlisted"] = list;
var level = TranslateIsolationLevel(transaction.IsolationMode);
transaction.Enlist(new ResourceAdapter(session.BeginTransaction(level), transaction.IsAmbient));
list.Add(session);
}
if (weAreSessionOwner)
{
transaction.RegisterSynchronization(new StatelessSessionDisposeSynchronization(session));
}
}
return(true);
}
protected bool EnlistIfNecessary(bool weAreSessionOwner,
ITransaction transaction,
SessionDelegate session)
{
if (transaction == null)
{
return(false);
}
IList list = (IList)transaction.Context["nh.session.enlisted"];
bool shouldEnlist;
if (list == null)
{
list = new ArrayList();
transaction.Context["nh.session.enlisted"] = list;
shouldEnlist = true;
}
else
{
shouldEnlist = true;
foreach (ISession sess in list)
{
if (SessionDelegate.AreEqual(session, sess))
{
shouldEnlist = false;
break;
}
}
}
if (shouldEnlist)
{
// TODO: propagate IsolationLevel, expose as transaction property
transaction.Enlist(new ResourceAdapter(session.BeginTransaction()));
list.Add(session);
if (weAreSessionOwner)
{
transaction.RegisterSynchronization(
new SessionDisposeSynchronization(session));
}
}
return(true);
}
/// <summary>
/// Enlists if necessary.
/// </summary>
/// <param name="weAreSessionOwner">if set to <c>true</c> [we are session owner].</param>
/// <param name="transaction">The transaction.</param>
/// <param name="session">The session.</param>
/// <returns></returns>
protected bool EnlistIfNecessary(bool weAreSessionOwner,
ITransaction transaction,
SessionDelegate session)
{
if (transaction == null) return false;
IList list = (IList) transaction.Context["nh.session.enlisted"];
bool shouldEnlist;
if (list == null)
{
list = new ArrayList();
shouldEnlist = true;
}
else
{
shouldEnlist = true;
foreach(ISession sess in list)
{
if (SessionDelegate.AreEqual(session, sess))
{
shouldEnlist = false;
break;
}
}
}
if (shouldEnlist)
{
if (!transaction.DistributedTransaction)
{
transaction.Context["nh.session.enlisted"] = list;
IsolationLevel level = TranslateIsolationLevel(transaction.IsolationMode);
transaction.Enlist(new ResourceAdapter(session.BeginTransaction(level)));
list.Add(session);
}
if (weAreSessionOwner)
{
transaction.RegisterSynchronization(new SessionDisposeSynchronization(session));
}
}
return true;
}