Dispose()

void System.Transactions.TransactionScope.Dispose ( )

inline

Implements System.IDisposable.

Definition at line 346 of file TransactionScope.cs.

    {
        bool flag = false;
        TransactionsEtwProvider log = TransactionsEtwProvider.Log;
        if (log.IsEnabled())
        {
            log.MethodEnter(TraceSourceType.TraceSourceBase, this, "Dispose");
        }
        if (_disposed)
        {
            if (log.IsEnabled())
            {
                log.MethodExit(TraceSourceType.TraceSourceBase, this, "Dispose");
            }
            return;
        }
        if (_scopeThread != Thread.CurrentThread && !AsyncFlowEnabled)
        {
            if (log.IsEnabled())
            {
                log.InvalidOperation("TransactionScope", "InvalidScopeThread");
            }
            throw new InvalidOperationException(System.SR.InvalidScopeThread);
        }
        Exception ex = null;
        try
        {
            _disposed = true;
            TransactionScope currentScope = _threadContextData.CurrentScope;
            Transaction contextTransaction = null;
            Transaction transaction = Transaction.FastGetTransaction(currentScope, _threadContextData, out contextTransaction);
            if (!Equals(currentScope))
            {
                if (currentScope == null)
                {
                    Transaction transaction2 = _committableTransaction;
                    if (transaction2 == null)
                    {
                        transaction2 = _dependentTransaction;
                    }
                    transaction2.Rollback();
                    flag = true;
                    throw TransactionException.CreateInvalidOperationException(TraceSourceType.TraceSourceBase, System.SR.TransactionScopeInvalidNesting, null, transaction2.DistributedTxId);
                }
                if (currentScope._interopOption == EnterpriseServicesInteropOption.None && ((null != currentScope._expectedCurrent && !currentScope._expectedCurrent.Equals(transaction)) || (null != transaction && null == currentScope._expectedCurrent)))
                {
                    TransactionTraceIdentifier currenttransactionID = ((!(null == transaction)) ? transaction.TransactionTraceId : TransactionTraceIdentifier.Empty);
                    TransactionTraceIdentifier newtransactionID = ((!(null == _expectedCurrent)) ? _expectedCurrent.TransactionTraceId : TransactionTraceIdentifier.Empty);
                    if (log.IsEnabled())
                    {
                        log.TransactionScopeCurrentChanged(currenttransactionID, newtransactionID);
                    }
                    ex = TransactionException.CreateInvalidOperationException(TraceSourceType.TraceSourceBase, System.SR.TransactionScopeIncorrectCurrent, null, (transaction == null) ? Guid.Empty : transaction.DistributedTxId);
                    if (null != transaction)
                    {
                        try
                        {
                            transaction.Rollback();
                        }
                        catch (TransactionException)
                        {
                        }
                        catch (ObjectDisposedException)
                        {
                        }
                    }
                }
                while (!Equals(currentScope))
                {
                    if (ex == null)
                    {
                        ex = TransactionException.CreateInvalidOperationException(TraceSourceType.TraceSourceBase, System.SR.TransactionScopeInvalidNesting, null, (transaction == null) ? Guid.Empty : transaction.DistributedTxId);
                    }
                    if (null == currentScope._expectedCurrent)
                    {
                        if (log.IsEnabled())
                        {
                            log.TransactionScopeNestedIncorrectly(TransactionTraceIdentifier.Empty);
                        }
                    }
                    else if (log.IsEnabled())
                    {
                        log.TransactionScopeNestedIncorrectly(currentScope._expectedCurrent.TransactionTraceId);
                    }
                    currentScope._complete = false;
                    try
                    {
                        currentScope.InternalDispose();
                    }
                    catch (TransactionException)
                    {
                    }
                    currentScope = _threadContextData.CurrentScope;
                    _complete = false;
                }
            }
            else if (_interopOption == EnterpriseServicesInteropOption.None && ((null != _expectedCurrent && !_expectedCurrent.Equals(transaction)) || (null != transaction && null == _expectedCurrent)))
            {
                TransactionTraceIdentifier currenttransactionID2 = ((!(null == transaction)) ? transaction.TransactionTraceId : TransactionTraceIdentifier.Empty);
                TransactionTraceIdentifier newtransactionID2 = ((!(null == _expectedCurrent)) ? _expectedCurrent.TransactionTraceId : TransactionTraceIdentifier.Empty);
                if (log.IsEnabled())
                {
                    log.TransactionScopeCurrentChanged(currenttransactionID2, newtransactionID2);
                }
                if (ex == null)
                {
                    ex = TransactionException.CreateInvalidOperationException(TraceSourceType.TraceSourceBase, System.SR.TransactionScopeIncorrectCurrent, null, (transaction == null) ? Guid.Empty : transaction.DistributedTxId);
                }
                if (null != transaction)
                {
                    try
                    {
                        transaction.Rollback();
                    }
                    catch (TransactionException)
                    {
                    }
                    catch (ObjectDisposedException)
                    {
                    }
                }
                _complete = false;
            }
            flag = true;
        }
        finally
        {
            if (!flag)
            {
                PopScope();
            }
        }
        InternalDispose();
        if (ex != null)
        {
            throw ex;
        }
        if (log.IsEnabled())
        {
            log.MethodExit(TraceSourceType.TraceSourceBase, this, "Dispose");
        }
    }

References System.Transactions.TransactionScope._committableTransaction, System.Transactions.TransactionScope._complete, System.Transactions.TransactionScope._dependentTransaction, System.Transactions.TransactionScope._disposed, System.Transactions.TransactionScope._expectedCurrent, System.Transactions.TransactionScope._interopOption, System.Transactions.TransactionScope._scopeThread, System.Transactions.TransactionScope._threadContextData, System.Transactions.TransactionScope.AsyncFlowEnabled, System.Transactions.TransactionException.CreateInvalidOperationException(), System.Transactions.ContextData.CurrentScope, System.Threading.Thread.CurrentThread, System.Transactions.Transaction.DistributedTxId, System.Transactions.TransactionTraceIdentifier.Empty, System.Transactions.Transaction.Equals(), System.Transactions.Transaction.FastGetTransaction(), System.Transactions.TransactionScope.InternalDispose(), System.Transactions.TransactionsEtwProvider.InvalidOperation(), System.Transactions.InvalidOperationException, System.SR.InvalidScopeThread, System.Diagnostics.Tracing.EventSource.IsEnabled(), System.Transactions.TransactionsEtwProvider.Log, System.Transactions.TransactionsEtwProvider.MethodEnter(), System.Transactions.TransactionsEtwProvider.MethodExit(), System.Transactions.TransactionScope.PopScope(), System.Transactions.Transaction.Rollback(), System.Transactions.TransactionsEtwProvider.TransactionScopeCurrentChanged(), System.SR.TransactionScopeIncorrectCurrent, System.SR.TransactionScopeInvalidNesting, System.Transactions.TransactionsEtwProvider.TransactionScopeNestedIncorrectly(), and System.Transactions.Transaction.TransactionTraceId.