internal override void EnterState(InternalTransaction tx)
{
base.EnterState(tx);
base.CommonEnterState(tx);
for (int i = 0; i < tx.phase0Volatiles.volatileEnlistmentCount; i++)
{
tx.phase0Volatiles.volatileEnlistments[i].twoPhaseState.InternalAborted(tx.phase0Volatiles.volatileEnlistments[i]);
}
for (int j = 0; j < tx.phase1Volatiles.volatileEnlistmentCount; j++)
{
tx.phase1Volatiles.volatileEnlistments[j].twoPhaseState.InternalAborted(tx.phase1Volatiles.volatileEnlistments[j]);
}
if (tx.durableEnlistment != null)
{
tx.durableEnlistment.State.InternalAborted(tx.durableEnlistment);
}
TransactionManager.TransactionTable.Remove(tx);
if (DiagnosticTrace.Warning)
{
TransactionAbortedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), tx.TransactionTraceId);
}
tx.FireCompletion();
if (tx.asyncCommit)
{
tx.SignalAsyncCompletion();
}
}
internal override void EnterState(InternalTransaction tx)
{
base.EnterState(tx);
base.CommonEnterState(tx);
for (int i = 0; i < tx.phase0Volatiles.volatileEnlistmentCount; i++)
{
tx.phase0Volatiles.volatileEnlistments[i].twoPhaseState.InternalAborted(tx.phase0Volatiles.volatileEnlistments[i]);
}
for (int j = 0; j < tx.phase1Volatiles.volatileEnlistmentCount; j++)
{
tx.phase1Volatiles.volatileEnlistments[j].twoPhaseState.InternalAborted(tx.phase1Volatiles.volatileEnlistments[j]);
}
if (tx.durableEnlistment != null)
{
tx.durableEnlistment.State.InternalAborted(tx.durableEnlistment);
}
TransactionManager.TransactionTable.Remove(tx);
if (DiagnosticTrace.Warning)
{
TransactionAbortedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), tx.TransactionTraceId);
}
tx.FireCompletion();
if (tx.asyncCommit)
{
tx.SignalAsyncCompletion();
}
}
internal override void EnterState(InternalTransaction tx)
{
base.EnterState(tx);
if (tx.phase1Volatiles.VolatileDemux != null)
{
tx.phase1Volatiles.VolatileDemux.BroadcastCommitted(ref tx.phase1Volatiles);
}
if (tx.phase0Volatiles.VolatileDemux != null)
{
tx.phase0Volatiles.VolatileDemux.BroadcastCommitted(ref tx.phase0Volatiles);
}
tx.FireCompletion();
if (DiagnosticTrace.Verbose)
{
TransactionCommittedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), tx.TransactionTraceId);
}
}
internal override void EnterState(InternalTransaction tx)
{
base.EnterState(tx);
if (tx.phase1Volatiles.VolatileDemux != null)
{
tx.phase1Volatiles.VolatileDemux.BroadcastInDoubt(ref tx.phase1Volatiles);
}
if (tx.phase0Volatiles.VolatileDemux != null)
{
tx.phase0Volatiles.VolatileDemux.BroadcastInDoubt(ref tx.phase0Volatiles);
}
tx.FireCompletion();
if (DiagnosticTrace.Warning)
{
TransactionInDoubtTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), tx.TransactionTraceId);
}
}
internal override void EnterState(InternalTransaction tx)
{
base.EnterState(tx);
// Notify the phase 0 enlistments that the transaction is indoubt
for (int i = 0; i < tx._phase0Volatiles._volatileEnlistmentCount; i++)
{
tx._phase0Volatiles._volatileEnlistments[i]._twoPhaseState.InternalIndoubt(tx._phase0Volatiles._volatileEnlistments[i]);
}
// Notify the phase 1 enlistments that the transaction is indoubt
for (int i = 0; i < tx._phase1Volatiles._volatileEnlistmentCount; i++)
{
tx._phase1Volatiles._volatileEnlistments[i]._twoPhaseState.InternalIndoubt(tx._phase1Volatiles._volatileEnlistments[i]);
}
// Fire Completion for anyone listening
tx.FireCompletion();
// We don't need to do the AsyncCompletion stuff. If it was needed, it was done out of SignalCallback.
TransactionsEtwProvider etwLog = TransactionsEtwProvider.Log;
if (etwLog.IsEnabled())
{
etwLog.TransactionInDoubt(tx.TransactionTraceId);
}
}
internal override void EnterState(InternalTransaction tx)
{
base.EnterState(tx);
// Tell all the enlistments the outcome.
if (tx._phase1Volatiles.VolatileDemux != null)
{
tx._phase1Volatiles.VolatileDemux.BroadcastInDoubt(ref tx._phase1Volatiles);
}
if (tx._phase0Volatiles.VolatileDemux != null)
{
tx._phase0Volatiles.VolatileDemux.BroadcastInDoubt(ref tx._phase0Volatiles);
}
// Fire Completion for anyone listening
tx.FireCompletion();
// We don't need to do the AsyncCompletion stuff. If it was needed, it was done out of SignalCallback.
TransactionsEtwProvider etwLog = TransactionsEtwProvider.Log;
if (etwLog.IsEnabled())
{
etwLog.TransactionInDoubt(tx.TransactionTraceId);
}
}
internal override void EnterState(InternalTransaction tx)
{
base.EnterState(tx);
// Set the transaction state
CommonEnterState(tx);
// Notify the phase 0 enlistments that the transaction has aborted
for (int i = 0; i < tx._phase0Volatiles._volatileEnlistmentCount; i++)
{
tx._phase0Volatiles._volatileEnlistments[i]._twoPhaseState.InternalIndoubt(tx._phase0Volatiles._volatileEnlistments[i]);
}
// Notify the phase 1 enlistments that the transaction has aborted
for (int i = 0; i < tx._phase1Volatiles._volatileEnlistmentCount; i++)
{
tx._phase1Volatiles._volatileEnlistments[i]._twoPhaseState.InternalIndoubt(tx._phase1Volatiles._volatileEnlistments[i]);
}
// Remove this from the timeout list
TransactionManager.TransactionTable.Remove(tx);
TransactionsEtwProvider etwLog = TransactionsEtwProvider.Log;
if (etwLog.IsEnabled())
{
etwLog.TransactionInDoubt(tx.TransactionTraceId);
}
// Fire Completion for anyone listening
tx.FireCompletion();
// Check to see if we need to release some waiter.
if (tx._asyncCommit)
{
tx.SignalAsyncCompletion();
}
}
internal override void EnterState( InternalTransaction tx )
{
base.EnterState( tx );
// Tell all the enlistments the outcome.
if ( tx.phase1Volatiles.VolatileDemux != null )
{
tx.phase1Volatiles.VolatileDemux.BroadcastInDoubt( ref tx.phase1Volatiles );
}
if ( tx.phase0Volatiles.VolatileDemux != null )
{
tx.phase0Volatiles.VolatileDemux.BroadcastInDoubt( ref tx.phase0Volatiles );
}
// Fire Completion for anyone listening
tx.FireCompletion( );
// We don't need to do the AsyncCompletion stuff. If it was needed, it was done out of SignalCallback.
if ( DiagnosticTrace.Warning )
{
TransactionInDoubtTraceRecord.Trace( SR.GetString( SR.TraceSourceLtm ),
tx.TransactionTraceId
);
}
}
internal override void EnterState( InternalTransaction tx )
{
base.EnterState( tx );
// Set the transaction state
CommonEnterState( tx );
// Notify the phase 0 enlistments that the transaction has aborted
for ( int i = 0; i < tx.phase0Volatiles.volatileEnlistmentCount; i++ )
{
tx.phase0Volatiles.volatileEnlistments[i].twoPhaseState.InternalIndoubt(tx.phase0Volatiles.volatileEnlistments[i]);
}
// Notify the phase 1 enlistments that the transaction has aborted
for ( int i = 0; i < tx.phase1Volatiles.volatileEnlistmentCount; i++ )
{
tx.phase1Volatiles.volatileEnlistments[i].twoPhaseState.InternalIndoubt(tx.phase1Volatiles.volatileEnlistments[i]);
}
// Remove this from the timeout list
TransactionManager.TransactionTable.Remove( tx );
if ( DiagnosticTrace.Warning )
{
TransactionInDoubtTraceRecord.Trace( SR.GetString( SR.TraceSourceLtm ),
tx.TransactionTraceId
);
}
// Fire Completion for anyone listening
tx.FireCompletion( );
// Check to see if we need to release some waiter.
if ( tx.asyncCommit )
{
tx.SignalAsyncCompletion();
}
}
internal override void EnterState(InternalTransaction tx)
{
base.EnterState(tx);
// Notify the phase 0 enlistments that the transaction is indoubt
for (int i = 0; i < tx._phase0Volatiles._volatileEnlistmentCount; i++)
{
tx._phase0Volatiles._volatileEnlistments[i]._twoPhaseState.InternalIndoubt(tx._phase0Volatiles._volatileEnlistments[i]);
}
// Notify the phase 1 enlistments that the transaction is indoubt
for (int i = 0; i < tx._phase1Volatiles._volatileEnlistmentCount; i++)
{
tx._phase1Volatiles._volatileEnlistments[i]._twoPhaseState.InternalIndoubt(tx._phase1Volatiles._volatileEnlistments[i]);
}
// Fire Completion for anyone listening
tx.FireCompletion();
// We don't need to do the AsyncCompletion stuff. If it was needed, it was done out of SignalCallback.
if (DiagnosticTrace.Warning)
{
TransactionInDoubtTraceRecord.Trace(SR.TraceSourceLtm,
tx.TransactionTraceId
);
}
}
internal override void EnterState(InternalTransaction tx)
{
base.EnterState(tx);
// Set the transaction state
CommonEnterState(tx);
// Do NOT mark the committable transaction as complete because it is aborting.
// Notify the enlistments that the transaction has aborted
for (int i = 0; i < tx._phase0Volatiles._volatileEnlistmentCount; i++)
{
tx._phase0Volatiles._volatileEnlistments[i]._twoPhaseState.InternalAborted(tx._phase0Volatiles._volatileEnlistments[i]);
}
for (int i = 0; i < tx._phase1Volatiles._volatileEnlistmentCount; i++)
{
tx._phase1Volatiles._volatileEnlistments[i]._twoPhaseState.InternalAborted(tx._phase1Volatiles._volatileEnlistments[i]);
}
// Notify the durable enlistment
if (tx._durableEnlistment != null)
{
tx._durableEnlistment.State.InternalAborted(tx._durableEnlistment);
}
// Remove this from the timeout list
TransactionManager.TransactionTable.Remove(tx);
if (DiagnosticTrace.Warning)
{
TransactionAbortedTraceRecord.Trace(SR.TraceSourceLtm,
tx.TransactionTraceId
);
}
// Fire Completion for anyone listening
tx.FireCompletion();
// Check to see if we need to release some waiter.
if (tx._asyncCommit)
{
tx.SignalAsyncCompletion();
}
}
