NH-2176 naming fix, clean up.

Author: fredericDelaporte

src/NHibernate/Transaction/AdoNetWithSystemTransactionFactory.cs

@@ -33,7 +33,7 @@ public void EnlistInSystemTransactionIfNeeded(ISessionImplementor session)
 			// Ensure the session does not run on a thread supposed to be blocked, waiting
 			// for transaction completion.
 			session.TransactionContext?.WaitOne();
-			
+
 			var transaction = System.Transactions.Transaction.Current;
 			// We may have defined the transaction context before having the connection, do not
 			// move under test on TransactionContext already defined. Otherwise we would rely on
@@ -49,11 +49,11 @@ public void EnlistInSystemTransactionIfNeeded(ISessionImplementor session)
 			session.TransactionContext = transactionContext;
 			_logger.DebugFormat(
 				"enlisted into DTC transaction: {0}",
-				transactionContext.AmbientTransation.IsolationLevel);
+				transactionContext.AmbientTransaction.IsolationLevel);
 			session.AfterTransactionBegin(null);
 
-			transactionContext.AmbientTransation.TransactionCompleted += transactionContext.TransactionCompleted;
-			transactionContext.AmbientTransation.EnlistVolatile(
+			transactionContext.AmbientTransaction.TransactionCompleted += transactionContext.TransactionCompleted;
+			transactionContext.AmbientTransaction.EnlistVolatile(
 				transactionContext,
 				EnlistmentOptions.EnlistDuringPrepareRequired);
 		}
@@ -74,30 +74,30 @@ public void ExecuteWorkInIsolation(ISessionImplementor session, IIsolatedWork wo
 
 		public class SystemTransactionContext : ITransactionContext, IEnlistmentNotification
 		{
-			internal System.Transactions.Transaction AmbientTransation { get; private set; }
+			internal System.Transactions.Transaction AmbientTransaction { get; private set; }
 			public bool ShouldCloseSessionOnSystemTransactionCompleted { get; set; }
 			public bool IsInActiveTransaction { get; internal set; }
 
 			private readonly ISessionImplementor _sessionImplementor;
 			private readonly ManualResetEvent _waitEvent = new ManualResetEvent(true);
 			private volatile bool _locked;
 			private readonly AsyncLocal<bool> _bypassWait = new AsyncLocal<bool>();
-			private bool IsDistributed => AmbientTransation.TransactionInformation.DistributedIdentifier != Guid.Empty;
+			private bool IsDistributed => AmbientTransaction.TransactionInformation.DistributedIdentifier != Guid.Empty;
 
 			public SystemTransactionContext(
 				ISessionImplementor sessionImplementor,
 				System.Transactions.Transaction transaction)
 			{
 				_sessionImplementor = sessionImplementor;
-				AmbientTransation = transaction.Clone();
+				AmbientTransaction = transaction.Clone();
 				IsInActiveTransaction = true;
 			}
 
 			public void WaitOne()
 			{
 				if (_bypassWait.Value || _isDisposed)
 					return;
-				if (!_locked && AmbientTransation.TransactionInformation.Status != TransactionStatus.Active)
+				if (!_locked && AmbientTransaction.TransactionInformation.Status != TransactionStatus.Active)
 					// Rollback case may end the transaction without a prepare phase, apply the lock.
 					SafeLockSession();
 				try
@@ -157,7 +157,7 @@ void IEnlistmentNotification.Prepare(PreparingEnlistment preparingEnlistment)
 				{
 					try
 					{
-						using (var tx = new TransactionScope(AmbientTransation))
+						using (var tx = new TransactionScope(AmbientTransaction))
 						{
 							if (_sessionImplementor.FlushMode != FlushMode.Manual && _sessionImplementor.ConnectionManager.IsConnected)
 							{
@@ -197,9 +197,6 @@ void IEnlistmentNotification.InDoubt(Enlistment enlistment)
 
 			private void ProcessSecondPhase(Enlistment enlistment, bool? success)
 			{
-				// In case of rollback, the prepare phase may have not be run, and we then need to lock as soon as possible.
-				// There is no guarantee the second phase will be run before the completed event, doing that at both places.
-				SafeLockSession();
 				using (new SessionIdLoggingContext(_sessionImplementor.SessionId))
 				{
 					_logger.Debug(
@@ -225,9 +222,6 @@ private void ProcessSecondPhase(Enlistment enlistment, bool? success)
 
 			public void TransactionCompleted(object sender, TransactionEventArgs e)
 			{
-				// In case of rollback, the prepare phase may have not be run, and we then need to lock as soon as possible.
-				// There is no guarantee the second phase will be run before the completed event, doing that at both places.
-				SafeLockSession();
 				e.Transaction.TransactionCompleted -= TransactionCompleted;
 				// This event may execute before second phase, so we cannot try to get the success from second phase.
 				// Using this event is required by example in case the prepare phase failed and called force rollback:
@@ -237,7 +231,7 @@ public void TransactionCompleted(object sender, TransactionEventArgs e)
 				try
 				{
 					wasSuccessful =
-						e.Transaction.TransactionInformation.Status == TransactionStatus.Committed;
+						AmbientTransaction.TransactionInformation.Status == TransactionStatus.Committed;
 				}
 				catch (ObjectDisposedException ode)
 				{
@@ -253,6 +247,7 @@ private void RunAfterTransactionActions(bool wasSuccessful)
 				if (_afterTransactionActionsDone)
 					// Probably called from In-Doubt and TransactionCompleted.
 					return;
+				_afterTransactionActionsDone = true;
 				// Allow transaction completed actions to run while others stay blocked.
 				_bypassWait.Value = true;
 				try
@@ -272,7 +267,6 @@ private void RunAfterTransactionActions(bool wasSuccessful)
 				}
 				finally
 				{
-					_afterTransactionActionsDone = true;
 					// Dispose releases blocked threads by the way.
 					// Must dispose in case !ShouldCloseSessionOnSystemTransactionCompleted, since
 					// we nullify session TransactionContext, causing it to have nothing still holding it.
@@ -296,11 +290,8 @@ protected virtual void Dispose(bool disposing)
 			{
 				if (disposing)
 				{
-					if (AmbientTransation != null)
-					{
-						AmbientTransation.Dispose();
-						AmbientTransation = null;
-					}
+					AmbientTransaction?.Dispose();
+					AmbientTransaction = null;
 					_waitEvent.Set();
 					_waitEvent.Dispose();
 				}