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);
        }
        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;
        }
示例#3
0
 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");
     }
 }
示例#4
0
 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);
 }
 internal void BeginCommit(InternalTransaction internalTransaction)
 {
     if (DiagnosticTrace.Verbose)
     {
         MethodEnteredTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "CommittableTransaction.BeginCommit");
         TransactionCommitCalledTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), base.TransactionTraceId);
     }
     base.realOletxTransaction.InternalTransaction = internalTransaction;
     this.commitCalled = true;
     base.realOletxTransaction.Commit();
     if (DiagnosticTrace.Verbose)
     {
         MethodExitedTraceRecord.Trace(System.Transactions.SR.GetString("TraceSourceOletx"), "CommittableTransaction.BeginCommit");
     }
 }
示例#6
0
        // Forward the commit to the state machine to take the appropriate action.
        //
        /// <include file='doc\Transaction.uex' path='docs/doc[@for="Transaction."]/*' />
        public void Commit()
        {
            if (DiagnosticTrace.Verbose)
            {
                MethodEnteredTraceRecord.Trace(SR.GetString(SR.TraceSourceLtm),
                                               "CommittableTransaction.Commit"
                                               );
                TransactionCommitCalledTraceRecord.Trace(SR.GetString(SR.TraceSourceLtm),
                                                         this.TransactionTraceId
                                                         );
            }

            if (Disposed)
            {
                throw new ObjectDisposedException("Transaction");
            }

            lock (this.internalTransaction)
            {
                if (this.complete)
                {
                    throw TransactionException.CreateTransactionCompletedException(SR.GetString(SR.TraceSourceLtm), this.DistributedTxId);
                }

                this.internalTransaction.State.BeginCommit(this.internalTransaction, false, null, null);

                // now that commit has started wait for the monitor on the transaction to know
                // if the transaction is done.
                do
                {
                    if (this.internalTransaction.State.IsCompleted(this.internalTransaction))
                    {
                        break;
                    }
                } while (System.Threading.Monitor.Wait(this.internalTransaction));

                this.internalTransaction.State.EndCommit(this.internalTransaction);
            }

            if (DiagnosticTrace.Verbose)
            {
                MethodExitedTraceRecord.Trace(SR.GetString(SR.TraceSourceLtm),
                                              "CommittableTransaction.Commit"
                                              );
            }
        }
        // Forward the commit to the state machine to take the appropriate action.
        //
        public void Commit()
        {
            if (DiagnosticTrace.Verbose)
            {
                MethodEnteredTraceRecord.Trace(SR.TraceSourceLtm, "CommittableTransaction.Commit");
                TransactionCommitCalledTraceRecord.Trace(SR.TraceSourceLtm, TransactionTraceId);
            }

            if (Disposed)
            {
                throw new ObjectDisposedException(nameof(CommittableTransaction));
            }

            lock (_internalTransaction)
            {
                if (_complete)
                {
                    throw TransactionException.CreateTransactionCompletedException(SR.TraceSourceLtm, DistributedTxId);
                }

                _internalTransaction.State.BeginCommit(_internalTransaction, false, null, null);

                // now that commit has started wait for the monitor on the transaction to know
                // if the transaction is done.
                do
                {
                    if (_internalTransaction.State.IsCompleted(_internalTransaction))
                    {
                        break;
                    }
                } while (Monitor.Wait(_internalTransaction));

                _internalTransaction.State.EndCommit(_internalTransaction);
            }

            if (DiagnosticTrace.Verbose)
            {
                MethodExitedTraceRecord.Trace(SR.TraceSourceLtm, "CommittableTransaction.Commit");
            }
        }