Simple thread transactions in C#

/// <summary>
/// Transaction object used for batching up operations with a simple commit. There can only be one transaction
/// at a time, per thread. Support for atomic operations via Abort() and AbortWithException().
/// </summary>
internal sealed class CoreFastTransaction : IDisposable
{
        [ThreadStatic]
        private static CoreFastTransaction _currentThreadTransaction;

        private bool _isCompleted = false;
        private bool _isAborted   = false;

        private Exception _lastException;
        private readonly ThreadLocal<int> _createdThreadId = new ThreadLocal<int>();

        /// <summary>
        /// Fired when the transaction is successfully completed.
        /// </summary>
        internal event EventHandler OnCompleted;

        /// <summary>
        /// Gets the current transaction for the current thread.
        /// </summary>
        internal static CoreFastTransaction Current
        {
                get
                {
                        return _currentThreadTransaction;
                }
        }

        /// <summary>
        /// Gets whether the current thread has an in-progress transaction.
        /// </summary>
        internal static bool ThreadHasTransaction
        {
                get
                {
                        return ( Current != null );
                }
        }

        /// <summary>
        /// Gets the last exception that occurred for this transaction.
        /// </summary>
        internal Exception LastException
        {
                get
                {
                        return this._lastException;
                }
        }

        /// <summary>
        /// Gets whether this transaction is complete.
        /// </summary>
        internal bool IsCompleted
        {
                get
                {
                        return this._isCompleted;
                }
        }

        /// <summary>
        /// Gets whether this transaction is aborted (IsCompleted is also true).
        /// </summary>
        internal bool IsAborted
        {
                get
                {
                        return this._isAborted;
                }
        }

        /// <summary>
        /// 
        /// </summary>
        private CoreFastTransaction()
        { }

        /// <summary>
        /// Factory
        /// </summary>
        /// <returns></returns>
        internal static CoreFastTransaction Create()
        {
                if ( _currentThreadTransaction != null && !_currentThreadTransaction.IsCompleted )
                {
                        throw new InvalidOperationException( "Complete the transaction on the current thread before starting a new one." );
                }

                _currentThreadTransaction = new CoreFastTransaction();
                _currentThreadTransaction._createdThreadId.Value = Thread.CurrentThread.ManagedThreadId;

                return _currentThreadTransaction;
        }

        /// <summary>
        /// Aborts the transaction, supplying an exception.
        /// </summary>
        /// <param name="exception"></param>
        internal void AbortWithException( Exception exception )
        {
                this._VerifyThreadConcurrency();

                if ( exception != null )
                {
                        this._lastException = exception;
                        this.Abort();
                }
        }

        /// <summary>
        /// Aborts the transaction.
        /// </summary>
        internal void Abort()
        {
                this._VerifyThreadConcurrency();

                this._isAborted = true;
                this._isCompleted = true;
        }

        /// <summary>
        /// Completes the transaction (success).
        /// </summary>
        internal void Complete()
        {
                this._VerifyThreadConcurrency();

                if ( !this._isAborted && !this._isCompleted )
                {
                        if ( this.OnCompleted != null )
                        {
                                this.OnCompleted( this, EventArgs.Empty );
                        }

                        this._isCompleted = true;
                }
        }

        /// <summary>
        /// 
        /// </summary>
        private void _VerifyThreadConcurrency()
        {
                if ( !this._createdThreadId.IsValueCreated ||
                        this._createdThreadId.Value != Thread.CurrentThread.ManagedThreadId )
                {
                        throw new InvalidOperationException( "Cannot perform transaction operation on a different thread than it was created on." );
                }
        }

        /// <summary>
        /// 
        /// </summary>
        ~CoreFastTransaction()
        {
                this.Dispose( true );
        }

        #region IDisposable Members
        /// <summary>
        /// 
        /// </summary>
        void IDisposable.Dispose()
        {
                this.Complete();
                this.Dispose( true );

                GC.SuppressFinalize( this );
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="fDisposing"></param>
        private void Dispose( bool fDisposing )
        {
                if ( fDisposing )
                {
                        if ( this._createdThreadId != null )
                        {
                                this._createdThreadId.Dispose();
                        }
                }
        }
        #endregion
}