Clean up code.

Author: hazzik

src/NHibernate.Test/NHSpecificTest/NH2420/Fixture.cs

@@ -90,7 +90,7 @@ public void ShouldBeAbleToReleaseSuppliedConnectionAfterDistributedTransaction()
 			// fires *after* the transaction is committed and so it doesn't affect the success
 			// of the transaction.
 
-			Assert.That(s.IsConnected, Is.False);
+		    Assert.That(() => s.IsConnected, Is.False.After(500, 100));
 			Assert.That(((ISessionImplementor)s).ConnectionManager.IsConnected, Is.False);
 			Assert.That(((ISessionImplementor)s).IsClosed, Is.True);
 		}

src/NHibernate/Impl/AbstractSessionImpl.cs

@@ -330,7 +330,6 @@ protected internal void SetClosed()
 			{
 				if (TransactionContext != null)
 					TransactionContext.Dispose();
-				TransactionContext = null;
 			}
 			catch (Exception)
 			{

src/NHibernate/Transaction/AdoNetWithDistributedTransactionFactory.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections;
+using System.Threading;
 using System.Transactions;
 using NHibernate.Engine;
 using NHibernate.Engine.Transaction;
@@ -29,54 +30,14 @@ public void EnlistInDistributedTransactionIfNeeded(ISessionImplementor session)
 
 			if (System.Transactions.Transaction.Current == null)
 				return;
-			
-			var transactionContext = new DistributedTransactionContext(session,
-																	   System.Transactions.Transaction.Current);
-			session.TransactionContext = transactionContext;
-			logger.DebugFormat("enlisted into DTC transaction: {0}",
-							   transactionContext.AmbientTransation.IsolationLevel);
-			session.AfterTransactionBegin(null);
-
-			TransactionCompletedEventHandler handler = null;
-
-			handler = delegate(object sender, TransactionEventArgs e)
-				{
-					using (new SessionIdLoggingContext(session.SessionId))
-					{
-						((DistributedTransactionContext) session.TransactionContext).IsInActiveTransaction = false;
-
-						bool wasSuccessful = false;
-						try
-						{
-							wasSuccessful = e.Transaction.TransactionInformation.Status
-											== TransactionStatus.Committed;
-						}
-						catch (ObjectDisposedException ode)
-						{
-							logger.Warn("Completed transaction was disposed, assuming transaction rollback", ode);
-						}
-						session.AfterTransactionCompletion(wasSuccessful, null);
-						if (transactionContext.ShouldCloseSessionOnDistributedTransactionCompleted)
-						{
-							session.CloseSessionFromDistributedTransaction();
-						}
-						session.TransactionContext = null;
-					}
-
-					e.Transaction.TransactionCompleted -= handler;
-				};
 
-			transactionContext.AmbientTransation.TransactionCompleted += handler;
-
-			transactionContext.AmbientTransation.EnlistVolatile(transactionContext,
-																EnlistmentOptions.EnlistDuringPrepareRequired);
+			new DistributedTransactionContext(session, System.Transactions.Transaction.Current);
 		}
 
 		public bool IsInDistributedActiveTransaction(ISessionImplementor session)
 		{
-			var distributedTransactionContext = ((DistributedTransactionContext)session.TransactionContext);
-			return distributedTransactionContext != null &&
-				   distributedTransactionContext.IsInActiveTransaction;
+			var distributedTransactionContext = (DistributedTransactionContext)session.TransactionContext;
+		    return distributedTransactionContext != null;
 		}
 
 		public void ExecuteWorkInIsolation(ISessionImplementor session, IIsolatedWork work, bool transacted)
@@ -92,35 +53,37 @@ public void ExecuteWorkInIsolation(ISessionImplementor session, IIsolatedWork wo
 
 		public class DistributedTransactionContext : ITransactionContext, IEnlistmentNotification
 		{
-			public System.Transactions.Transaction AmbientTransation { get; set; }
-			public bool ShouldCloseSessionOnDistributedTransactionCompleted { get; set; }
-			private ISessionImplementor sessionImplementor;
-			public bool IsInActiveTransaction;
+		    public bool ShouldCloseSessionOnDistributedTransactionCompleted { get; set; }
+
+		    System.Transactions.Transaction _transaction;
+		    ISessionImplementor _session;
 
-			public DistributedTransactionContext(ISessionImplementor sessionImplementor, System.Transactions.Transaction transaction)
+		    public DistributedTransactionContext(ISessionImplementor session, System.Transactions.Transaction transaction)
 			{
-				this.sessionImplementor = sessionImplementor;
-				AmbientTransation = transaction.Clone();
-				IsInActiveTransaction = true;
+                _session = session;
+			    _session.TransactionContext = this;
+				_transaction = transaction.Clone();
+				logger.DebugFormat("enlisted into DTC transaction: {0}",
+								   _transaction.IsolationLevel);
+				_session.AfterTransactionBegin(null);
+				_transaction.EnlistVolatile(this, EnlistmentOptions.EnlistDuringPrepareRequired);
 			}
 
-			#region IEnlistmentNotification Members
-
 			void IEnlistmentNotification.Prepare(PreparingEnlistment preparingEnlistment)
 			{
-				using (new SessionIdLoggingContext(sessionImplementor.SessionId))
+				using (new SessionIdLoggingContext(_session.SessionId))
 				{
 					try
 					{
-						using (var tx = new TransactionScope(AmbientTransation))
+						using (var tx = new TransactionScope(_transaction))
 						{
-							sessionImplementor.BeforeTransactionCompletion(null);
-							if (sessionImplementor.FlushMode != FlushMode.Never && sessionImplementor.ConnectionManager.IsConnected)
+							_session.BeforeTransactionCompletion(null);
+							if (_session.FlushMode != FlushMode.Never && _session.ConnectionManager.IsConnected)
 							{
-								using (sessionImplementor.ConnectionManager.FlushingFromDtcTransaction)
+								using (_session.ConnectionManager.FlushingFromDtcTransaction)
 								{
-									logger.Debug(string.Format("[session-id={0}] Flushing from Dtc Transaction", sessionImplementor.SessionId));
-									sessionImplementor.Flush();
+									logger.Debug(String.Format("[session-id={0}] Flushing from Dtc Transaction", _session.SessionId));
+									_session.Flush();
 								}
 							}
 							logger.Debug("prepared for DTC transaction");
@@ -132,55 +95,65 @@ void IEnlistmentNotification.Prepare(PreparingEnlistment preparingEnlistment)
 					catch (Exception exception)
 					{
 						logger.Error("DTC transaction prepare phase failed", exception);
+						OnTransactionCompletion(false);
 						preparingEnlistment.ForceRollback(exception);
 					}
 				}
 			}
 
 			void IEnlistmentNotification.Commit(Enlistment enlistment)
 			{
-				using (new SessionIdLoggingContext(sessionImplementor.SessionId))
+				using (new SessionIdLoggingContext(_session.SessionId))
 				{
 					logger.Debug("committing DTC transaction");
-					// we have nothing to do here, since it is the actual
-					// DB connection that will commit the transaction
-					enlistment.Done();
-					IsInActiveTransaction = false;
+				    OnTransactionCompletion(true);
 				}
+				enlistment.Done();
 			}
 
 			void IEnlistmentNotification.Rollback(Enlistment enlistment)
 			{
-				using (new SessionIdLoggingContext(sessionImplementor.SessionId))
+				using (new SessionIdLoggingContext(_session.SessionId))
 				{
 					logger.Debug("rolled back DTC transaction");
-					// Currently AfterTransactionCompletion is called by the handler for the TransactionCompleted event.
-					//sessionImplementor.AfterTransactionCompletion(false, null);
-					enlistment.Done();
-					IsInActiveTransaction = false;
+					OnTransactionCompletion(false);
 				}
+				enlistment.Done();
 			}
 
 			void IEnlistmentNotification.InDoubt(Enlistment enlistment)
 			{
-				using (new SessionIdLoggingContext(sessionImplementor.SessionId))
+				using (new SessionIdLoggingContext(_session.SessionId))
 				{
-					sessionImplementor.AfterTransactionCompletion(false, null);
 					logger.Debug("DTC transaction is in doubt");
-					enlistment.Done();
-					IsInActiveTransaction = false;
+					OnTransactionCompletion(false);
 				}
+				enlistment.Done();
 			}
 
-			#endregion
-
 			public void Dispose()
 			{
-				if (AmbientTransation != null)
-					AmbientTransation.Dispose();
-				AmbientTransation = null;
-				sessionImplementor = null;
-			}
+				if (_transaction != null)
+					_transaction.Dispose();
+			    _transaction = null;
+			    if (_session != null)
+			        _session.TransactionContext = null;
+			    _session = null;
+            }
+
+            void OnTransactionCompletion(bool wasSuccessful)
+			{
+				using (new SessionIdLoggingContext(_session.SessionId))
+				{
+				    _session.TransactionContext = null;
+                    _session.AfterTransactionCompletion(wasSuccessful, null);
+				    if (ShouldCloseSessionOnDistributedTransactionCompleted)
+				    {
+				        _session.CloseSessionFromDistributedTransaction();
+				    }
+				    Dispose();
+				}
+            }
 		}
 	}
 }