NH-4003 - renaming then converting to properties some methods, to be squashed or dropped.

Author: fredericDelaporte

src/NHibernate.Test/SessionBuilder/Fixture.cs

@@ -37,7 +37,7 @@ public void CanSetAutoClose()
 		private void CanSetAutoClose<T>(T sb) where T : ISessionBuilder<T>
 		{
 			var options = (ISessionCreationOptions)sb;
-			CanSet(sb, sb.AutoClose, options.ShouldAutoClose,
+			CanSet(sb, sb.AutoClose, () => options.ShouldAutoClose,
 				sb is ISharedSessionBuilder ssb ? ssb.AutoClose : default(Func<ISharedSessionBuilder>),
 				// initial values
 				false,
@@ -63,34 +63,34 @@ private void CanSetConnection<T>(T sb) where T : ISessionBuilder<T>
 			try
 			{
 				var options = (ISessionCreationOptions)sb;
-				Assert.IsNull(options.GetConnection(), $"{sbType}: Initial value");
+				Assert.IsNull(options.UserSuppliedConnection, $"{sbType}: Initial value");
 				var fsb = sb.Connection(conn);
-				Assert.AreEqual(conn, options.GetConnection(), $"{sbType}: After call with a connection");
+				Assert.AreEqual(conn, options.UserSuppliedConnection, $"{sbType}: After call with a connection");
 				Assert.AreEqual(sb, fsb, $"{sbType}: Unexpected fluent return after call with a connection");
 
 				if (sb is ISharedSessionBuilder ssb)
 				{
 					var sharedOptions = (ISharedSessionCreationOptions)options;
-					Assert.IsFalse(sharedOptions.IsTransactionCoordinatorShared(), $"{sbType}: Transaction coordinator shared before sharing");
-					Assert.IsNull(sharedOptions.GetConnectionManager(), $"{sbType}: Connection manager shared before sharing");
+					Assert.IsFalse(sharedOptions.IsTransactionCoordinatorShared, $"{sbType}: Transaction coordinator shared before sharing");
+					Assert.IsNull(sharedOptions.ConnectionManager, $"{sbType}: Connection manager shared before sharing");
 
 					var fssb = ssb.Connection();
 					// Sharing connection shares the connection manager, not the connection.
-					Assert.IsNull(options.GetConnection(), $"{sbType}: After call with previous session connection");
-					Assert.IsTrue(sharedOptions.IsTransactionCoordinatorShared(), $"{sbType}: Transaction coordinator not shared after sharing");
-					Assert.IsNotNull(sharedOptions.GetConnectionManager(), $"{sbType}: Connection manager not shared after sharing");
+					Assert.IsNull(options.UserSuppliedConnection, $"{sbType}: After call with previous session connection");
+					Assert.IsTrue(sharedOptions.IsTransactionCoordinatorShared, $"{sbType}: Transaction coordinator not shared after sharing");
+					Assert.IsNotNull(sharedOptions.ConnectionManager, $"{sbType}: Connection manager not shared after sharing");
 					Assert.AreEqual(sb, fssb, $"{sbType}: Unexpected fluent return on shared");
 
 					fsb = sb.Connection(null);
-					Assert.IsNull(options.GetConnection(), $"{sbType}: After call with null");
-					Assert.IsFalse(sharedOptions.IsTransactionCoordinatorShared(), $"{sbType}: Transaction coordinator shared after un-sharing");
-					Assert.IsNull(sharedOptions.GetConnectionManager(), $"{sbType}: Connection manager shared after un-sharing");
+					Assert.IsNull(options.UserSuppliedConnection, $"{sbType}: After call with null");
+					Assert.IsFalse(sharedOptions.IsTransactionCoordinatorShared, $"{sbType}: Transaction coordinator shared after un-sharing");
+					Assert.IsNull(sharedOptions.ConnectionManager, $"{sbType}: Connection manager shared after un-sharing");
 					Assert.AreEqual(sb, fsb, $"{sbType}: Unexpected fluent return after un-sharing");
 				}
 				else
 				{
 					fsb = sb.Connection(null);
-					Assert.IsNull(options.GetConnection(), $"{sbType}: After call with null");
+					Assert.IsNull(options.UserSuppliedConnection, $"{sbType}: After call with null");
 					Assert.AreEqual(sb, fsb, $"{sbType}: Unexpected fluent return after call with null");
 				}
 			}
@@ -109,13 +109,13 @@ public void CanSetConnectionOnStateless()
 			try
 			{
 				var options = (ISessionCreationOptions)sb;
-				Assert.IsNull(options.GetConnection(), $"{sbType}: Initial value");
+				Assert.IsNull(options.UserSuppliedConnection, $"{sbType}: Initial value");
 				var fsb = sb.Connection(conn);
-				Assert.AreEqual(conn, options.GetConnection(), $"{sbType}: After call with a connection");
+				Assert.AreEqual(conn, options.UserSuppliedConnection, $"{sbType}: After call with a connection");
 				Assert.AreEqual(sb, fsb, $"{sbType}: Unexpected fluent return after call with a connection");
 
 				fsb = sb.Connection(null);
-				Assert.IsNull(options.GetConnection(), $"{sbType}: After call with null");
+				Assert.IsNull(options.UserSuppliedConnection, $"{sbType}: After call with null");
 				Assert.AreEqual(sb, fsb, $"{sbType}: Unexpected fluent return after call with null");
 			}
 			finally
@@ -138,7 +138,7 @@ public void CanSetConnectionReleaseMode()
 		private void CanSetConnectionReleaseMode<T>(T sb) where T : ISessionBuilder<T>
 		{
 			var options = (ISessionCreationOptions)sb;
-			CanSet(sb, sb.ConnectionReleaseMode, options.GetConnectionReleaseMode,
+			CanSet(sb, sb.ConnectionReleaseMode, () => options.SessionConnectionReleaseMode,
 				sb is ISharedSessionBuilder ssb ? ssb.ConnectionReleaseMode : default(Func<ISharedSessionBuilder>),
 				// initial values
 				sessions.Settings.ConnectionReleaseMode,
@@ -160,7 +160,7 @@ public void CanSetFlushMode()
 		private void CanSetFlushMode<T>(T sb) where T : ISessionBuilder<T>
 		{
 			var options = (ISessionCreationOptions)sb;
-			CanSet(sb, sb.FlushMode, options.GetInitialSessionFlushMode,
+			CanSet(sb, sb.FlushMode, () => options.InitialSessionFlushMode,
 				sb is ISharedSessionBuilder ssb ? ssb.FlushMode : default(Func<ISharedSessionBuilder>),
 				// initial values
 				sessions.Settings.DefaultFlushMode,
@@ -186,22 +186,22 @@ private void CanSetInterceptor<T>(T sb) where T : ISessionBuilder<T>
 			var interceptor = new EmptyInterceptor();
 			var options = (ISessionCreationOptions)sb;
 
-			Assert.AreEqual(sessions.Interceptor, options.GetInterceptor(), $"{sbType}: Initial value");
+			Assert.AreEqual(sessions.Interceptor, options.SessionInterceptor, $"{sbType}: Initial value");
 			var fsb = sb.Interceptor(interceptor);
-			Assert.AreEqual(interceptor, options.GetInterceptor(), $"{sbType}: After call with an interceptor");
+			Assert.AreEqual(interceptor, options.SessionInterceptor, $"{sbType}: After call with an interceptor");
 			Assert.AreEqual(sb, fsb, $"{sbType}: Unexpected fluent return after call with an interceptor");
 
 			if (sb is ISharedSessionBuilder ssb)
 			{
 				var fssb = ssb.Interceptor();
-				Assert.AreEqual(EmptyInterceptor.Instance, options.GetInterceptor(), $"{sbType}: After call with shared interceptor");
+				Assert.AreEqual(EmptyInterceptor.Instance, options.SessionInterceptor, $"{sbType}: After call with shared interceptor");
 				Assert.AreEqual(sb, fssb, $"{sbType}: Unexpected fluent return on shared");
 			}
 
 			Assert.Throws<ArgumentNullException>(() => sb.Interceptor(null), $"{sbType}: After call with null");
 
 			fsb = sb.NoInterceptor();
-			Assert.AreEqual(EmptyInterceptor.Instance, options.GetInterceptor(), $"{sbType}: After no call");
+			Assert.AreEqual(EmptyInterceptor.Instance, options.SessionInterceptor, $"{sbType}: After no call");
 			Assert.AreEqual(sb, fsb, $"{sbType}: Unexpected fluent return after no call");
 		}
 

src/NHibernate/Impl/AbstractSessionImpl.cs

@@ -46,8 +46,8 @@ protected internal AbstractSessionImpl(ISessionFactoryImplementor factory, ISess
 		{
 			_factory = factory;
 			Timestamp = factory.Settings.CacheProvider.NextTimestamp();
-			_flushMode = options.GetInitialSessionFlushMode();
-			Interceptor = options.GetInterceptor() ?? EmptyInterceptor.Instance;
+			_flushMode = options.InitialSessionFlushMode;
+			Interceptor = options.SessionInterceptor ?? EmptyInterceptor.Instance;
 		}
 
 		#region ISessionImplementor Members

src/NHibernate/Impl/ISessionCreationOptions.cs

@@ -8,17 +8,17 @@ namespace NHibernate.Impl
 	/// <seealso cref="ISessionBuilder"/>
 	public interface ISessionCreationOptions
 	{
-		// NH note: it is tempting to convert them to properties, but then their names conflict
-		// with ISessionBuilder, which is implemented along this interface.
-		FlushMode GetInitialSessionFlushMode();
+		// NH note: naming "adjusted" for converting Java methods to properties while avoiding conflicts with
+		// ISessionBuilder.
+		FlushMode InitialSessionFlushMode { get; }
 
-		bool ShouldAutoClose();
+		bool ShouldAutoClose { get; }
 
-		DbConnection GetConnection();
+		DbConnection UserSuppliedConnection { get; }
 
-		IInterceptor GetInterceptor();
+		IInterceptor SessionInterceptor { get; }
 
 		// Todo: port PhysicalConnectionHandlingMode
-		ConnectionReleaseMode GetConnectionReleaseMode();
+		ConnectionReleaseMode SessionConnectionReleaseMode { get; }
 	}
 }

src/NHibernate/Impl/ISharedSessionCreationOptions.cs

@@ -10,8 +10,8 @@ namespace NHibernate.Impl
 	public interface ISharedSessionCreationOptions : ISessionCreationOptions
 	{
 		// NH note: not converting them to properties for staying in sync with ISessionCreationOptions.
-		bool IsTransactionCoordinatorShared();
+		bool IsTransactionCoordinatorShared { get; }
 		// NH different implementation: need to port Hibernate transaction management.
-		ConnectionManager GetConnectionManager();
+		ConnectionManager ConnectionManager { get; }
 	}
 }

src/NHibernate/Impl/SessionFactoryImpl.cs

@@ -1309,20 +1309,18 @@ protected void SetSelf(T self)
 
 			// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 			// SessionCreationOptions
-			// NH note: it is tempting to convert them to properties, but then their names conflict
-			// with SessionBuilder interface.
 
-			public virtual FlushMode GetInitialSessionFlushMode() => _flushMode;
+			public virtual FlushMode InitialSessionFlushMode => _flushMode;
 
-			public virtual bool ShouldAutoClose() => _autoClose;
+			public virtual bool ShouldAutoClose => _autoClose;
 
-			public DbConnection GetConnection() => _connection;
+			public DbConnection UserSuppliedConnection => _connection;
 
 			// NH different implementation: Hibernate here ignore EmptyInterceptor.Instance too, resulting
 			// in the "NoInterceptor" being unable to override a session factory interceptor.
-			public virtual IInterceptor GetInterceptor() => _interceptor ?? _sessionFactory.Interceptor;
+			public virtual IInterceptor SessionInterceptor => _interceptor ?? _sessionFactory.Interceptor;
 
-			public virtual ConnectionReleaseMode GetConnectionReleaseMode() => _connectionReleaseMode;
+			public virtual ConnectionReleaseMode SessionConnectionReleaseMode => _connectionReleaseMode;
 
 			// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 			// SessionBuilder
@@ -1400,15 +1398,15 @@ public IStatelessSessionBuilder Connection(DbConnection connection)
 				return this;
 			}
 
-			public FlushMode GetInitialSessionFlushMode() => FlushMode.Always;
+			public FlushMode InitialSessionFlushMode => FlushMode.Always;
 
-			public bool ShouldAutoClose() => false;
+			public bool ShouldAutoClose => false;
 
-			public DbConnection GetConnection() => _connection;
+			public DbConnection UserSuppliedConnection => _connection;
 
-			public IInterceptor GetInterceptor() => EmptyInterceptor.Instance;
+			public IInterceptor SessionInterceptor => EmptyInterceptor.Instance;
 
-			public ConnectionReleaseMode GetConnectionReleaseMode() => ConnectionReleaseMode.AfterTransaction;
+			public ConnectionReleaseMode SessionConnectionReleaseMode => ConnectionReleaseMode.AfterTransaction;
 		}
 	}
 }

src/NHibernate/Impl/SessionImpl.cs

@@ -189,22 +189,22 @@ internal SessionImpl(SessionFactoryImpl factory, ISessionCreationOptions options
 				actionQueue = new ActionQueue(this);
 				persistenceContext = new StatefulPersistenceContext(this);
 
-				autoCloseSessionEnabled = options.ShouldAutoClose();
+				autoCloseSessionEnabled = options.ShouldAutoClose;
 
 				listeners = factory.EventListeners;
-				connectionReleaseMode = options.GetConnectionReleaseMode();
+				connectionReleaseMode = options.SessionConnectionReleaseMode;
 
-				if (options is ISharedSessionCreationOptions sharedOptions && sharedOptions.IsTransactionCoordinatorShared())
+				if (options is ISharedSessionCreationOptions sharedOptions && sharedOptions.IsTransactionCoordinatorShared)
 				{
 					// NH specific implementation: need to port Hibernate transaction management.
 					_transactionCoordinatorShared = true;
-					if (options.GetConnection() != null)
+					if (options.UserSuppliedConnection != null)
 						throw new SessionException("Cannot simultaneously share transaction context and specify connection");
-					connectionManager = sharedOptions.GetConnectionManager();
+					connectionManager = sharedOptions.ConnectionManager;
 				}
 				else
 				{
-					connectionManager = new ConnectionManager(this, options.GetConnection(), connectionReleaseMode, Interceptor);
+					connectionManager = new ConnectionManager(this, options.UserSuppliedConnection, connectionReleaseMode, Interceptor);
 				}
 
 				if (factory.Statistics.IsStatisticsEnabled)
@@ -2556,10 +2556,10 @@ public override ISharedSessionBuilder Connection(DbConnection connection)
 			// SharedSessionCreationOptions
 
 			// NH note: not converting them to properties for staying in sync with ISessionCreationOptions.
-			public virtual bool IsTransactionCoordinatorShared() => _shareTransactionContext;
+			public virtual bool IsTransactionCoordinatorShared => _shareTransactionContext;
 
 			// NH different implementation: need to port Hibernate transaction management.
-			public ConnectionManager GetConnectionManager() => _shareTransactionContext ? _session.ConnectionManager : null;
+			public ConnectionManager ConnectionManager => _shareTransactionContext ? _session.ConnectionManager : null;
 		}
 	}
 }

src/NHibernate/Impl/StatelessSessionImpl.cs

@@ -38,7 +38,7 @@ internal StatelessSessionImpl(SessionFactoryImpl factory, ISessionCreationOption
 			using (new SessionIdLoggingContext(SessionId))
 			{
 				temporaryPersistenceContext = new StatefulPersistenceContext(this);
-				connectionManager = new ConnectionManager(this, options.GetConnection(), ConnectionReleaseMode.AfterTransaction,
+				connectionManager = new ConnectionManager(this, options.UserSuppliedConnection, ConnectionReleaseMode.AfterTransaction,
 					EmptyInterceptor.Instance);
 
 				if (log.IsDebugEnabled)