public SafeTransaction(TransactionScopeOption scopeOption = TransactionScopeOption.RequiresNew)
{
if (Database.DefaultConnectionFactory is SqlCeConnectionFactory)
_transaction = null;
else
_transaction = new TransactionScope(scopeOption);
}
public InheritedSqlPersistenceEngine(
IConnectionFactory connectionFactory,
ISqlDialect dialect,
ISerialize serializer,
TransactionScopeOption scopeOption, int pageSize)
: base(connectionFactory, dialect, serializer, scopeOption, pageSize)
{}
public TransactionalOperationAttribute(TransactionScopeOption option)
: base(false)
{
this.Option = option;
this.IsolationLevel = DefaultIsolationLevel;
this.TimeoutMs = DefaultTimeoutMs;
}
//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*/);
}
private SqlPersistenceFactory(ISerialize serializer, TransactionScopeOption scopeOption, int pageSize)
{
this.serializer = serializer;
this.scopeOption = scopeOption;
this.PageSize = pageSize;
}
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();
}
private void Init(TransactionScopeOption option, IsolationLevel isolationLevel)
{
_scope = new TransactionScope(option, new TransactionOptions()
{
IsolationLevel = isolationLevel
});
}
public static TransactionScope CreateTransactionScopeWithNoLock(TransactionScopeOption option)
{
TransactionOptions options = new TransactionOptions();
options.IsolationLevel = IsolationLevel.ReadUncommitted;
return new TransactionScope(option, options);
}
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 )"
);
}
}
private SqlPersistenceFactory(ISerialize serializer, TransactionScopeOption scopeOption, IStreamIdHasher streamIdHasher, int pageSize)
{
_serializer = serializer;
_scopeOption = scopeOption;
_streamIdHasher = streamIdHasher ?? new Sha1StreamIdHasher();
PageSize = pageSize;
}
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 TransactionScope (TransactionScopeOption scopeOption,
TransactionOptions options,
DTCOption opt)
{
Initialize (scopeOption, null, options, opt,
TransactionManager.DefaultTimeout);
}
public TransactionAttribute(TransactionScopeOption mode, IsolationLevel isolationLevel)
{
Timeout = TimeSpan.MaxValue;
Mode = mode;
IsolationLevel = isolationLevel;
_CustomContext = new Dictionary<string, object>();
}
public static TransactionScope StartTransaction(this IMessageContext messageContext,
TransactionScopeOption option = TransactionScopeOption.Required)
{
var scope = new TransactionScope(option);
messageContext.EnlistInCurrentTransaction();
return scope;
}
public SafeTransaction(TransactionScopeOption scopeOption, IsolationLevel isolationLevel)
{
if (Database.DefaultConnectionFactory is SqlCeConnectionFactory)
_transaction = null;
else
_transaction = new TransactionScope(scopeOption,
new TransactionOptions { IsolationLevel = isolationLevel });
}
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 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 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>
/// 새로운 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);
}
/// <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;
}
public static TransactionScope Begin(TransactionScopeOption scopeOption, IsolationLevel isolationLevel)
{
var transactionOptions = new TransactionOptions
{
IsolationLevel = isolationLevel,
Timeout = Timeout
};
return new TransactionScope(scopeOption, transactionOptions);
}
public TransactionScopeDeliveryHandler(
IDeliveryHandler inner, TransactionScopeOption scopeOption, TransactionOptions transactionOptions)
{
if (inner == null)
throw new ArgumentNullException("inner");
this.inner = inner;
this.scopeOption = scopeOption;
this.transactionOptions = transactionOptions;
}
public static TransactionScope Begin(TransactionScopeOption scopeOption, TimeSpan timeOut)
{
var transactionOptions = new TransactionOptions
{
IsolationLevel = IsolationLevel.ReadCommitted,
Timeout = timeOut
};
return new TransactionScope(scopeOption, transactionOptions);
}
public static TransactionScope Begin(TransactionScopeOption scopeOption)
{
var transactionOptions = new TransactionOptions
{
IsolationLevel = IsolationLevel.ReadCommitted,
Timeout = TransactionManager.MaximumTimeout
};
return new TransactionScope(scopeOption, transactionOptions);
}
public FirebirdSqlPersistenceFactory(IConnectionFactory factory, ISerialize serializer, IContribSqlDialect dialect, IContribStreamIdHasher streamIdHasher = null, TransactionScopeOption scopeOption = TransactionScopeOption.Suppress, int pageSize = DefaultPageSize)
{
this._connectionFactory = factory;
this._dialect = dialect;
this._transactionScopeOption = scopeOption;
this._serializer = serializer;
this._scopeOption = scopeOption;
this._streamIdHasher = streamIdHasher ?? new StreamIdHasher<SHA1>();
this._pagesize = pageSize;
}
public RavenPersistenceFactory(
string connectionName,
IDocumentSerializer serializer,
TransactionScopeOption scopeOption,
bool consistentQueries)
{
this.ConnectionStringName = connectionName;
this.serializer = serializer;
this.scopeOption = scopeOption;
this.consistentQueries = consistentQueries;
}
public RavenPersistenceOptions(
int pageSize = DefaultPageSize,
bool consistentQueries = DefaultConsistentQueries,
TransactionScopeOption scopeOption = DefaultScopeOption,
string databaseName = DefaultDatabaseName)
{
_pageSize = (pageSize > MaxServerPageSize) ? MaxServerPageSize : pageSize;
_databaseName = databaseName;
_consistentQueries = consistentQueries;
_scopeOption = scopeOption;
}
/// <summary>
/// Initializes a new instance of the <see cref="TransactionScopeCallHandler"/> class.
/// Creates a new <see cref="TransactionScopeCallHandler"/>.
/// </summary>
/// <param name="transactionScopeOption">
/// An instance of the TransactionScopeOption enumeration that describes the transaction requirements associated with this transaction scope.
/// </param>
/// <param name="transactionOptions">
/// A TransactionOptions structure that describes the transaction options to use if a new transaction is created. If an existing transaction is used, the timeout value in this parameter applies to the transaction scope. If that time expires before the scope is disposed, the transaction is aborted.
/// </param>
/// <param name="interopOption">
/// An instance of the EnterpriseServicesInteropOption enumeration that describes how the associated transaction interacts with COM+ transactions.
/// </param>
/// <param name="complete">
/// Whether the Transaction should be completed when the next handler executed without exceptions.
/// </param>
public TransactionScopeCallHandler(
TransactionScopeOption transactionScopeOption,
TransactionOptions transactionOptions,
EnterpriseServicesInteropOption interopOption,
bool complete)
{
this.transactionScopeOption = transactionScopeOption;
this.transactionOptions = transactionOptions;
this.interopOption = interopOption;
this.complete = complete;
}
/// <summary>
/// 构造函数
/// 设置事务创建方式
/// </summary>
/// <param name="scopeOption">事务范围选项
/// 0：如果存在环境事务，则将事务添加到已有环境事务中，否则则创建新的事务；
/// 1：不管是否存在环境事务，每次都创建新的事务；
/// 2：如果存在环境事务，则不创建事务（非事务方式运行代码）</param>
public TransactionManager(TransactionScopeOption scopeOption)
{
scope = new TransactionScope(scopeOption);
}
private void NestedScopeInternalTest(
TransactionScopeOption nestedOption,
bool innerComplete,
bool outerComplete,
bool expectInnerChangesVisible,
bool expectOuterChangesVisible)
{
createTable("CREATE TABLE T(str varchar(10))", "INNODB");
try
{
using (TransactionScope outer = new TransactionScope())
{
string connStr = GetConnectionString(true);
using (MySqlConnection c1 = new MySqlConnection(connStr))
{
c1.Open();
MySqlCommand cmd1 = new MySqlCommand("INSERT INTO T VALUES ('outer')", c1);
cmd1.ExecuteNonQuery();
using (TransactionScope inner = new TransactionScope(nestedOption))
{
MySqlConnection c2;
if (nestedOption == TransactionScopeOption.Required)
{
// inner scope joins already running ambient
// transaction, we cannot use new connection here
c2 = c1;
}
else
{
// when TransactionScopeOption.RequiresNew or
// new TransactionScopeOption.Suppress is used,
// we have to use a new transaction. We create a
// new connection for it.
c2 = new MySqlConnection(connStr);
c2.Open();
}
MySqlCommand cmd2 =
new MySqlCommand("INSERT INTO T VALUES ('inner')", c2);
cmd2.ExecuteNonQuery();
if (innerComplete)
{
inner.Complete();
}
// Dispose connection if it was created.
if (c2 != c1)
{
c2.Dispose();
}
}
}
if (outerComplete)
{
outer.Complete();
}
}
bool innerChangesVisible =
((long)MySqlHelper.ExecuteScalar(conn, "select count(*) from T where str = 'inner'") == 1);
bool outerChangesVisible =
((long)MySqlHelper.ExecuteScalar(conn, "select count(*) from T where str = 'outer'") == 1);
Assert.AreEqual(innerChangesVisible, expectInnerChangesVisible);
Assert.AreEqual(outerChangesVisible, expectOuterChangesVisible);
}
finally
{
MySqlHelper.ExecuteNonQuery(conn, "DROP TABLE T");
}
}
public TranScopeCommandHandlerDecorator(ICommandHandler <TCommand> decorated, TransactionScopeOption opt = TransactionScopeOption.Required)
{
_decoratedHndl = decorated;
_opt = opt;
IsolationLevel = System.Transactions.IsolationLevel.ReadCommitted;
Timeout = TransactionManager.MaximumTimeout;
}
public TransactionScope(TransactionScopeOption option)
: this(option, TransactionManager.DefaultTimeout)
{
}
/// <summary>
/// См. <see cref="IDataContext.CreateScope(TransactionScopeOption)"/>.
/// </summary>
public ITransactionScope CreateScope(TransactionScopeOption scopeOption)
{
return(_context.CreateScope(scopeOption));
}
public IUnitOfWorkCompleteHandle Begin(TransactionScopeOption scope)
{
return(Begin(new UnitOfWorkOptions {
Scope = scope
}));
}
public abstract void Commit(IsolationLevel isolationLevel = IsolationLevel.ReadCommitted,
TransactionScopeOption scopeOption = TransactionScopeOption.Required);
public TransactionScope(
TransactionScopeOption scopeOption,
TransactionOptions transactionOptions,
EnterpriseServicesInteropOption interopOption)
{
TransactionsEtwProvider etwLog = TransactionsEtwProvider.Log;
if (etwLog.IsEnabled())
{
etwLog.MethodEnter(TraceSourceType.TraceSourceBase, this);
}
ValidateScopeTimeout("transactionOptions.Timeout", transactionOptions.Timeout);
TimeSpan scopeTimeout = transactionOptions.Timeout;
transactionOptions.Timeout = TransactionManager.ValidateTimeout(transactionOptions.Timeout);
TransactionManager.ValidateIsolationLevel(transactionOptions.IsolationLevel);
ValidateInteropOption(interopOption);
_interopModeSpecified = true;
_interopOption = interopOption;
if (NeedToCreateTransaction(scopeOption))
{
_committableTransaction = new CommittableTransaction(transactionOptions);
_expectedCurrent = _committableTransaction.Clone();
}
else
{
if (null != _expectedCurrent)
{
// If the requested IsolationLevel is stronger than that of the specified transaction, throw.
if ((IsolationLevel.Unspecified != transactionOptions.IsolationLevel) && (_expectedCurrent.IsolationLevel != transactionOptions.IsolationLevel))
{
throw new ArgumentException(SR.TransactionScopeIsolationLevelDifferentFromTransaction, nameof(transactionOptions));
}
}
}
if ((null != _expectedCurrent) && (null == _committableTransaction) && (TimeSpan.Zero != scopeTimeout))
{
// BUGBUG: Scopes should use a shared timer
_scopeTimer = new Timer(
TimerCallback,
this,
scopeTimeout,
TimeSpan.Zero);
}
if (null == _expectedCurrent)
{
if (etwLog.IsEnabled())
{
etwLog.TransactionScopeCreated(TransactionTraceIdentifier.Empty, TransactionScopeResult.NoTransaction);
}
}
else
{
TransactionScopeResult scopeResult;
if (null == _committableTransaction)
{
scopeResult = TransactionScopeResult.UsingExistingCurrent;
}
else
{
scopeResult = TransactionScopeResult.CreatedTransaction;
}
if (etwLog.IsEnabled())
{
etwLog.TransactionScopeCreated(_expectedCurrent.TransactionTraceId, scopeResult);
}
}
PushScope();
if (etwLog.IsEnabled())
{
etwLog.MethodExit(TraceSourceType.TraceSourceBase, this);
}
}
/// <summary>
/// Cria escopos de transações.
/// </summary>
/// <param name="scopeOption">TransactionScopeOption</param>
/// <param name="timeOut">int</param>
/// <returns>TransactionScope</returns>
public static TransactionScope ObterEscopo(TransactionScopeOption scopeOption, int timeOut)
{
return(new TransactionScope(scopeOption, TimeSpan.FromSeconds(timeOut), TransactionScopeAsyncFlowOption.Enabled));
}
public TransactionScope(TransactionScopeOption scopeOption,
TransactionOptions options)
: this(scopeOption, options, DTCOption.None)
{
}
/// <summary>
/// См. <see cref="IDataContext.CreateScope(TransactionScopeOption, TransactionOptions)"/>.
/// </summary>
public ITransactionScope CreateScope(TransactionScopeOption scopeOption, TransactionOptions transactionOptions)
{
return(_context.CreateScope(scopeOption, transactionOptions));
}
/// <summary>
/// См. <see cref="IDataContext.CreateScope(TransactionScopeOption, TimeSpan)"/>.
/// </summary>
public ITransactionScope CreateScope(TransactionScopeOption scopeOption, TimeSpan scopeTimeout)
{
return(_context.CreateScope(scopeOption, scopeTimeout));
}
public static TransactionScope CreateReadCommitted(TransactionScopeOption transactionScopeOption = TransactionScopeOption.Required, TimeSpan?timeout = null)
{
return(CreateReadCommitted(transactionScopeOption, timeout, TransactionScopeAsyncFlowOption.Enabled));
}
/// <summary>
/// 构造函数
/// 设置事务创建方式和超时
/// TransactionScopeOption,使用默认值Required（该范围需要一个事务。如果已经存在环境事务，则使用该环境事务。否则，在进入范围之前创建新的事务。）
/// </summary>
/// <param name="scopeTimeout">设置超时时间 格式new TimeSpan(0, 0, 10)</param>
/// <param name="scopeOption">事务范围选项 默认参数</param>
public TransactionManager(TimeSpan scopeTimeout,
TransactionScopeOption scopeOption = TransactionScopeOption.Required)
{
scope = new TransactionScope(scopeOption, scopeTimeout);
}
/// <summary>
/// 创建<see cref="UnitOfWorkAttribute"/>对象。
/// </summary>
public UnitOfWorkAttribute()
{
IsTransactional = true;
TransactionScopeOption = TransactionScopeOption.Required;
}
/// <summary>
/// 构造函数
/// 设置事务创建方式和事务的超时，隔离级别等信息
/// </summary>
/// <param name="transOptions">TransactionOptions对象里设置事务的隔离级别和超时信息</param>
/// <param name="scopeOption">事务范围选项 默认参数</param>
public TransactionManager(TransactionOptions transOptions,
TransactionScopeOption scopeOption = TransactionScopeOption.Required)
{
scope = new TransactionScope(scopeOption, transOptions);
}
public TransactionScope(TransactionScopeOption option,
TimeSpan timeout)
{
Initialize(option, null, defaultOptions,
DTCOption.None, timeout);
}
/// <summary>
/// Checks that cache operation behaves transactionally.
/// </summary>
private void CheckTxOp(Action <ICache <int, int>, int> act)
{
var isolationLevels = new[]
{
IsolationLevel.Serializable, IsolationLevel.RepeatableRead, IsolationLevel.ReadCommitted,
IsolationLevel.ReadUncommitted, IsolationLevel.Snapshot, IsolationLevel.Chaos
};
foreach (var isolationLevel in isolationLevels)
{
var txOpts = new TransactionOptions {
IsolationLevel = isolationLevel
};
const TransactionScopeOption scope = TransactionScopeOption.Required;
var cache = Cache();
cache[1] = 1;
cache[2] = 2;
// Rollback.
using (new TransactionScope(scope, txOpts))
{
act(cache, 1);
Assert.IsNotNull(cache.Ignite.GetTransactions().Tx, "Transaction has not started.");
}
Assert.AreEqual(1, cache[1]);
Assert.AreEqual(2, cache[2]);
using (new TransactionScope(scope, txOpts))
{
act(cache, 1);
act(cache, 2);
}
Assert.AreEqual(1, cache[1]);
Assert.AreEqual(2, cache[2]);
// Commit.
using (var ts = new TransactionScope(scope, txOpts))
{
act(cache, 1);
ts.Complete();
}
Assert.IsTrue(!cache.ContainsKey(1) || cache[1] != 1);
Assert.AreEqual(2, cache[2]);
using (var ts = new TransactionScope(scope, txOpts))
{
act(cache, 1);
act(cache, 2);
ts.Complete();
}
Assert.IsTrue(!cache.ContainsKey(1) || cache[1] != 1);
Assert.IsTrue(!cache.ContainsKey(2) || cache[2] != 2);
}
}
public Task CommitAsync(IsolationLevel isolationLevel = IsolationLevel.ReadCommitted,
TransactionScopeOption scopeOption = TransactionScopeOption.Required)
{
return(CommitAsync(CancellationToken.None, isolationLevel, scopeOption));
}
public LocalTransactionScope(TransactionScopeOption scopeOption) : this(scopeOption, new TransactionOptions {
IsolationLevel = Transaction.Current != null ? Transaction.Current.IsolationLevel : IsolationLevel.ReadCommitted
})
{
}
public static TransactionScope CreateTransactionScope(TransactionScopeOption scopeOption) => CreateTransactionScope(scopeOption, defaultTransactionOptions);
public LocalTransactionScope(TransactionScopeOption scopeOption, TransactionOptions transactionOptions)
{
_transactionScope = new TransactionScope(scopeOption, transactionOptions, TransactionScopeAsyncFlowOption.Enabled);
_connectionScope = new DbConnectionScope(ToDbConnectionScopeOption(scopeOption));
}
private static TransactionScope CreateTransactionScope(TransactionScopeOption scopeOption, IsolationLevel isolationLevel, TimeSpan timeout)
{
return(new TransactionScope(scopeOption, new TransactionOptions {
IsolationLevel = isolationLevel, Timeout = timeout
}, TransactionScopeAsyncFlowOption.Enabled));
}
public TransactionScopeAspect(TransactionScopeOption option)
{
_option = option;
}
public TransactionScopeAspect(TransactionScopeOption transactionScopeOption)
{
_transactionScopeOption = transactionScopeOption;
}
public TransactionScope(TransactionScopeOption scopeOption, TimeSpan scopeTimeout)
: this(scopeOption, scopeTimeout, TransactionScopeAsyncFlowOption.Suppress)
{
}
public TransactionScope(
TransactionScopeOption scopeOption,
TimeSpan scopeTimeout,
TransactionScopeAsyncFlowOption asyncFlowOption
)
{
TransactionsEtwProvider etwLog = TransactionsEtwProvider.Log;
if (etwLog.IsEnabled())
{
etwLog.MethodEnter(TraceSourceType.TraceSourceBase, this);
}
ValidateScopeTimeout(nameof(scopeTimeout), scopeTimeout);
TimeSpan txTimeout = TransactionManager.ValidateTimeout(scopeTimeout);
ValidateAndSetAsyncFlowOption(asyncFlowOption);
if (NeedToCreateTransaction(scopeOption))
{
_committableTransaction = new CommittableTransaction(txTimeout);
_expectedCurrent = _committableTransaction.Clone();
}
if ((null != _expectedCurrent) && (null == _committableTransaction) && (TimeSpan.Zero != scopeTimeout))
{
// BUGBUG: Scopes should not use individual timers
_scopeTimer = new Timer(
TimerCallback,
this,
scopeTimeout,
TimeSpan.Zero);
}
if (null == _expectedCurrent)
{
if (etwLog.IsEnabled())
{
etwLog.TransactionScopeCreated(TransactionTraceIdentifier.Empty, TransactionScopeResult.NoTransaction);
}
}
else
{
TransactionScopeResult scopeResult;
if (null == _committableTransaction)
{
scopeResult = TransactionScopeResult.UsingExistingCurrent;
}
else
{
scopeResult = TransactionScopeResult.CreatedTransaction;
}
if (etwLog.IsEnabled())
{
etwLog.TransactionScopeCreated(_expectedCurrent.TransactionTraceId, scopeResult);
}
}
PushScope();
if (etwLog.IsEnabled())
{
etwLog.MethodExit(TraceSourceType.TraceSourceBase, this);
}
}
public TransactionScope(TransactionScopeOption scopeOption)
: this(scopeOption, TransactionScopeAsyncFlowOption.Suppress)
{
}
/// <summary>
/// См. <see cref="IDataContext.CreateScope(TransactionScopeOption, TransactionOptions, EnterpriseServicesInteropOption)"/>.
/// </summary>
public ITransactionScope CreateScope(TransactionScopeOption scopeOption, TransactionOptions transactionOptions, EnterpriseServicesInteropOption interopOption)
{
return(_context.CreateScope(scopeOption, transactionOptions, interopOption));
}
public static TransactionScope CreateSerializable(TransactionScopeOption transactionScopeOption = TransactionScopeOption.Required, TimeSpan?timeout = null)
{
return(CreateSerializable(transactionScopeOption, timeout, TransactionScopeAsyncFlowOption.Enabled));
}
public SqlPersistenceFactory(
IConnectionFactory factory,
ISerialize serializer,
ISqlDialect dialect,
TransactionScopeOption scopeOption)
{
this.connectionFactory = factory;
this.serializer = serializer;
this.dialect = dialect;
this.scopeOption = scopeOption;
}
