public SafeTransaction(TransactionScopeOption scopeOption = TransactionScopeOption.RequiresNew)
 {
     if (Database.DefaultConnectionFactory is SqlCeConnectionFactory)
         _transaction = null;
     else
         _transaction = new TransactionScope(scopeOption);
 }

 public TransactionalOperationAttribute(TransactionScopeOption option)
     : base(false)
 {
     this.Option = option;
     this.IsolationLevel = DefaultIsolationLevel;
     this.TimeoutMs = DefaultTimeoutMs;
 }

        public TransactionScope(
            TransactionScopeOption scopeOption,
            TransactionScopeAsyncFlowOption asyncFlowOption
            )
        {
            if ( !TransactionManager._platformValidated ) TransactionManager.ValidatePlatform();

            if ( DiagnosticTrace.Verbose )
            {
                MethodEnteredTraceRecord.Trace( SR.GetString( SR.TraceSourceBase ),
                    "TransactionScope.ctor( TransactionScopeOption )"
                    );
            }

            ValidateAndSetAsyncFlowOption(asyncFlowOption);
            
            if ( NeedToCreateTransaction( scopeOption ) )
            {
                committableTransaction = new CommittableTransaction();
                expectedCurrent = committableTransaction.Clone();
            }

            if ( DiagnosticTrace.Information )
            {
                if ( null == expectedCurrent )
                {
                    TransactionScopeCreatedTraceRecord.Trace( SR.GetString( SR.TraceSourceBase ),
                        TransactionTraceIdentifier.Empty,
                        TransactionScopeResult.NoTransaction
                        );
                }
                else
                {
                    TransactionScopeResult scopeResult;

                    if ( null == committableTransaction )
                    {
                        scopeResult = TransactionScopeResult.UsingExistingCurrent;
                    }
                    else
                    {
                        scopeResult = TransactionScopeResult.CreatedTransaction;
                    }

                    TransactionScopeCreatedTraceRecord.Trace( SR.GetString( SR.TraceSourceBase ),
                        expectedCurrent.TransactionTraceId,
                        scopeResult
                        );
                }
            }

            PushScope();
            
            if ( DiagnosticTrace.Verbose )
            {
                MethodExitedTraceRecord.Trace( SR.GetString( SR.TraceSourceBase ),
                    "TransactionScope.ctor( TransactionScopeOption )"
                    );
            }
        }

		public TransactionAttribute(TransactionScopeOption mode, IsolationLevel isolationLevel)
		{
			Timeout = TimeSpan.MaxValue;
			Mode = mode;
			IsolationLevel = isolationLevel;
			_CustomContext = new Dictionary<string, object>();
		}

 public void Commit(TransactionScopeOption scopeOption, TransactionOptions transactionOptions)
 {
     using (TransactionScope scope = new TransactionScope(scopeOption, transactionOptions))
     {
         foreach (UnitOfWork.Operation operation2 in from o in this.operations
                                                     orderby o.ProcessDate
                                                     select o)
         {
             switch (operation2.Type)
             {
                 case UnitOfWork.OperationType.Insert:
                     operation2.Repository.PersistNewItem(operation2.Entity);
                     break;
                 case UnitOfWork.OperationType.Update:
                     operation2.Repository.PersistUpdatedItem(operation2.Entity);
                     break;
                 case UnitOfWork.OperationType.Delete:
                     operation2.Repository.PersistDeletedItem(operation2.Entity);
                     break;
             }
         }
         scope.Complete();
     }
     foreach (EntityBase entityBase in (from operation in this.operations
                                        select operation.Entity).OfType<EntityBase>())
     {
         entityBase.ClearChangedProperties();
     }
     this.Reset();
 }

 public InheritedSqlPersistenceEngine(
     IConnectionFactory connectionFactory,
     ISqlDialect dialect,
     ISerialize serializer,
     TransactionScopeOption scopeOption, int pageSize) 
     : base(connectionFactory, dialect, serializer, scopeOption, pageSize)
 {}

 private void Init(TransactionScopeOption option, IsolationLevel isolationLevel)
 {
     _scope = new TransactionScope(option, new TransactionOptions()
     {
         IsolationLevel = isolationLevel
     });
 }

 private SqlPersistenceFactory(ISerialize serializer, TransactionScopeOption scopeOption,  IStreamIdHasher streamIdHasher, int pageSize)
 {
     _serializer = serializer;
     _scopeOption = scopeOption;
     _streamIdHasher = streamIdHasher ?? new Sha1StreamIdHasher();
     PageSize = pageSize;
 }

        //TransactionScopeAsyncFlowOption transactionScopeAsyncFlowOption = TransactionScopeAsyncFlowOption.Suppress) // .NET 4.5.1 feature
        public static TransactionScope CreateRepeatableRead(
            TransactionScopeOption transactionScopeOption = TransactionScopeOption.Required,
            TimeSpan? timeout = null)
        {
            var transactionOptions = new TransactionOptions
            {
                IsolationLevel = IsolationLevel.RepeatableRead,
            };

            // Upgrade isolation level if necessary
            if (transactionScopeOption == TransactionScopeOption.Required)
            {
                var currentTransaction = Transaction.Current;
                if (currentTransaction != null && currentTransaction.IsolationLevel == IsolationLevel.Serializable)
                {
                    transactionOptions.IsolationLevel = currentTransaction.IsolationLevel;
                }
            }

            if (timeout.HasValue)
            {
                transactionOptions.Timeout = timeout.Value;
            }

            return new TransactionScope(transactionScopeOption, transactionOptions/*, transactionScopeAsyncFlowOption*/);
        }

        public FatQueueTransaction(
            IsolationLevel isolationLevel, 
            TimeSpan? timeout,
            Func<IDbConnection> connectionFactory,
            TransactionScopeOption transactionScopeOption = TransactionScopeOption.Required, 
            TransactionScopeAsyncFlowOption transactionScopeAsyncFlowOption = TransactionScopeAsyncFlowOption.Enabled)
        {
            _connectionFactory = connectionFactory;

            var transactionOptions = new TransactionOptions
            {
                IsolationLevel = isolationLevel,
            };

            if (timeout != null)
            {
                transactionOptions.Timeout = timeout.Value;
            }

            if (System.Transactions.Transaction.Current == null || transactionScopeOption == TransactionScopeOption.RequiresNew)
            {
                _transaction = new CommittableTransaction(transactionOptions);
                _transactionScope = new TransactionScope(_transaction, transactionScopeAsyncFlowOption);
            }
        }

 public static TransactionScope StartTransaction(this IMessageContext messageContext,
     TransactionScopeOption option = TransactionScopeOption.Required)
 {
     var scope = new TransactionScope(option);
     messageContext.EnlistInCurrentTransaction();
     return scope;
 }

        private SqlPersistenceFactory(ISerialize serializer, TransactionScopeOption scopeOption, int pageSize)
        {
            this.serializer = serializer;
            this.scopeOption = scopeOption;

            this.PageSize = pageSize;
        }

		public TransactionScope (TransactionScopeOption scopeOption,
			TransactionOptions options,
			DTCOption opt)
		{
			Initialize (scopeOption, null, options, opt,
				TransactionManager.DefaultTimeout);
		}

        public static TransactionScope CreateTransactionScopeWithNoLock(TransactionScopeOption option)
        {
            TransactionOptions options = new TransactionOptions();
            options.IsolationLevel = IsolationLevel.ReadUncommitted;

            return new TransactionScope(option, options);
        }

 public static TransactionScope Acquire(TransactionScopeOption scope,
     IsolationLevel isolationLevel, TimeSpan timeout,
     TransactionScopeAsyncFlowOption asyncFlowOption)
 {
     TransactionOptions options = new TransactionOptions {IsolationLevel = isolationLevel, Timeout = timeout};
     TransactionScope result = new TransactionScope(scope, options, asyncFlowOption);
     return result;
 }

 public static TransactionScope CreateTransactionScope(TransactionScopeOption scopeOpion, IsolationLevel level)
 {
     if (Transaction.Current != null)
     {
         level = Transaction.Current.IsolationLevel;
     }
     return new TransactionScope(scopeOpion, new TransactionOptions { IsolationLevel = level });
 }

 public CustomSqlPersistenceFactory(IConnectionFactory factory, ISerialize serializer, ISqlDialect dialect, TransactionScopeOption scopeOption, int pageSize) : base(factory, serializer, dialect, scopeOption, pageSize)
 {
     this.factory = factory;
     this.serializer = serializer;
     this.dialect = dialect;
     this.scopeOption = scopeOption;
     this.pageSize = pageSize;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="DbTransactionScope"/> class.
        /// </summary>
        /// <param name="scopeOption">
        ///     An instance of the System.Transactions.TransactionScopeOption enumeration
        ///     that describes the transaction requirements associated with this transaction
        ///     scope.
        /// </param>
        public DbTransactionScope(TransactionScopeOption scopeOption)
        {
            if (Log.Enabled) Log.Entry("DbTransactionScope", Transaction.Current);

            m_scope = new TransactionScope(scopeOption);
            Initialize();

            if (Log.Enabled) Log.Exit("DbTransactionScope", Transaction.Current);
        }

 public PostgreSqlDbTransaction(IsolationLevel isolationLevel, 
     TimeSpan? timeout, 
     Func<IDbConnection> connectionFactory, 
     TransactionScopeOption transactionScopeOption = TransactionScopeOption.Required, 
     TransactionScopeAsyncFlowOption transactionScopeAsyncFlowOption = TransactionScopeAsyncFlowOption.Enabled) : 
     base(isolationLevel, timeout, connectionFactory, transactionScopeOption, transactionScopeAsyncFlowOption)
 {
     _isolationLevel = isolationLevel;
 }

        /// <summary>
        /// 새로운 TransactionScope 를 생성한다.
        /// </summary>
        /// <param name="scopeOption">TransactionScopeOption 값</param>
        /// <param name="isolationLevel">Transaction 격리수준</param>
        /// <returns>Instance of new <see cref="System.Transactions.TransactionScope"/></returns>
        /// <example>
        /// <code>
        /// using(TransactionScope txScope = AdoTool.CreateTransactionScope(TransactionScopeOption.Required, System.Transactions.IsolationLevel.ReadCommitted))
        /// {
        ///		// database operations...
        /// 
        ///		txScope.Commit();
        /// }
        /// </code>
        /// </example>
        public static TransactionScope CreateTransactionScope(TransactionScopeOption scopeOption = TransactionScopeOption.Required,
                                                              IsolationLevel isolationLevel = IsolationLevel.ReadCommitted) {
            if(IsDebugEnabled)
                log.Debug("새로운 TransactionScope를 생성합니다... TransactionScopeOption=[{0}], IsolationLevel=[{1}]", scopeOption,
                          isolationLevel);

            var txOptions = new TransactionOptions { IsolationLevel = isolationLevel };
            return new TransactionScope(scopeOption, txOptions);
        }