/// <summary>
/// Gets an enlistment into the ambient transaction, if one exists.
/// </summary>
/// <returns>An enlistment into the ambient transaction, or <c>null</c> if there is no ambient
/// transaction.</returns>
private TransactionEnlistment GetEnlistment()
{
Transaction txTransaction = Transaction.Current;
TransactionEnlistment enlEnlistment = null;;
if (txTransaction != null)
{
lock (m_objEnlistmentLock)
{
if (m_dicEnlistments == null)
{
m_dicEnlistments = new Dictionary <string, TransactionEnlistment>();
}
if (m_dicEnlistments.ContainsKey(txTransaction.TransactionInformation.LocalIdentifier))
{
enlEnlistment = m_dicEnlistments[txTransaction.TransactionInformation.LocalIdentifier];
}
else
{
enlEnlistment = new TransactionEnlistment(txTransaction, this);
m_dicEnlistments.Add(txTransaction.TransactionInformation.LocalIdentifier, enlEnlistment);
}
}
}
else
{
enlEnlistment = new TransactionEnlistment(null, this);
}
return(enlEnlistment);
}
/// <summary>
/// Gets an enlistment into the ambient transaction, if one exists.
/// </summary>
/// <returns>An enlistment into the ambient transaction, or <c>null</c> if there is no ambient
/// transaction.</returns>
private TransactionEnlistment GetEnlistment()
{
var transaction = Transaction.Current;
TransactionEnlistment enlistment;
if (transaction != null)
{
lock (EnlistmentLock)
{
if (_enlistments == null)
{
_enlistments = new Dictionary <string, TransactionEnlistment>();
}
if (_enlistments.ContainsKey(transaction.TransactionInformation.LocalIdentifier))
{
enlistment = _enlistments[transaction.TransactionInformation.LocalIdentifier];
}
else
{
enlistment = new TransactionEnlistment(transaction, this);
_enlistments.Add(transaction.TransactionInformation.LocalIdentifier, enlistment);
}
}
}
else
{
enlistment = new TransactionEnlistment(null, this);
}
return(enlistment);
}
private void EnsureEnslistment()
{
AssertNotDisposedOrDisposing();
if (Transaction.Current == null)
{
throw new InvalidOperationException("You must use TransactionScope when using Rhino.Queues");
}
if (CurrentlyEnslistedTransaction == Transaction.Current)
{
return;
}
// need to change the enslitment
#pragma warning disable 420
Interlocked.Increment(ref currentlyInsideTransaction);
#pragma warning restore 420
Enlistment = new TransactionEnlistment(queueStorage, () =>
{
lock (newMessageArrivedLock)
{
Monitor.PulseAll(newMessageArrivedLock);
}
#pragma warning disable 420
Interlocked.Decrement(ref currentlyInsideTransaction);
#pragma warning restore 420
}, AssertNotDisposed);
CurrentlyEnslistedTransaction = Transaction.Current;
}
public void Rollback(TransactionEnlistment enlistment)
{
if (DebugTrace.Info)
{
DebugTrace.TxTrace(TraceLevel.Info, enlistment.EnlistmentId, "Sending Rollback to transaction manager");
}
this.coordination.Rollback(enlistment.Enlistment, this.rollbackResponseCallback, enlistment);
}
public void ForgetResponse(TransactionEnlistment enlistment, Status status)
{
if (DebugTrace.Info)
{
DebugTrace.TxTrace(TraceLevel.Info, enlistment.EnlistmentId, "Replying {0} to transaction manager's Forget", status);
}
enlistment.DeliverCallback(status);
}
protected StateMachine(TransactionEnlistment enlistment)
{
this.enlistment = enlistment;
this.state = enlistment.State;
this.synchronization = new SynchronizationManager(this);
if (DebugTrace.Warning || DiagnosticUtility.ShouldTraceWarning)
{
this.history = new StateMachineHistory();
}
}
public void Rollback(Enlistment enlistment, ProtocolProviderCallback callback, object obj)
{
ParticipantEnlistment protocolProviderContext = enlistment.ProtocolProviderContext as ParticipantEnlistment;
if (protocolProviderContext != null)
{
protocolProviderContext.StateMachine.Enqueue(new TmRollbackEvent(protocolProviderContext, callback, obj));
}
else
{
TransactionEnlistment enlistment3 = (TransactionEnlistment)enlistment.ProtocolProviderContext;
enlistment3.StateMachine.Enqueue(new TmAsyncRollbackEvent(enlistment3, callback, obj));
}
}
private void EnsureEnlistment()
{
AssertNotDisposedOrDisposing();
if (Transaction.Current == null)
{
throw new InvalidOperationException("You must use TransactionScope when using LightningQueues");
}
if (_currentlyEnslistedTransaction == Transaction.Current)
{
return;
}
// need to change the enlistment
Interlocked.Increment(ref _currentlyInsideTransaction);
_enlistment = new TransactionEnlistment(_queueStorage, OnTransactionComplete, AssertNotDisposed);
_currentlyEnslistedTransaction = Transaction.Current;
}
/// <summary>
/// Gets an enlistment into the ambient transaction, if one exists.
/// </summary>
/// <returns>An enlistment into the ambient transaction, or <c>null</c> if there is no ambient
/// transaction.</returns>
private TransactionEnlistment GetEnlistment()
{
Transaction txTransaction = Transaction.Current;
TransactionEnlistment enlEnlistment = null; ;
if (txTransaction != null)
{
lock (m_objEnlistmentLock)
{
if (m_dicEnlistments == null)
m_dicEnlistments = new Dictionary<string, TransactionEnlistment>();
if (m_dicEnlistments.ContainsKey(txTransaction.TransactionInformation.LocalIdentifier))
enlEnlistment = m_dicEnlistments[txTransaction.TransactionInformation.LocalIdentifier];
else
{
enlEnlistment = new TransactionEnlistment(txTransaction, this);
m_dicEnlistments.Add(txTransaction.TransactionInformation.LocalIdentifier, enlEnlistment);
}
}
}
else
enlEnlistment = new TransactionEnlistment(null, this);
return enlEnlistment;
}
public static void RollbackResponse(Enlistment enlistment, Status status, object obj)
{
TransactionEnlistment enlistment2 = (TransactionEnlistment)obj;
enlistment2.StateMachine.Enqueue(new TmRollbackResponseEvent(enlistment2, status));
}
private void EnsureEnlistment()
{
AssertNotDisposedOrDisposing();
if (Transaction.Current == null)
throw new InvalidOperationException("You must use TransactionScope when using Rhino.Files");
if (CurrentlyEnslistedTransaction == Transaction.Current)
return;
// need to change the enlistment
Interlocked.Increment(ref _currentlyInsideTransaction);
Enlistment = new TransactionEnlistment(_queueStorage, OnTransactionComplete, AssertNotDisposed);
CurrentlyEnslistedTransaction = Transaction.Current;
}
public TmRollbackResponseEvent(TransactionEnlistment enlistment, Microsoft.Transactions.Bridge.Status status) : base(enlistment)
{
this.status = status;
}
protected SynchronizationEvent(TransactionEnlistment enlistment)
{
this.enlistment = enlistment;
this.state = enlistment.State;
}
public TmAsyncRollbackEvent(TransactionEnlistment enlistment, ProtocolProviderCallback callback, object state) : base(enlistment)
{
this.callback = callback;
this.callbackState = state;
}
