internal override void InternalDispose()
{
if (DiagnosticTrace.Verbose)
{
MethodEnteredTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), "IDisposable.Dispose");
}
if (Interlocked.Exchange(ref this.disposed, 1) != 1)
{
if (base.internalTransaction.State.get_Status(base.internalTransaction) == TransactionStatus.Active)
{
lock (base.internalTransaction)
{
base.internalTransaction.State.DisposeRoot(base.internalTransaction);
}
}
long num = Interlocked.Decrement(ref base.internalTransaction.cloneCount);
if (num == 0L)
{
base.internalTransaction.Dispose();
}
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), "IDisposable.Dispose");
}
}
}
internal OletxDependentTransaction DependentClone(bool delayCommit)
{
OletxDependentTransaction transaction = null;
if (DiagnosticTrace.Verbose)
{
MethodEnteredTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "OletxTransaction.DependentClone");
}
if (TransactionStatus.Aborted == this.Status)
{
throw TransactionAbortedException.Create(System.Transactions.SR.GetString("TraceSourceOletx"), this.realOletxTransaction.innerException);
}
if (TransactionStatus.InDoubt == this.Status)
{
throw TransactionInDoubtException.Create(System.Transactions.SR.GetString("TraceSourceOletx"), this.realOletxTransaction.innerException);
}
if (this.Status != TransactionStatus.Active)
{
throw TransactionException.Create(System.Transactions.SR.GetString("TraceSourceOletx"), System.Transactions.SR.GetString("TransactionAlreadyOver"), null);
}
transaction = new OletxDependentTransaction(this.realOletxTransaction, delayCommit);
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "OletxTransaction.DependentClone");
}
return(transaction);
}
public void EndCommit(IAsyncResult asyncResult)
{
if (DiagnosticTrace.Verbose)
{
MethodEnteredTraceRecord.Trace(SR.TraceSourceLtm, "CommittableTransaction.EndCommit");
}
if (asyncResult != ((object)this))
{
throw new ArgumentException(SR.BadAsyncResult, nameof(asyncResult));
}
lock (_internalTransaction)
{
do
{
if (_internalTransaction.State.IsCompleted(_internalTransaction))
{
break;
}
} while (Monitor.Wait(_internalTransaction));
_internalTransaction.State.EndCommit(_internalTransaction);
}
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(SR.TraceSourceLtm, "CommittableTransaction.EndCommit");
}
}
public static byte[] GetTransmitterPropagationToken(
Transaction transaction
)
{
if (!TransactionManager._platformValidated)
{
TransactionManager.ValidatePlatform();
}
if (null == transaction)
{
throw new ArgumentNullException("transaction");
}
if (DiagnosticTrace.Verbose)
{
MethodEnteredTraceRecord.Trace(SR.GetString(SR.TraceSourceOletx),
"TransactionInterop.GetTransmitterPropagationToken"
);
}
// First, make sure we are working with an OletxTransaction.
OletxTransaction oletxTx = TransactionInterop.ConvertToOletxTransaction(transaction);
byte[] token = GetTransmitterPropagationToken(oletxTx);
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(SR.GetString(SR.TraceSourceOletx),
"TransactionInterop.GetTransmitterPropagationToken"
);
}
return(token);
}
internal override void DependentCloneCompleted()
{
bool flag = false;
lock (this)
{
if (DiagnosticTrace.Verbose)
{
string methodName = "OletxPhase0VolatileEnlistmentContainer.DependentCloneCompleted, outstandingNotifications = " + this.outstandingNotifications.ToString(CultureInfo.CurrentCulture) + ", incompleteDependentClones = " + this.incompleteDependentClones.ToString(CultureInfo.CurrentCulture) + ", phase = " + this.phase.ToString(CultureInfo.CurrentCulture);
MethodEnteredTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), methodName);
}
base.incompleteDependentClones--;
if ((base.incompleteDependentClones == 0) && (base.phase == 0))
{
base.outstandingNotifications++;
flag = true;
}
}
if (flag)
{
this.DecrementOutstandingNotifications(true);
}
if (DiagnosticTrace.Verbose)
{
string str = "OletxPhase0VolatileEnlistmentContainer.DependentCloneCompleted";
MethodExitedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), str);
}
}
public bool EnlistPromotableSinglePhase(IPromotableSinglePhaseNotification promotableSinglePhaseNotification)
{
if (DiagnosticTrace.Verbose)
{
MethodEnteredTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), "Transaction.EnlistPromotableSinglePhase");
}
if (this.Disposed)
{
throw new ObjectDisposedException("Transaction");
}
if (promotableSinglePhaseNotification == null)
{
throw new ArgumentNullException("promotableSinglePhaseNotification");
}
if (this.complete)
{
throw TransactionException.CreateTransactionCompletedException(System.Transactions.SR.GetString("TraceSourceLtm"));
}
bool flag = false;
lock (this.internalTransaction)
{
flag = this.internalTransaction.State.EnlistPromotableSinglePhase(this.internalTransaction, promotableSinglePhaseNotification, this);
}
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), "Transaction.EnlistPromotableSinglePhase");
}
return(flag);
}
void ISerializable.GetObjectData(SerializationInfo serializationInfo, StreamingContext context)
{
if (DiagnosticTrace.Verbose)
{
MethodEnteredTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), "ISerializable.GetObjectData");
}
if (this.Disposed)
{
throw new ObjectDisposedException("Transaction");
}
if (serializationInfo == null)
{
throw new ArgumentNullException("serializationInfo");
}
if (this.complete)
{
throw TransactionException.CreateTransactionCompletedException(System.Transactions.SR.GetString("TraceSourceLtm"));
}
lock (this.internalTransaction)
{
this.internalTransaction.State.GetObjectData(this.internalTransaction, serializationInfo, context);
}
if (DiagnosticTrace.Information)
{
TransactionSerializedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), this.TransactionTraceId);
}
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), "ISerializable.GetObjectData");
}
}
public void Rollback(Exception e)
{
if (DiagnosticTrace.Verbose)
{
MethodEnteredTraceRecord.Trace(SR.TraceSourceLtm, "Transaction.Rollback");
}
if (DiagnosticTrace.Warning)
{
TransactionRollbackCalledTraceRecord.Trace(SR.TraceSourceLtm, TransactionTraceId);
}
if (Disposed)
{
throw new ObjectDisposedException(nameof(Transaction));
}
lock (_internalTransaction)
{
Debug.Assert(_internalTransaction.State != null);
_internalTransaction.State.Rollback(_internalTransaction, e);
}
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(SR.TraceSourceLtm, "Transaction.Rollback");
}
}
// Create a clone of the transaction that forwards requests to this object.
//
public Transaction Clone()
{
if (DiagnosticTrace.Verbose)
{
MethodEnteredTraceRecord.Trace(SR.TraceSourceLtm, "Transaction.Clone");
}
if (Disposed)
{
throw new ObjectDisposedException(nameof(Transaction));
}
if (_complete)
{
throw TransactionException.CreateTransactionCompletedException(SR.TraceSourceLtm, DistributedTxId);
}
Transaction clone = InternalClone();
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(SR.TraceSourceLtm, "Transaction.Clone");
}
return(clone);
}
internal void BeginCommit(
InternalTransaction internalTransaction
)
{
if (DiagnosticTrace.Verbose)
{
MethodEnteredTraceRecord.Trace(SR.GetString(SR.TraceSourceOletx),
"CommittableTransaction.BeginCommit"
);
TransactionCommitCalledTraceRecord.Trace(SR.GetString(SR.TraceSourceOletx),
this.TransactionTraceId
);
}
Debug.Assert((0 == this.disposed), "OletxTransction object is disposed");
this.realOletxTransaction.InternalTransaction = internalTransaction;
this.commitCalled = true;
this.realOletxTransaction.Commit();
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(SR.GetString(SR.TraceSourceOletx),
"CommittableTransaction.BeginCommit"
);
}
return;
}
internal void VoteRequest()
{
OletxVolatileEnlistment enlistment = null;
int count = 0;
bool flag = false;
lock (this)
{
if (DiagnosticTrace.Verbose)
{
string methodName = "OletxPhase1VolatileEnlistmentContainer.VoteRequest";
MethodEnteredTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), methodName);
}
base.phase = 1;
if (0 < base.incompleteDependentClones)
{
flag = true;
base.outstandingNotifications = 1;
}
else
{
base.outstandingNotifications = base.enlistmentList.Count;
count = base.enlistmentList.Count;
if (count == 0)
{
base.outstandingNotifications = 1;
}
}
base.realOletxTransaction.TooLateForEnlistments = true;
}
if (flag)
{
this.DecrementOutstandingNotifications(false);
}
else if (count == 0)
{
this.DecrementOutstandingNotifications(true);
}
else
{
for (int i = 0; i < count; i++)
{
enlistment = base.enlistmentList[i] as OletxVolatileEnlistment;
if (enlistment == null)
{
if (DiagnosticTrace.Critical)
{
InternalErrorTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "");
}
throw new InvalidOperationException(System.Transactions.SR.GetString("InternalError"));
}
enlistment.Prepare(this);
}
}
if (DiagnosticTrace.Verbose)
{
string str = "OletxPhase1VolatileEnlistmentContainer.VoteRequest";
MethodExitedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), str);
}
}
public void Complete()
{
if (DiagnosticTrace.Verbose)
{
MethodEnteredTraceRecord.Trace(SR.GetString(SR.TraceSourceOletx),
"DependentTransaction.Complete"
);
}
Debug.Assert((0 == this.disposed), "OletxTransction object is disposed");
int localCompleted = Interlocked.CompareExchange(ref this.completed, 1, 0);
if (1 == localCompleted)
{
throw TransactionException.CreateTransactionCompletedException(SR.GetString(SR.TraceSourceOletx));
}
if (DiagnosticTrace.Information)
{
DependentCloneCompleteTraceRecord.Trace(SR.GetString(SR.TraceSourceOletx),
this.TransactionTraceId
);
}
this.volatileEnlistmentContainer.DependentCloneCompleted();
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(SR.GetString(SR.TraceSourceOletx),
"DependentTransaction.Complete"
);
}
}
public void Commit()
{
if (DiagnosticTrace.Verbose)
{
MethodEnteredTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), "CommittableTransaction.Commit");
TransactionCommitCalledTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), base.TransactionTraceId);
}
if (base.Disposed)
{
throw new ObjectDisposedException("Transaction");
}
lock (base.internalTransaction)
{
if (base.complete)
{
throw TransactionException.CreateTransactionCompletedException(System.Transactions.SR.GetString("TraceSourceLtm"));
}
base.internalTransaction.State.BeginCommit(base.internalTransaction, false, null, null);
while (!base.internalTransaction.State.IsCompleted(base.internalTransaction) && Monitor.Wait(base.internalTransaction))
{
}
base.internalTransaction.State.EndCommit(base.internalTransaction);
}
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), "CommittableTransaction.Commit");
}
}
public IAsyncResult BeginCommit(AsyncCallback asyncCallback, object asyncState)
{
if (DiagnosticTrace.Verbose)
{
MethodEnteredTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), "CommittableTransaction.BeginCommit");
TransactionCommitCalledTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), base.TransactionTraceId);
}
if (base.Disposed)
{
throw new ObjectDisposedException("Transaction");
}
lock (base.internalTransaction)
{
if (base.complete)
{
throw TransactionException.CreateTransactionCompletedException(System.Transactions.SR.GetString("TraceSourceLtm"));
}
base.internalTransaction.State.BeginCommit(base.internalTransaction, true, asyncCallback, asyncState);
}
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), "CommittableTransaction.BeginCommit");
}
return(this);
}
public void Committed()
{
if (DiagnosticTrace.Verbose)
{
MethodEnteredTraceRecord.Trace(SR.GetString(SR.TraceSourceLtm),
"SinglePhaseEnlistment.Committed"
);
EnlistmentCallbackPositiveTraceRecord.Trace(SR.GetString(SR.TraceSourceLtm),
this.internalEnlistment.EnlistmentTraceId,
EnlistmentCallback.Committed
);
}
lock (this.internalEnlistment.SyncRoot)
{
this.internalEnlistment.State.Committed(this.internalEnlistment);
}
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(SR.GetString(SR.TraceSourceLtm),
"SinglePhaseEnlistment.Committed"
);
}
}
// Handle Transaction Disposal.
//
internal virtual void InternalDispose()
{
if (DiagnosticTrace.Verbose)
{
MethodEnteredTraceRecord.Trace(SR.TraceSourceLtm, "IDisposable.Dispose");
}
if (Interlocked.Exchange(ref _disposed, Transaction._disposedTrueValue) == Transaction._disposedTrueValue)
{
return;
}
// Attempt to clean up the internal transaction
long remainingITx = Interlocked.Decrement(ref _internalTransaction._cloneCount);
if (remainingITx == 0)
{
_internalTransaction.Dispose();
}
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(SR.TraceSourceLtm, "IDisposable.Dispose");
}
}
public DependentTransaction DependentClone(DependentCloneOption cloneOption)
{
if (DiagnosticTrace.Verbose)
{
MethodEnteredTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), "Transaction.DependentClone");
}
if ((cloneOption != DependentCloneOption.BlockCommitUntilComplete) && (cloneOption != DependentCloneOption.RollbackIfNotComplete))
{
throw new ArgumentOutOfRangeException("cloneOption");
}
if (this.Disposed)
{
throw new ObjectDisposedException("Transaction");
}
if (this.complete)
{
throw TransactionException.CreateTransactionCompletedException(System.Transactions.SR.GetString("TraceSourceLtm"));
}
DependentTransaction transaction = new DependentTransaction(this.isoLevel, this.internalTransaction, cloneOption == DependentCloneOption.BlockCommitUntilComplete);
if (DiagnosticTrace.Information)
{
DependentCloneCreatedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), transaction.TransactionTraceId, cloneOption);
}
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), "Transaction.DependentClone");
}
return(transaction);
}
public byte[] RecoveryInformation()
{
if (DiagnosticTrace.Verbose)
{
MethodEnteredTraceRecord.Trace(SR.GetString(SR.TraceSourceLtm),
"PreparingEnlistment.RecoveryInformation"
);
}
try
{
lock (this.internalEnlistment.SyncRoot)
{
return(this.internalEnlistment.State.RecoveryInformation(this.internalEnlistment));
}
}
finally
{
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(SR.GetString(SR.TraceSourceLtm),
"PreparingEnlistment.RecoveryInformation"
);
}
}
}
public Enlistment EnlistVolatile(ISinglePhaseNotification singlePhaseNotification, EnlistmentOptions enlistmentOptions)
{
if (DiagnosticTrace.Verbose)
{
MethodEnteredTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), "Transaction.EnlistVolatile( ISinglePhaseNotification )");
}
if (this.Disposed)
{
throw new ObjectDisposedException("Transaction");
}
if (singlePhaseNotification == null)
{
throw new ArgumentNullException("singlePhaseNotification");
}
if ((enlistmentOptions != EnlistmentOptions.None) && (enlistmentOptions != EnlistmentOptions.EnlistDuringPrepareRequired))
{
throw new ArgumentOutOfRangeException("enlistmentOptions");
}
if (this.complete)
{
throw TransactionException.CreateTransactionCompletedException(System.Transactions.SR.GetString("TraceSourceLtm"));
}
lock (this.internalTransaction)
{
Enlistment enlistment2 = this.internalTransaction.State.EnlistVolatile(this.internalTransaction, singlePhaseNotification, enlistmentOptions, this);
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceLtm"), "Transaction.EnlistVolatile( ISinglePhaseNotification )");
}
return(enlistment2);
}
}
public void ForceRollback(Exception e)
{
if (DiagnosticTrace.Verbose)
{
MethodEnteredTraceRecord.Trace(SR.GetString(SR.TraceSourceLtm),
"PreparingEnlistment.ForceRollback"
);
}
if (DiagnosticTrace.Warning)
{
EnlistmentCallbackNegativeTraceRecord.Trace(SR.GetString(SR.TraceSourceLtm),
this.internalEnlistment.EnlistmentTraceId,
EnlistmentCallback.ForceRollback
);
}
lock (this.internalEnlistment.SyncRoot)
{
this.internalEnlistment.State.ForceRollback(this.internalEnlistment, e);
}
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(SR.GetString(SR.TraceSourceLtm),
"PreparingEnlistment.ForceRollback"
);
}
}
public void Done()
{
if (DiagnosticTrace.Verbose)
{
MethodEnteredTraceRecord.Trace(SR.GetString(SR.TraceSourceLtm),
"Enlistment.Done"
);
EnlistmentCallbackPositiveTraceRecord.Trace(SR.GetString(SR.TraceSourceLtm),
this.internalEnlistment.EnlistmentTraceId,
EnlistmentCallback.Done
);
}
lock (this.internalEnlistment.SyncRoot)
{
this.internalEnlistment.State.EnlistmentDone(this.internalEnlistment);
}
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(SR.GetString(SR.TraceSourceLtm),
"Enlistment.Done"
);
}
}
internal static byte[] GetRecoveryInformation(string startupInfo, byte[] resourceManagerRecoveryInformation)
{
if (DiagnosticTrace.Verbose)
{
MethodEnteredTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceBase"), "TransactionManager.GetRecoveryInformation");
}
MemoryStream output = new MemoryStream();
byte[] buffer = null;
try
{
BinaryWriter writer = new BinaryWriter(output);
writer.Write(1);
if (startupInfo != null)
{
writer.Write(startupInfo);
}
else
{
writer.Write("");
}
writer.Write(resourceManagerRecoveryInformation);
writer.Flush();
buffer = output.ToArray();
}
finally
{
output.Close();
}
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceBase"), "TransactionManager.GetRecoveryInformation");
}
return(buffer);
}
internal override void DecrementOutstandingNotifications(bool voteYes)
{
bool flag = false;
IPhase0EnlistmentShim shim = null;
lock (this)
{
if (DiagnosticTrace.Verbose)
{
string methodName = "OletxPhase0VolatileEnlistmentContainer.DecrementOutstandingNotifications, outstandingNotifications = " + this.outstandingNotifications.ToString(CultureInfo.CurrentCulture) + ", incompleteDependentClones = " + this.incompleteDependentClones.ToString(CultureInfo.CurrentCulture);
MethodEnteredTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), methodName);
}
base.outstandingNotifications--;
base.collectedVoteYes = base.collectedVoteYes && voteYes;
if ((base.outstandingNotifications == 0) && (base.incompleteDependentClones == 0))
{
if ((base.phase == 0) && !base.alreadyVoted)
{
flag = true;
base.alreadyVoted = true;
shim = this.phase0EnlistmentShim;
}
base.realOletxTransaction.DecrementUndecidedEnlistments();
}
}
try
{
if (flag && (shim != null))
{
shim.Phase0Done(base.collectedVoteYes && !base.realOletxTransaction.Doomed);
}
}
catch (COMException exception)
{
if ((System.Transactions.Oletx.NativeMethods.XACT_E_CONNECTION_DOWN == exception.ErrorCode) || (System.Transactions.Oletx.NativeMethods.XACT_E_TMNOTAVAILABLE == exception.ErrorCode))
{
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), exception);
}
}
else
{
if (System.Transactions.Oletx.NativeMethods.XACT_E_PROTOCOL != exception.ErrorCode)
{
throw;
}
this.phase0EnlistmentShim = null;
if (DiagnosticTrace.Verbose)
{
ExceptionConsumedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), exception);
}
}
}
if (DiagnosticTrace.Verbose)
{
string str = "OletxPhase0VolatileEnlistmentContainer.DecrementOutstandingNotifications";
MethodExitedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), str);
}
}
void IPromotedEnlistment.EnlistmentDone()
{
if (DiagnosticTrace.Verbose)
{
MethodEnteredTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "OletxEnlistment.EnlistmentDone");
EnlistmentCallbackPositiveTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), base.InternalTraceIdentifier, EnlistmentCallback.Done);
}
OletxVolatileEnlistmentState active = OletxVolatileEnlistmentState.Active;
OletxVolatileEnlistmentContainer container = null;
lock (this)
{
active = this.state;
container = this.container;
if ((((this.state != OletxVolatileEnlistmentState.Active) && (OletxVolatileEnlistmentState.Preparing != this.state)) && ((OletxVolatileEnlistmentState.Aborting != this.state) && (OletxVolatileEnlistmentState.Committing != this.state))) && (OletxVolatileEnlistmentState.InDoubt != this.state))
{
throw TransactionException.CreateEnlistmentStateException(System.Transactions.SR.GetString("TraceSourceOletx"), null);
}
this.state = OletxVolatileEnlistmentState.Done;
}
if ((OletxVolatileEnlistmentState.Preparing == active) && (container != null))
{
container.DecrementOutstandingNotifications(true);
}
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "OletxEnlistment.EnlistmentDone");
}
}
public object GetRealObject(StreamingContext context)
{
if (DiagnosticTrace.Verbose)
{
MethodEnteredTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "IObjectReference.GetRealObject");
}
if (this.propagationTokenForDeserialize == null)
{
if (DiagnosticTrace.Critical)
{
InternalErrorTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), System.Transactions.SR.GetString("UnableToDeserializeTransaction"));
}
throw TransactionException.Create(System.Transactions.SR.GetString("TraceSourceOletx"), System.Transactions.SR.GetString("UnableToDeserializeTransactionInternalError"), null);
}
if (null != this.savedLtmPromotedTransaction)
{
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "IObjectReference.GetRealObject");
}
return(this.savedLtmPromotedTransaction);
}
Transaction transactionFromTransmitterPropagationToken = TransactionInterop.GetTransactionFromTransmitterPropagationToken(this.propagationTokenForDeserialize);
this.savedLtmPromotedTransaction = transactionFromTransmitterPropagationToken;
if (DiagnosticTrace.Verbose)
{
TransactionDeserializedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), transactionFromTransmitterPropagationToken.internalTransaction.PromotedTransaction.TransactionTraceId);
}
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "IObjectReference.GetRealObject");
}
return(transactionFromTransmitterPropagationToken);
}
public void InDoubt()
{
if (DiagnosticTrace.Verbose)
{
MethodEnteredTraceRecord.Trace(SR.GetString(SR.TraceSourceLtm),
"SinglePhaseEnlistment.InDoubt"
);
}
lock (this.internalEnlistment.SyncRoot)
{
if (DiagnosticTrace.Warning)
{
EnlistmentCallbackNegativeTraceRecord.Trace(SR.GetString(SR.TraceSourceLtm),
this.internalEnlistment.EnlistmentTraceId,
EnlistmentCallback.InDoubt
);
}
this.internalEnlistment.State.InDoubt(this.internalEnlistment, null);
}
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(SR.GetString(SR.TraceSourceLtm),
"SinglePhaseEnlistment.InDoubt"
);
}
}
internal override void InternalDispose()
{
if (DiagnosticTrace.Verbose)
{
MethodEnteredTraceRecord.Trace(SR.TraceSourceLtm, "IDisposable.Dispose");
}
if (Interlocked.Exchange(ref _disposed, Transaction._disposedTrueValue) == Transaction._disposedTrueValue)
{
return;
}
if (_internalTransaction.State.get_Status(_internalTransaction) == TransactionStatus.Active)
{
lock (_internalTransaction)
{
// Since this is the root transaction do state based dispose.
_internalTransaction.State.DisposeRoot(_internalTransaction);
}
}
// Attempt to clean up the internal transaction
long remainingITx = Interlocked.Decrement(ref _internalTransaction._cloneCount);
if (remainingITx == 0)
{
_internalTransaction.Dispose();
}
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(SR.TraceSourceLtm, "IDisposable.Dispose");
}
}
public void Aborted(Exception e)
{
if (DiagnosticTrace.Verbose)
{
MethodEnteredTraceRecord.Trace(SR.GetString(SR.TraceSourceLtm),
"SinglePhaseEnlistment.Aborted"
);
}
if (DiagnosticTrace.Warning)
{
EnlistmentCallbackNegativeTraceRecord.Trace(SR.GetString(SR.TraceSourceLtm),
this.internalEnlistment.EnlistmentTraceId,
EnlistmentCallback.Aborted
);
}
lock (this.internalEnlistment.SyncRoot)
{
this.internalEnlistment.State.Aborted(this.internalEnlistment, e);
}
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(SR.GetString(SR.TraceSourceLtm),
"SinglePhaseEnlistment.Aborted"
);
}
}
public IAsyncResult BeginCommit(AsyncCallback asyncCallback, object asyncState)
{
if (DiagnosticTrace.Verbose)
{
MethodEnteredTraceRecord.Trace(SR.TraceSourceLtm, "CommittableTransaction.BeginCommit");
TransactionCommitCalledTraceRecord.Trace(SR.TraceSourceLtm, TransactionTraceId);
}
if (Disposed)
{
throw new ObjectDisposedException(nameof(CommittableTransaction));
}
lock (_internalTransaction)
{
if (_complete)
{
throw TransactionException.CreateTransactionCompletedException(SR.TraceSourceLtm, DistributedTxId);
}
// this.complete will get set to true when the transaction enters a state that is
// beyond Phase0.
_internalTransaction.State.BeginCommit(_internalTransaction, true, asyncCallback, asyncState);
}
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(SR.TraceSourceLtm, "CommittableTransaction.BeginCommit");
}
return(this);
}
static public void RecoveryComplete(
Guid resourceManagerIdentifier
)
{
if (resourceManagerIdentifier == Guid.Empty)
{
throw new ArgumentException(SR.GetString(SR.BadResourceManagerId), "resourceManagerIdentifier");
}
if (DiagnosticTrace.Verbose)
{
MethodEnteredTraceRecord.Trace(SR.GetString(SR.TraceSourceBase),
"TransactionManager.RecoveryComplete"
);
}
if (DiagnosticTrace.Information)
{
RecoveryCompleteTraceRecord.Trace(SR.GetString(SR.TraceSourceBase),
resourceManagerIdentifier
);
}
DistributedTransactionManager.ResourceManagerRecoveryComplete(resourceManagerIdentifier);
if (DiagnosticTrace.Verbose)
{
MethodExitedTraceRecord.Trace(SR.GetString(SR.TraceSourceBase),
"TransactionManager.RecoveryComplete"
);
}
}