internal SuspendedTransaction(TransactionHandleRegistry outerInstance, ActiveTransaction activeMarker, TransactionHandle transactionHandle)
{
this._outerInstance = outerInstance;
this.ActiveMarker = activeMarker;
this.TransactionHandle = transactionHandle;
this.LastActiveTimestampConflict = outerInstance.clock.millis();
}
/// <summary>
/// Rollbacks the transaction.
/// </summary>
private static void RollbackTransaction()
{
ActiveTransaction.Rollback();
ActiveTransaction.Dispose();
ActiveTransaction = null;
TransactionCounter = 0;
}
/// <summary>
/// Rollback active transaction
/// </summary>
private static void RolebackTransaction()
{
try {
ActiveTransaction.Rollback();
if (log.IsWarnEnabled)
{
log.Warn("활성화된 Transaction을 Rollback 했습니다.");
}
}
catch (Exception ex) {
if (log.IsErrorEnabled)
{
log.Error("Transaction Rollback에 실패했습니다.");
log.Error(ex);
}
}
finally {
if (ActiveTransaction != null)
{
ActiveTransaction.Dispose();
ActiveTransaction = null;
}
TransactionCount = 0;
}
}
public void BeginTransaction()
{
_call++;
if (ActiveTransaction == null)
{
var connection = GetConnection();
ActiveTransaction = new ActiveTransaction(connection);
}
}
public void Rollback()
{
if (ActiveTransaction == null)
{
throw new InvalidOperationException("No transaction started.");
}
ActiveTransaction.Rollback();
ActiveTransaction = null;
_call = 0;
}
/// <summary>
/// Commits the transaction.
/// </summary>
private static void CommitTransaction()
{
TransactionCounter--;
if (TransactionCounter == 0 && ActiveTransaction != null)
{
ActiveTransaction.Commit();
ActiveTransaction.Dispose();
ActiveTransaction = null;
}
}
/// <summary>
/// Commits the current transaction.
/// </summary>
public virtual void Commit()
{
EnsureTransactionIsActive();
try {
ActiveTransaction.Commit();
}
finally {
ActiveTransaction.Dispose();
ClearActiveTransaction();
}
}
/// <summary>
/// Rollbacks the current transaction.
/// </summary>
public virtual void Rollback()
{
EnsureTransactionIsActive();
try {
ActiveTransaction.Rollback();
}
finally {
ActiveTransaction.Dispose();
ClearActiveTransaction();
}
}
protected virtual void Dispose(bool disposing)
{
if (!_disposed)
{
if (disposing)
{
ActiveConnection.Dispose();
ActiveTransaction?.Dispose();
}
}
_disposed = true;
}
public void Commit()
{
if (ActiveTransaction == null)
{
throw new InvalidOperationException("No transaction started.");
}
if (_call == 1)
{
ActiveTransaction.Commit();
ActiveTransaction = null;
}
_call--;
}
/// <summary>
/// ADO.NET의 기본 Transaction을 시작한다. (TransactionScope와는 달리 DTC를 이용하지 않는다.)
/// </summary>
/// <param name="isolationLevel">Transaction 격리수준 (기본적으로 ReadCommitted)</param>
/// <returns>Return a new instance of DbTransaction</returns>
/// <example>
/// <code>
/// AdoRepository.BeginTransaction(IsolationLevel.ReadUncommitted);
/// try
/// {
/// DbCommand insertCommand = AdoRepository.GetSqlStringCommand(InsertString);
/// DbCommand deleteCommand = AdoRepository.GetSqlStringCommand(DeleteString);
/// DbCommand countCommand = AdoRepository.GetSqlStringCommand(CountString);
///
/// var count = Convert.ToInt32(AdoRepository.ExecuteScalar(countCommand));
///
/// AdoRepository.ExecuteNonQuery(insertCommand);
/// AdoRepository.ExecuteNonQuery(deleteCommand);
///
/// AdoRepository.Commit();
///
/// Assert.AreEqual(4, count);
/// }
/// catch (Exception ex)
/// {
/// if (IsErrorEnabled)
/// log.ErrorException(ex);
///
/// AdoRepository.Rollback();
///
/// throw;
/// }
/// </code>
/// </example>
public virtual DbTransaction BeginTransaction(System.Data.IsolationLevel isolationLevel)
{
var connection = AdoTool.CreateTransactionScopeConnection(Db);
ActiveTransaction = connection.BeginTransaction(isolationLevel);
if (IsDebugEnabled)
{
log.Debug("Database=[{0}]에 새로운 Transaction을 시작했습니다. Transaction=[{1}]",
connection.Database, ActiveTransaction.GetType().FullName);
}
return(ActiveTransaction);
}
/// <inheritdoc/>
public void Dispose()
{
if (isDisposed)
{
return;
}
isDisposed = true;
if (ActiveTransaction != null)
{
ActiveTransaction.Dispose();
ClearActiveTransaction();
}
UnderlyingConnection.Dispose();
}
/// <summary>
/// Dispose active transaction
/// </summary>
private static void DisposeTransaction()
{
if (TransactionCount <= 0)
{
if (IsDebugEnabled)
{
log.Debug("활성 Transaction을 Dispose 합니다..");
}
if (ActiveTransaction != null)
{
ActiveTransaction.Dispose();
}
ActiveTransaction = null;
}
}
/// <summary>
/// Commit transaction
/// </summary>
private static void CommitTransaction()
{
TransactionCount--;
if (TransactionCount == 0 && ActiveTransaction != null)
{
ActiveTransaction.Commit();
ActiveTransaction.Dispose();
ActiveTransaction = null;
if (log.IsInfoEnabled)
{
log.Info("활성화된 Transaction을 Commit하고 Dispose했습니다.");
}
}
}
/// <summary>
/// 提交事务
/// </summary>
public void Commit()
{
if (wasOpenTransaction)
{
try
{
ActiveTransaction.Commit();
}
catch (Exception)
{
ActiveTransaction.Rollback();
throw;
}
finally
{
wasOpenTransaction = false;
}
}
}
/// <summary>
/// Closes the connection to the database. This is the preferred method of closing any open connection.
/// </summary>
public override void Close()
{
if (_state == ConnectionState.Closed)
{
return;
}
if (ActiveTransaction != null)
{
ActiveTransaction.Rollback();
}
ActiveTransaction = null;
_state = ConnectionState.Closed;
if (InnerConnection != null)
{
InnerConnection.StateChange -= WrappedConnection_StateChange;
InnerConnectionFactory.Instance.CloseConnection(_ConnectionString, InnerConnection);
}
InnerConnection = null;
OnStateChange(new StateChangeEventArgs(ConnectionState.Open, ConnectionState.Closed));
}
/// <summary>
/// 현재 활성화된 Transaction이 있다면, Commit을 수행한다.
/// </summary>
/// <exception cref="InvalidOperationException">Current Thread Context에 활성화된 Transaction이 없을 때</exception>
public virtual void Commit()
{
if (IsActiveTransaction == false)
{
if (IsDebugEnabled)
{
log.Debug("활성화된 Transaction이 없으므로 반환합니다.");
}
return;
}
if (IsActiveTransaction)
{
try {
ActiveTransaction.Commit();
if (log.IsInfoEnabled)
{
log.Info("Transaction을 Commit 했습니다!!!");
}
}
catch (Exception ex) {
if (log.IsErrorEnabled)
{
log.ErrorException("Transaction Commit 작업이 실패했습니다.", ex);
}
throw;
}
finally {
if (IsActiveTransaction)
{
ActiveTransaction.Dispose();
ActiveTransaction = null;
}
}
}
}
/// <summary>
/// 현재 활성화된 Transaction이 있다면, Rollback을 수행한다.
/// </summary>
public virtual void Rollback()
{
// Guard.Assert(ActiveTransaction != null, "Active transaction is null.");
if (IsActiveTransaction == false)
{
if (IsDebugEnabled)
{
log.Debug("ActiveTransaction이 없습니다. Rollback을 수행하지 않습니다.");
}
return;
}
try {
ActiveTransaction.Rollback();
if (log.IsInfoEnabled)
{
log.Info("Transaction을 Rollback 했습니다.");
}
}
catch (Exception ex) {
if (log.IsErrorEnabled)
{
log.ErrorException("Transaction Rollback 작업이 실패했습니다.", ex);
}
throw;
}
finally {
if (IsActiveTransaction)
{
ActiveTransaction.Dispose();
ActiveTransaction = null;
}
}
}
public void Complete()
{
PublishDomainEvents(DomainEvents);
DomainEvents.Clear();
ActiveTransaction?.Commit();
}
public IDbTransaction GetTransaction() => ActiveTransaction?.GetTransaction();
