Clean up a bit isolation work code

fredericDelaporte · fredericDelaporte · commit 8f45c08c231c · 2020-03-22T20:05:19.000+01:00
diff --git a/src/NHibernate/Async/Transaction/AdoNetTransactionFactory.cs b/src/NHibernate/Async/Transaction/AdoNetTransactionFactory.cs
@@ -16,7 +16,6 @@
 using NHibernate.Engine;
 using NHibernate.Engine.Transaction;
 using NHibernate.Exceptions;
-using NHibernate.Impl;
 
 namespace NHibernate.Transaction
 {
@@ -42,7 +41,6 @@ async Task InternalExecuteWorkInIsolationAsync()
 
 				DbConnection connection = null;
 				DbTransaction trans = null;
-				// bool wasAutoCommit = false;
 				try
 				{
 					// We make an exception for SQLite and use the session's connection,
@@ -54,20 +52,13 @@ async Task InternalExecuteWorkInIsolationAsync()
 					if (transacted)
 					{
 						trans = connection.BeginTransaction();
-						// TODO NH: a way to read the autocommit state is needed
-						//if (TransactionManager.GetAutoCommit(connection))
-						//{
-						//  wasAutoCommit = true;
-						//  TransactionManager.SetAutoCommit(connection, false);
-						//}
 					}
 
 					await (work.DoWorkAsync(connection, trans, cancellationToken)).ConfigureAwait(false);
 
 					if (transacted)
 					{
 						trans.Commit();
-						//TransactionManager.Commit(connection);
 					}
 				}
 				catch (Exception t)
@@ -83,46 +74,30 @@ async Task InternalExecuteWorkInIsolationAsync()
 						}
 						catch (Exception ignore)
 						{
-							isolaterLog.Debug(ignore, "Unable to rollback transaction");
+							_isolatorLog.Debug(ignore, "Unable to rollback transaction");
 						}
 
-						if (t is HibernateException)
-						{
-							throw;
-						}
-						else if (t is DbException)
-						{
-							throw ADOExceptionHelper.Convert(session.Factory.SQLExceptionConverter, t,
-						                                 "error performing isolated work");
-						}
-						else
-						{
-							throw new HibernateException("error performing isolated work", t);
-						}
+						switch (t)
+					{
+						case HibernateException _:
+								throw;
+						case DbException _:
+								throw ADOExceptionHelper.Convert(session.Factory.SQLExceptionConverter, t,
+							                                 "error performing isolated work");
+						default:
+								throw new HibernateException("error performing isolated work", t);
+					}
 					}
 				}
 				finally
 				{
-					//if (transacted && wasAutoCommit)
-					//{
-					//  try
-					//  {
-					//    // TODO NH: reset autocommit
-					//    // TransactionManager.SetAutoCommit(connection, true);
-					//  }
-					//  catch (Exception)
-					//  {
-					//    log.Debug("was unable to reset connection back to auto-commit");
-					//  }
-					//}
-
 					try
 					{
 						trans?.Dispose();
 					}
 					catch (Exception ignore)
 					{
-						isolaterLog.Warn(ignore, "Unable to dispose transaction");
+						_isolatorLog.Warn(ignore, "Unable to dispose transaction");
 					}
 
 					if (connection != null && session.Factory.Dialect is SQLiteDialect == false)
diff --git a/src/NHibernate/Transaction/AdoNetTransactionFactory.cs b/src/NHibernate/Transaction/AdoNetTransactionFactory.cs
@@ -6,7 +6,6 @@
 using NHibernate.Engine;
 using NHibernate.Engine.Transaction;
 using NHibernate.Exceptions;
-using NHibernate.Impl;
 
 namespace NHibernate.Transaction
 {
@@ -16,7 +15,7 @@ namespace NHibernate.Transaction
 	/// </summary>
 	public partial class AdoNetTransactionFactory : ITransactionFactory
 	{
-		private readonly INHibernateLogger isolaterLog = NHibernateLogger.For(typeof(ITransactionFactory));
+		private readonly INHibernateLogger _isolatorLog = NHibernateLogger.For(typeof(ITransactionFactory));
 
 		/// <inheritdoc />
 		public virtual ITransaction CreateTransaction(ISessionImplementor session)
@@ -52,7 +51,6 @@ public virtual void ExecuteWorkInIsolation(ISessionImplementor session, IIsolate
 
 			DbConnection connection = null;
 			DbTransaction trans = null;
-			// bool wasAutoCommit = false;
 			try
 			{
 				// We make an exception for SQLite and use the session's connection,
@@ -64,20 +62,13 @@ public virtual void ExecuteWorkInIsolation(ISessionImplementor session, IIsolate
 				if (transacted)
 				{
 					trans = connection.BeginTransaction();
-					// TODO NH: a way to read the autocommit state is needed
-					//if (TransactionManager.GetAutoCommit(connection))
-					//{
-					//  wasAutoCommit = true;
-					//  TransactionManager.SetAutoCommit(connection, false);
-					//}
 				}
 
 				work.DoWork(connection, trans);
 
 				if (transacted)
 				{
 					trans.Commit();
-					//TransactionManager.Commit(connection);
 				}
 			}
 			catch (Exception t)
@@ -93,46 +84,30 @@ public virtual void ExecuteWorkInIsolation(ISessionImplementor session, IIsolate
 					}
 					catch (Exception ignore)
 					{
-						isolaterLog.Debug(ignore, "Unable to rollback transaction");
+						_isolatorLog.Debug(ignore, "Unable to rollback transaction");
 					}
 
-					if (t is HibernateException)
+					switch (t)
 					{
-						throw;
-					}
-					else if (t is DbException)
-					{
-						throw ADOExceptionHelper.Convert(session.Factory.SQLExceptionConverter, t,
-						                                 "error performing isolated work");
-					}
-					else
-					{
-						throw new HibernateException("error performing isolated work", t);
+						case HibernateException _:
+							throw;
+						case DbException _:
+							throw ADOExceptionHelper.Convert(session.Factory.SQLExceptionConverter, t,
+							                                 "error performing isolated work");
+						default:
+							throw new HibernateException("error performing isolated work", t);
 					}
 				}
 			}
 			finally
 			{
-				//if (transacted && wasAutoCommit)
-				//{
-				//  try
-				//  {
-				//    // TODO NH: reset autocommit
-				//    // TransactionManager.SetAutoCommit(connection, true);
-				//  }
-				//  catch (Exception)
-				//  {
-				//    log.Debug("was unable to reset connection back to auto-commit");
-				//  }
-				//}
-
 				try
 				{
 					trans?.Dispose();
 				}
 				catch (Exception ignore)
 				{
-					isolaterLog.Warn(ignore, "Unable to dispose transaction");
+					_isolatorLog.Warn(ignore, "Unable to dispose transaction");
 				}
 
 				if (connection != null && session.Factory.Dialect is SQLiteDialect == false)

Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,6 @@`
`16`	`16`	`using NHibernate.Engine;`
`17`	`17`	`using NHibernate.Engine.Transaction;`
`18`	`18`	`using NHibernate.Exceptions;`
`19`		`-using NHibernate.Impl;`
`20`	`19`
`21`	`20`	`namespace NHibernate.Transaction`
`22`	`21`	`{`
`@@ -42,7 +41,6 @@ async Task InternalExecuteWorkInIsolationAsync()`
`42`	`41`
`43`	`42`	`DbConnection connection = null;`
`44`	`43`	`DbTransaction trans = null;`
`45`		`- // bool wasAutoCommit = false;`
`46`	`44`	`try`
`47`	`45`	`{`
`48`	`46`	`// We make an exception for SQLite and use the session's connection,`
`@@ -54,20 +52,13 @@ async Task InternalExecuteWorkInIsolationAsync()`
`54`	`52`	`if (transacted)`
`55`	`53`	`{`
`56`	`54`	`trans = connection.BeginTransaction();`
`57`		`- // TODO NH: a way to read the autocommit state is needed`
`58`		`- //if (TransactionManager.GetAutoCommit(connection))`
`59`		`- //{`
`60`		`- // wasAutoCommit = true;`
`61`		`- // TransactionManager.SetAutoCommit(connection, false);`
`62`		`- //}`
`63`	`55`	`}`
`64`	`56`
`65`	`57`	`await (work.DoWorkAsync(connection, trans, cancellationToken)).ConfigureAwait(false);`
`66`	`58`
`67`	`59`	`if (transacted)`
`68`	`60`	`{`
`69`	`61`	`trans.Commit();`
`70`		`- //TransactionManager.Commit(connection);`
`71`	`62`	`}`
`72`	`63`	`}`
`73`	`64`	`catch (Exception t)`
`@@ -83,46 +74,30 @@ async Task InternalExecuteWorkInIsolationAsync()`
`83`	`74`	`}`
`84`	`75`	`catch (Exception ignore)`
`85`	`76`	`{`
`86`		`- isolaterLog.Debug(ignore, "Unable to rollback transaction");`
	`77`	`+ _isolatorLog.Debug(ignore, "Unable to rollback transaction");`
`87`	`78`	`}`
`88`	`79`
`89`		`- if (t is HibernateException)`
`90`		`- {`
`91`		`- throw;`
`92`		`- }`
`93`		`- else if (t is DbException)`
`94`		`- {`
`95`		`- throw ADOExceptionHelper.Convert(session.Factory.SQLExceptionConverter, t,`
`96`		`- "error performing isolated work");`
`97`		`- }`
`98`		`- else`
`99`		`- {`
`100`		`- throw new HibernateException("error performing isolated work", t);`
`101`		`- }`
	`80`	`+ switch (t)`
	`81`	`+ {`
	`82`	`+ case HibernateException _:`
	`83`	`+ throw;`
	`84`	`+ case DbException _:`
	`85`	`+ throw ADOExceptionHelper.Convert(session.Factory.SQLExceptionConverter, t,`
	`86`	`+ "error performing isolated work");`
	`87`	`+ default:`
	`88`	`+ throw new HibernateException("error performing isolated work", t);`
	`89`	`+ }`
`102`	`90`	`}`
`103`	`91`	`}`
`104`	`92`	`finally`
`105`	`93`	`{`
`106`		`- //if (transacted && wasAutoCommit)`
`107`		`- //{`
`108`		`- // try`
`109`		`- // {`
`110`		`- // // TODO NH: reset autocommit`
`111`		`- // // TransactionManager.SetAutoCommit(connection, true);`
`112`		`- // }`
`113`		`- // catch (Exception)`
`114`		`- // {`
`115`		`- // log.Debug("was unable to reset connection back to auto-commit");`
`116`		`- // }`
`117`		`- //}`
`118`		`-`
`119`	`94`	`try`
`120`	`95`	`{`
`121`	`96`	`trans?.Dispose();`
`122`	`97`	`}`
`123`	`98`	`catch (Exception ignore)`
`124`	`99`	`{`
`125`		`- isolaterLog.Warn(ignore, "Unable to dispose transaction");`
	`100`	`+ _isolatorLog.Warn(ignore, "Unable to dispose transaction");`
`126`	`101`	`}`
`127`	`102`
`128`	`103`	`if (connection != null && session.Factory.Dialect is SQLiteDialect == false)`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,6 @@`
`6`	`6`	`using NHibernate.Engine;`
`7`	`7`	`using NHibernate.Engine.Transaction;`
`8`	`8`	`using NHibernate.Exceptions;`
`9`		`-using NHibernate.Impl;`
`10`	`9`
`11`	`10`	`namespace NHibernate.Transaction`
`12`	`11`	`{`
`@@ -16,7 +15,7 @@ namespace NHibernate.Transaction`
`16`	`15`	`/// </summary>`
`17`	`16`	`public partial class AdoNetTransactionFactory : ITransactionFactory`
`18`	`17`	`{`
`19`		`- private readonly INHibernateLogger isolaterLog = NHibernateLogger.For(typeof(ITransactionFactory));`
	`18`	`+ private readonly INHibernateLogger _isolatorLog = NHibernateLogger.For(typeof(ITransactionFactory));`
`20`	`19`
`21`	`20`	`/// <inheritdoc />`
`22`	`21`	`public virtual ITransaction CreateTransaction(ISessionImplementor session)`
`@@ -52,7 +51,6 @@ public virtual void ExecuteWorkInIsolation(ISessionImplementor session, IIsolate`
`52`	`51`
`53`	`52`	`DbConnection connection = null;`
`54`	`53`	`DbTransaction trans = null;`
`55`		`- // bool wasAutoCommit = false;`
`56`	`54`	`try`
`57`	`55`	`{`
`58`	`56`	`// We make an exception for SQLite and use the session's connection,`
`@@ -64,20 +62,13 @@ public virtual void ExecuteWorkInIsolation(ISessionImplementor session, IIsolate`
`64`	`62`	`if (transacted)`
`65`	`63`	`{`
`66`	`64`	`trans = connection.BeginTransaction();`
`67`		`- // TODO NH: a way to read the autocommit state is needed`
`68`		`- //if (TransactionManager.GetAutoCommit(connection))`
`69`		`- //{`
`70`		`- // wasAutoCommit = true;`
`71`		`- // TransactionManager.SetAutoCommit(connection, false);`
`72`		`- //}`
`73`	`65`	`}`
`74`	`66`
`75`	`67`	`work.DoWork(connection, trans);`
`76`	`68`
`77`	`69`	`if (transacted)`
`78`	`70`	`{`
`79`	`71`	`trans.Commit();`
`80`		`- //TransactionManager.Commit(connection);`
`81`	`72`	`}`
`82`	`73`	`}`
`83`	`74`	`catch (Exception t)`
`@@ -93,46 +84,30 @@ public virtual void ExecuteWorkInIsolation(ISessionImplementor session, IIsolate`
`93`	`84`	`}`
`94`	`85`	`catch (Exception ignore)`
`95`	`86`	`{`
`96`		`- isolaterLog.Debug(ignore, "Unable to rollback transaction");`
	`87`	`+ _isolatorLog.Debug(ignore, "Unable to rollback transaction");`
`97`	`88`	`}`
`98`	`89`
`99`		`- if (t is HibernateException)`
	`90`	`+ switch (t)`
`100`	`91`	`{`
`101`		`- throw;`
`102`		`- }`
`103`		`- else if (t is DbException)`
`104`		`- {`
`105`		`- throw ADOExceptionHelper.Convert(session.Factory.SQLExceptionConverter, t,`
`106`		`- "error performing isolated work");`
`107`		`- }`
`108`		`- else`
`109`		`- {`
`110`		`- throw new HibernateException("error performing isolated work", t);`
	`92`	`+ case HibernateException _:`
	`93`	`+ throw;`
	`94`	`+ case DbException _:`
	`95`	`+ throw ADOExceptionHelper.Convert(session.Factory.SQLExceptionConverter, t,`
	`96`	`+ "error performing isolated work");`
	`97`	`+ default:`
	`98`	`+ throw new HibernateException("error performing isolated work", t);`
`111`	`99`	`}`
`112`	`100`	`}`
`113`	`101`	`}`
`114`	`102`	`finally`
`115`	`103`	`{`
`116`		`- //if (transacted && wasAutoCommit)`
`117`		`- //{`
`118`		`- // try`
`119`		`- // {`
`120`		`- // // TODO NH: reset autocommit`
`121`		`- // // TransactionManager.SetAutoCommit(connection, true);`
`122`		`- // }`
`123`		`- // catch (Exception)`
`124`		`- // {`
`125`		`- // log.Debug("was unable to reset connection back to auto-commit");`
`126`		`- // }`
`127`		`- //}`
`128`		`-`
`129`	`104`	`try`
`130`	`105`	`{`
`131`	`106`	`trans?.Dispose();`
`132`	`107`	`}`
`133`	`108`	`catch (Exception ignore)`
`134`	`109`	`{`
`135`		`- isolaterLog.Warn(ignore, "Unable to dispose transaction");`
	`110`	`+ _isolatorLog.Warn(ignore, "Unable to dispose transaction");`
`136`	`111`	`}`
`137`	`112`
`138`	`113`	`if (connection != null && session.Factory.Dialect is SQLiteDialect == false)`