Merge remote-tracking branch 'upstream/master' into nuget

Author: hazzik

src/NHibernate.Test/DebugConnectionProvider.cs

@@ -1,7 +1,7 @@
 using System;
-using System.Collections;
-using System.Collections.Generic;
+using System.Collections.Concurrent;
 using System.Data;
+using System.Linq;
 using NHibernate.Connection;
 
 namespace NHibernate.Test
@@ -12,70 +12,49 @@ namespace NHibernate.Test
 	/// </summary>
 	public class DebugConnectionProvider : DriverConnectionProvider
 	{
-		private ISet<IDbConnection> connections = new HashSet<IDbConnection>();
+		private ConcurrentDictionary<IDbConnection, byte> connections = new ConcurrentDictionary<IDbConnection, byte>();
 
 		public override IDbConnection GetConnection()
 		{
 			try
 			{
 				IDbConnection connection = base.GetConnection();
-				connections.Add(connection);
+				connections.TryAdd(connection, 0);
 				return connection;
 			}
 			catch (Exception e)
 			{
 				throw new HibernateException("Could not open connection to: " + ConnectionString, e);
 			}
-
 		}
 
 		public override void CloseConnection(IDbConnection conn)
 		{
 			base.CloseConnection(conn);
-			connections.Remove(conn);
+			byte _;
+			connections.TryRemove(conn, out _);
 		}
 
 		public bool HasOpenConnections
 		{
 			get
 			{
-				// check to see if all connections that were at one point opened
-				// have been closed through the CloseConnection
-				// method
-				if (connections.Count == 0)
-				{
-					// there are no connections, either none were opened or
-					// all of the closings went through CloseConnection.
-					return false;
-				}
-				else
-				{
-					// Disposing of an ISession does not call CloseConnection (should it???)
-					// so a Diposed of ISession will leave an IDbConnection in the list but
-					// the IDbConnection will be closed (atleast with MsSql it works this way).
-					foreach (IDbConnection conn in connections)
-					{
-						if (conn.State != ConnectionState.Closed)
-						{
-							return true;
-						}
-					}
-
-					// all of the connections have been Disposed and were closed that way
-					// or they were Closed through the CloseConnection method.
-					return false;
-				}
+				// Disposing of an ISession does not call CloseConnection (should it???)
+				// so a Diposed of ISession will leave an IDbConnection in the list but
+				// the IDbConnection will be closed (atleast with MsSql it works this way).
+				return connections.Keys.Any(conn => conn.State != ConnectionState.Closed);
 			}
 		}
 
 		public void CloseAllConnections()
 		{
 			while (connections.Count != 0)
 			{
-				IEnumerator en = connections.GetEnumerator();
-				en.MoveNext();
-				CloseConnection(en.Current as IDbConnection);
+				foreach (var conn in connections.Keys.ToArray())
+				{
+					CloseConnection(conn);
+				}
 			}
 		}
 	}
-}
+}

src/NHibernate/AdoNet/MySqlClientSqlCommandSet.cs

@@ -2,56 +2,51 @@
 using System.Data;
 using System.Diagnostics;
 using System.Reflection;
+using NHibernate.Util;
 
 namespace NHibernate.AdoNet
 {
-	using Action = System.Action;
-
 	public class MySqlClientSqlCommandSet : IDisposable
 	{
 		private static readonly System.Type adapterType;
+		private static readonly Action<object> doInitialise;
+		private static readonly Action<object, int> batchSizeSetter;
+		private static readonly Action<object, IDbCommand> doAppend;
+		private static readonly Func<object, int> doExecuteNonQuery;
+		private static readonly Action<object> doDispose;
+
 		private readonly object instance;
-		private readonly Action doInitialise;
-		private readonly Action<int> batchSizeSetter;
-		private readonly Func<IDbCommand, int> doAppend;
-		private readonly Func<int> doExecuteNonQuery;
-		private readonly Action doDispose;
 		private int countOfCommands;
 
 		static MySqlClientSqlCommandSet()
 		{
 			var sysData = Assembly.Load("MySql.Data");
 			adapterType = sysData.GetType("MySql.Data.MySqlClient.MySqlDataAdapter");
 			Debug.Assert(adapterType != null, "Could not find MySqlDataAdapter!");
+
+			doInitialise = DelegateHelper.BuildAction(adapterType, "InitializeBatching");
+			batchSizeSetter = DelegateHelper.BuildPropertySetter<int>(adapterType, "UpdateBatchSize");
+			doAppend = DelegateHelper.BuildAction<IDbCommand>(adapterType, "AddToBatch");
+			doExecuteNonQuery = DelegateHelper.BuildFunc<int>(adapterType, "ExecuteBatch");
+			doDispose = DelegateHelper.BuildAction(adapterType, "Dispose");
 		}
 
 		public MySqlClientSqlCommandSet(int batchSize)
 		{
 			instance = Activator.CreateInstance(adapterType, true);
-			doInitialise = (Action) Delegate.CreateDelegate(typeof (Action), instance, "InitializeBatching");
-			batchSizeSetter = (Action<int>) Delegate.CreateDelegate(typeof (Action<int>), instance, "set_UpdateBatchSize");
-			doAppend = (Func<IDbCommand, int>) Delegate.CreateDelegate(typeof (Func<IDbCommand, int>), instance, "AddToBatch");
-			doExecuteNonQuery = (Func<int>) Delegate.CreateDelegate(typeof (Func<int>), instance, "ExecuteBatch");
-			doDispose = (Action)Delegate.CreateDelegate(typeof(Action), instance, "Dispose");
-
-			Initialise(batchSize);
-		}
-
-		private void Initialise(int batchSize)
-		{
-			doInitialise();
-			batchSizeSetter(batchSize);
+			doInitialise(instance);
+			batchSizeSetter(instance, batchSize);
 		}
 
 		public void Append(IDbCommand command)
 		{
-			doAppend(command);
+			doAppend(instance, command);
 			countOfCommands++;
 		}
 
 		public void Dispose()
 		{
-			doDispose();
+			doDispose(instance);
 		}
 
 		public int ExecuteNonQuery()
@@ -63,7 +58,7 @@ public int ExecuteNonQuery()
 					return 0;
 				}
 
-				return doExecuteNonQuery();
+				return doExecuteNonQuery(instance);
 			}
 			catch (Exception exception)
 			{
@@ -73,10 +68,7 @@ public int ExecuteNonQuery()
 
 		public int CountOfCommands
 		{
-			get
-			{
-				return countOfCommands;
-			}
+			get { return countOfCommands; }
 		}
 	}
 }

src/NHibernate/AdoNet/SqlClientSqlCommandSet.cs

@@ -2,14 +2,14 @@
 using System.Data.SqlClient;
 using System.Diagnostics;
 using System.Reflection;
+using NHibernate.Util;
 
 namespace NHibernate.AdoNet
 {
-	using Action = System.Action;
 	using SqlCommand = System.Data.SqlClient.SqlCommand;
 
 	/// <summary>
-	/// Expose the batch functionality in ADO.Net 2.0
+	/// Expose the batch functionality in ADO.Net 4.0
 	/// Microsoft in its wisdom decided to make my life hard and mark it internal.
 	/// Through the use of Reflection and some delegates magic, I opened up the functionality.
 	/// 
@@ -18,35 +18,37 @@ namespace NHibernate.AdoNet
 	public class SqlClientSqlCommandSet : IDisposable
 	{
 		private static readonly System.Type sqlCmdSetType;
+		private static readonly Action<object, SqlConnection> connectionSetter;
+		private static readonly Action<object, SqlTransaction> transactionSetter;
+		private static readonly Action<object, int> commandTimeoutSetter;
+		private static readonly Func<object, SqlConnection> connectionGetter;
+		private static readonly Func<object, SqlCommand> batchCommandGetter;
+		private static readonly Action<object, SqlCommand> doAppend;
+		private static readonly Func<object, int> doExecuteNonQuery;
+		private static readonly Action<object> doDispose;
+
 		private readonly object instance;
-		private readonly Action<SqlConnection> connectionSetter;
-		private readonly Action<SqlTransaction> transactionSetter;
-		private readonly Action<int> commandTimeoutSetter;
-		private readonly Func<SqlConnection> connectionGetter;
-		private readonly Func<SqlCommand> commandGetter;
-		private readonly Action<SqlCommand> doAppend;
-		private readonly Func<int> doExecuteNonQuery;
-		private readonly Action doDispose;
 		private int countOfCommands;
 
 		static SqlClientSqlCommandSet()
 		{
-			var sysData = Assembly.Load("System.Data, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
+			var sysData = Assembly.Load("System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
 			sqlCmdSetType = sysData.GetType("System.Data.SqlClient.SqlCommandSet");
 			Debug.Assert(sqlCmdSetType != null, "Could not find SqlCommandSet!");
+
+			connectionSetter = DelegateHelper.BuildPropertySetter<SqlConnection>(sqlCmdSetType, "Connection");
+			connectionGetter = DelegateHelper.BuildPropertyGetter<SqlConnection>(sqlCmdSetType, "Connection");
+			transactionSetter = DelegateHelper.BuildPropertySetter<SqlTransaction>(sqlCmdSetType, "Transaction");
+			commandTimeoutSetter = DelegateHelper.BuildPropertySetter<int>(sqlCmdSetType, "CommandTimeout");
+			batchCommandGetter = DelegateHelper.BuildPropertyGetter<SqlCommand>(sqlCmdSetType, "BatchCommand");
+			doAppend = DelegateHelper.BuildAction<SqlCommand>(sqlCmdSetType, "Append");
+			doExecuteNonQuery = DelegateHelper.BuildFunc<int>(sqlCmdSetType, "ExecuteNonQuery");
+			doDispose = DelegateHelper.BuildAction(sqlCmdSetType, "Dispose");
 		}
 
 		public SqlClientSqlCommandSet()
 		{
 			instance = Activator.CreateInstance(sqlCmdSetType, true);
-			connectionSetter = (Action<SqlConnection>) Delegate.CreateDelegate(typeof (Action<SqlConnection>), instance, "set_Connection");
-			transactionSetter = (Action<SqlTransaction>) Delegate.CreateDelegate(typeof (Action<SqlTransaction>), instance, "set_Transaction");
-			commandTimeoutSetter = (Action<int>) Delegate.CreateDelegate(typeof (Action<int>), instance, "set_CommandTimeout");
-			connectionGetter = (Func<SqlConnection>) Delegate.CreateDelegate(typeof (Func<SqlConnection>), instance, "get_Connection");
-			commandGetter = (Func<SqlCommand>) Delegate.CreateDelegate(typeof (Func<SqlCommand>), instance, "get_BatchCommand");
-			doAppend = (Action<SqlCommand>) Delegate.CreateDelegate(typeof (Action<SqlCommand>), instance, "Append");
-			doExecuteNonQuery = (Func<int>) Delegate.CreateDelegate(typeof (Func<int>), instance, "ExecuteNonQuery");
-			doDispose = (Action) Delegate.CreateDelegate(typeof (Action), instance, "Dispose");
 		}
 
 		/// <summary>
@@ -56,7 +58,7 @@ public SqlClientSqlCommandSet()
 		public void Append(SqlCommand command)
 		{
 			AssertHasParameters(command);
-			doAppend(command);
+			doAppend(instance, command);
 			countOfCommands++;
 		}
 
@@ -79,7 +81,7 @@ private static void AssertHasParameters(SqlCommand command)
 		/// </summary>
 		public SqlCommand BatchCommand
 		{
-			get { return commandGetter(); }
+			get { return batchCommandGetter(instance); }
 		}
 
 		/// <summary>
@@ -104,23 +106,23 @@ public int ExecuteNonQuery()
 
 			if (CountOfCommands == 0)
 				return 0;
-			return doExecuteNonQuery();
+			return doExecuteNonQuery(instance);
 		}
 
 		public SqlConnection Connection
 		{
-			get { return connectionGetter(); }
-			set { connectionSetter(value); }
+			get { return connectionGetter(instance); }
+			set { connectionSetter(instance, value); }
 		}
 
 		public SqlTransaction Transaction
 		{
-			set { transactionSetter(value); }
+			set { transactionSetter(instance, value); }
 		}
 
 		public int CommandTimeout
 		{
-			set { commandTimeoutSetter(value); }
+			set { commandTimeoutSetter(instance, value); }
 		}
 
 		///<summary>
@@ -129,7 +131,7 @@ public int CommandTimeout
 		///<filterpriority>2</filterpriority>
 		public void Dispose()
 		{
-			doDispose();
+			doDispose(instance);
 		}
 	}
 }