Reduce allocations when opening a connection.

Defer creation of MySqlConnectionStringBuilder and ConnectionSettings until it is known that a new ConnectionPool needs to be created.

Author: bgrainger

src/MySqlConnector/Core/ConnectionPool.cs

@@ -14,6 +14,8 @@ internal sealed class ConnectionPool
 	{
 		public int Id { get; }
 
+		public ConnectionSettings ConnectionSettings { get; }
+
 		public async Task<ServerSession> GetSessionAsync(MySqlConnection connection, IOBehavior ioBehavior, CancellationToken cancellationToken)
 		{
 			cancellationToken.ThrowIfCancellationRequested();
@@ -27,7 +29,7 @@ public async Task<ServerSession> GetSessionAsync(MySqlConnection connection, IOB
 				RecoverLeakedSessions();
 			}
 
-			if (m_connectionSettings.MinimumPoolSize > 0)
+			if (ConnectionSettings.MinimumPoolSize > 0)
 				await CreateMinimumPooledSessions(ioBehavior, cancellationToken).ConfigureAwait(false);
 
 			// wait for an open slot (until the cancellationToken is cancelled, which is typically due to timeout)
@@ -61,9 +63,9 @@ public async Task<ServerSession> GetSessionAsync(MySqlConnection connection, IOB
 					}
 					else
 					{
-						if (m_connectionSettings.ConnectionReset)
+						if (ConnectionSettings.ConnectionReset)
 						{
-							reuseSession = await session.TryResetConnectionAsync(m_connectionSettings, ioBehavior, cancellationToken).ConfigureAwait(false);
+							reuseSession = await session.TryResetConnectionAsync(ConnectionSettings, ioBehavior, cancellationToken).ConfigureAwait(false);
 						}
 						else
 						{
@@ -98,7 +100,7 @@ public async Task<ServerSession> GetSessionAsync(MySqlConnection connection, IOB
 				session = new ServerSession(this, m_generation, Interlocked.Increment(ref m_lastSessionId));
 				if (Log.IsInfoEnabled())
 					Log.Info("{0} no pooled session available; created new Session{1}", m_logArguments[0], session.Id);
-				await session.ConnectAsync(m_connectionSettings, m_loadBalancer, ioBehavior, cancellationToken).ConfigureAwait(false);
+				await session.ConnectAsync(ConnectionSettings, m_loadBalancer, ioBehavior, cancellationToken).ConfigureAwait(false);
 				AdjustHostConnectionCount(session, 1);
 				session.OwningConnection = new WeakReference<MySqlConnection>(connection);
 				int leasedSessionsCountNew;
@@ -126,8 +128,8 @@ private bool SessionIsHealthy(ServerSession session)
 				return false;
 			if (session.DatabaseOverride != null)
 				return false;
-			if (m_connectionSettings.ConnectionLifeTime > 0
-			    && (DateTime.UtcNow - session.CreatedUtc).TotalSeconds >= m_connectionSettings.ConnectionLifeTime)
+			if (ConnectionSettings.ConnectionLifeTime > 0
+			    && (DateTime.UtcNow - session.CreatedUtc).TotalSeconds >= ConnectionSettings.ConnectionLifeTime)
 				return false;
 
 			return true;
@@ -175,9 +177,9 @@ public async Task ReapAsync(IOBehavior ioBehavior, CancellationToken cancellatio
 		{
 			Log.Debug("{0} reaping connection pool", m_logArguments);
 			RecoverLeakedSessions();
-			if (m_connectionSettings.ConnectionIdleTimeout == 0)
+			if (ConnectionSettings.ConnectionIdleTimeout == 0)
 				return;
-			await CleanPoolAsync(ioBehavior, session => (DateTime.UtcNow - session.LastReturnedUtc).TotalSeconds >= m_connectionSettings.ConnectionIdleTimeout, true, cancellationToken).ConfigureAwait(false);
+			await CleanPoolAsync(ioBehavior, session => (DateTime.UtcNow - session.LastReturnedUtc).TotalSeconds >= ConnectionSettings.ConnectionIdleTimeout, true, cancellationToken).ConfigureAwait(false);
 		}
 
 		/// <summary>
@@ -196,7 +198,7 @@ public Dictionary<string, CachedProcedure> GetProcedureCache()
 			}
 			return procedureCache;
 		}
-		
+
 		/// <summary>
 		/// Examines all the <see cref="ServerSession"/> objects in <see cref="m_leasedSessions"/> to determine if any
 		/// have an owning <see cref="MySqlConnection"/> that has been garbage-collected. If so, assumes that the connection
@@ -238,7 +240,7 @@ private async Task CleanPoolAsync(IOBehavior ioBehavior, Func<ServerSession, boo
 					// if respectMinPoolSize is true, return if (leased sessions + waiting sessions <= minPoolSize)
 					if (respectMinPoolSize)
 						lock (m_sessions)
-							if (m_connectionSettings.MaximumPoolSize - m_sessionSemaphore.CurrentCount + m_sessions.Count <= m_connectionSettings.MinimumPoolSize)
+							if (ConnectionSettings.MaximumPoolSize - m_sessionSemaphore.CurrentCount + m_sessions.Count <= ConnectionSettings.MinimumPoolSize)
 								return;
 
 					// try to get an open slot; if this fails, connection pool is full and sessions will be disposed when returned to pool
@@ -301,7 +303,7 @@ private async Task CreateMinimumPooledSessions(IOBehavior ioBehavior, Cancellati
 				lock (m_sessions)
 				{
 					// check if the desired minimum number of sessions have been created
-					if (m_connectionSettings.MaximumPoolSize - m_sessionSemaphore.CurrentCount + m_sessions.Count >= m_connectionSettings.MinimumPoolSize)
+					if (ConnectionSettings.MaximumPoolSize - m_sessionSemaphore.CurrentCount + m_sessions.Count >= ConnectionSettings.MinimumPoolSize)
 						return;
 				}
 
@@ -322,7 +324,7 @@ private async Task CreateMinimumPooledSessions(IOBehavior ioBehavior, Cancellati
 				{
 					var session = new ServerSession(this, m_generation, Interlocked.Increment(ref m_lastSessionId));
 					Log.Info("{0} created Session{1} to reach minimum pool size", m_logArguments[0], session.Id);
-					await session.ConnectAsync(m_connectionSettings, m_loadBalancer, ioBehavior, cancellationToken).ConfigureAwait(false);
+					await session.ConnectAsync(ConnectionSettings, m_loadBalancer, ioBehavior, cancellationToken).ConfigureAwait(false);
 					AdjustHostConnectionCount(session, 1);
 					lock (m_sessions)
 						m_sessions.AddFirst(session);
@@ -335,29 +337,51 @@ private async Task CreateMinimumPooledSessions(IOBehavior ioBehavior, Cancellati
 			}
 		}
 
-		public static ConnectionPool GetPool(ConnectionSettings cs)
+		public static ConnectionPool GetPool(string connectionString)
 		{
-			if (!cs.Pooling)
-				return null;
+			// check if pool has already been created for this exact connection string
+			try
+			{
+				s_poolLock.EnterReadLock();
+				if (s_pools.TryGetValue(connectionString, out var pool))
+					return pool;
+			}
+			finally
+			{
+				s_poolLock.ExitReadLock();
+			}
 
-			var key = cs.ConnectionString;
+			// parse connection string and check for 'Pooling' setting
+			var connectionStringBuilder = new MySqlConnectionStringBuilder(connectionString);
+			if (!connectionStringBuilder.Pooling)
+				return null;
 
+			// check for pool using normalized form of connection string
+			var normalizedConnectionString = connectionStringBuilder.ConnectionString;
 			try
 			{
 				s_poolLock.EnterReadLock();
-				if (s_pools.TryGetValue(key, out var pool))
+				if (s_pools.TryGetValue(normalizedConnectionString, out var pool))
 					return pool;
+				// TODO: Add an entry using 'connectionString'?
 			}
 			finally
 			{
 				s_poolLock.ExitReadLock();
 			}
 
+			var connectionSettings = new ConnectionSettings(connectionStringBuilder);
+
 			try
 			{
 				s_poolLock.EnterWriteLock();
-				if (!s_pools.TryGetValue(key, out var pool))
-					pool = s_pools[key] = new ConnectionPool(cs);
+				if (!s_pools.TryGetValue(normalizedConnectionString, out var pool))
+				{
+					pool = new ConnectionPool(connectionSettings);
+					s_pools[normalizedConnectionString] = pool;
+					if (normalizedConnectionString != connectionString)
+						s_pools[connectionString] = pool;
+				}
 				return pool;
 			}
 			finally
@@ -393,7 +417,7 @@ private static IReadOnlyList<ConnectionPool> GetAllPools()
 
 		private ConnectionPool(ConnectionSettings cs)
 		{
-			m_connectionSettings = cs;
+			ConnectionSettings = cs;
 			m_generation = 0;
 			m_cleanSemaphore = new SemaphoreSlim(1);
 			m_sessionSemaphore = new SemaphoreSlim(cs.MaximumPoolSize);
@@ -414,10 +438,7 @@ private ConnectionPool(ConnectionSettings cs)
 			Id = Interlocked.Increment(ref s_poolId);
 			m_logArguments = new object[] { "Pool{0}".FormatInvariant(Id) };
 			if (Log.IsInfoEnabled())
-			{
-				var csb = new MySqlConnectionStringBuilder(cs.ConnectionString);
-				Log.Info("{0} creating new connection pool for {1}", m_logArguments[0], csb.GetConnectionString(includePassword: false));
-			}
+				Log.Info("{0} creating new connection pool for {1}", m_logArguments[0], cs.ConnectionStringBuilder.GetConnectionString(includePassword: false));
 		}
 
 		private void AdjustHostConnectionCount(ServerSession session, int delta)
@@ -472,7 +493,6 @@ public IEnumerable<string> LoadBalance(IReadOnlyList<string> hosts)
 		readonly SemaphoreSlim m_cleanSemaphore;
 		readonly SemaphoreSlim m_sessionSemaphore;
 		readonly LinkedList<ServerSession> m_sessions;
-		readonly ConnectionSettings m_connectionSettings;
 		readonly Dictionary<string, ServerSession> m_leasedSessions;
 		readonly ILoadBalancer m_loadBalancer;
 		readonly Dictionary<string, int> m_hostSessions;

src/MySqlConnector/Core/ConnectionSettings.cs

@@ -10,6 +10,7 @@ internal sealed class ConnectionSettings
 	{
 		public ConnectionSettings(MySqlConnectionStringBuilder csb)
 		{
+			ConnectionStringBuilder = csb;
 			ConnectionString = csb.ConnectionString;
 
 			// Base Options
@@ -64,6 +65,12 @@ public ConnectionSettings(MySqlConnectionStringBuilder csb)
 			UseCompression = csb.UseCompression;
 		}
 
+		/// <summary>
+		/// The <see cref="MySqlConnectionStringBuilder" /> that was used to create this <see cref="ConnectionSettings" />.!--
+		/// This object must not be mutated.
+		/// </summary>
+		public MySqlConnectionStringBuilder ConnectionStringBuilder { get; }
+
 		// Base Options
 		public string ConnectionString { get; }
 		public ConnectionType ConnectionType { get; }

src/MySqlConnector/MySql.Data.MySqlClient/MySqlConnection.cs

@@ -154,10 +154,9 @@ private async ValueTask<bool> PingAsync(IOBehavior ioBehavior, CancellationToken
 
 		public override void Open() => OpenAsync(IOBehavior.Synchronous, CancellationToken.None).GetAwaiter().GetResult();
 
-		public override Task OpenAsync(CancellationToken cancellationToken) =>
-			OpenAsync(AsyncIOBehavior, cancellationToken);
+		public override Task OpenAsync(CancellationToken cancellationToken) => OpenAsync(default, cancellationToken);
 
-		private async Task OpenAsync(IOBehavior ioBehavior, CancellationToken cancellationToken)
+		private async Task OpenAsync(IOBehavior? ioBehavior, CancellationToken cancellationToken)
 		{
 			VerifyNotDisposed();
 			if (State != ConnectionState.Closed)
@@ -191,23 +190,28 @@ private async Task OpenAsync(IOBehavior ioBehavior, CancellationToken cancellati
 
 		public override string ConnectionString
 		{
-			get => m_connectionStringBuilder.GetConnectionString(!m_hasBeenOpened || m_connectionSettings.PersistSecurityInfo);
+			get
+			{
+				if (!m_hasBeenOpened)
+					return m_connectionString;
+				var connectionStringBuilder = GetConnectionSettings().ConnectionStringBuilder;
+				return connectionStringBuilder.GetConnectionString(connectionStringBuilder.PersistSecurityInfo);
+			}
 			set
 			{
 				if (m_hasBeenOpened)
 					throw new InvalidOperationException("Cannot change connection string on a connection that has already been opened.");
-				m_connectionStringBuilder = new MySqlConnectionStringBuilder(value);
-				m_connectionSettings = new ConnectionSettings(m_connectionStringBuilder);
+				m_connectionString = value;
 			}
 		}
 
-		public override string Database => m_session?.DatabaseOverride ?? m_connectionSettings.Database;
+		public override string Database => m_session?.DatabaseOverride ?? GetConnectionSettings().Database;
 
 		public override ConnectionState State => m_connectionState;
 
-		public override string DataSource => (m_connectionSettings.ConnectionType == ConnectionType.Tcp
-			? string.Join(",", m_connectionSettings.HostNames)
-			: m_connectionSettings.UnixSocket) ?? "";
+		public override string DataSource => (GetConnectionSettings().ConnectionType == ConnectionType.Tcp
+			? string.Join(",", GetConnectionSettings().HostNames)
+			: GetConnectionSettings().UnixSocket) ?? "";
 
 		public override string ServerVersion => m_session.ServerVersion.OriginalString;
 
@@ -225,7 +229,7 @@ private static async Task ClearPoolAsync(MySqlConnection connection, IOBehavior
 			if (connection == null)
 				throw new ArgumentNullException(nameof(connection));
 
-			var pool = ConnectionPool.GetPool(connection.m_connectionSettings);
+			var pool = ConnectionPool.GetPool(connection.m_connectionString);
 			if (pool != null)
 				await pool.ClearAsync(ioBehavior, cancellationToken).ConfigureAwait(false);
 		}
@@ -288,7 +292,7 @@ internal void Cancel(MySqlCommand command)
 			try
 			{
 				// open a dedicated connection to the server to kill the active query
-				var csb = new MySqlConnectionStringBuilder(m_connectionStringBuilder.GetConnectionString(includePassword: true));
+				var csb = new MySqlConnectionStringBuilder(m_connectionString);
 				csb.Pooling = false;
 				if (m_session.IPAddress != null)
 					csb.Server = m_session.IPAddress.ToString();
@@ -343,10 +347,10 @@ internal async Task<CachedProcedure> GetCachedProcedure(IOBehavior ioBehavior, s
 		internal MySqlTransaction CurrentTransaction { get; set; }
 		internal bool AllowUserVariables => m_connectionSettings.AllowUserVariables;
 		internal bool ConvertZeroDateTime => m_connectionSettings.ConvertZeroDateTime;
-		internal int DefaultCommandTimeout => m_connectionSettings.DefaultCommandTimeout;
+		internal int DefaultCommandTimeout => GetConnectionSettings().DefaultCommandTimeout;
 		internal bool OldGuids => m_connectionSettings.OldGuids;
 		internal bool TreatTinyAsBoolean => m_connectionSettings.TreatTinyAsBoolean;
-		internal IOBehavior AsyncIOBehavior => m_connectionSettings.ForceSynchronous ? IOBehavior.Synchronous : IOBehavior.Asynchronous;
+		internal IOBehavior AsyncIOBehavior => GetConnectionSettings().ForceSynchronous ? IOBehavior.Synchronous : IOBehavior.Asynchronous;
 
 		internal MySqlSslMode SslMode => m_connectionSettings.SslMode;
 
@@ -367,20 +371,23 @@ internal void FinishQuerying()
 			m_activeReader = null;
 		}
 
-		private async Task<ServerSession> CreateSessionAsync(IOBehavior ioBehavior, CancellationToken cancellationToken)
+		private async Task<ServerSession> CreateSessionAsync(IOBehavior? ioBehavior, CancellationToken cancellationToken)
 		{
+			var pool = ConnectionPool.GetPool(m_connectionString);
+			m_connectionSettings = pool?.ConnectionSettings ?? new ConnectionSettings(new MySqlConnectionStringBuilder(m_connectionString));
+			var actualIOBehavior = ioBehavior ?? (m_connectionSettings.ForceSynchronous ? IOBehavior.Synchronous : IOBehavior.Asynchronous);
+
 			var connectTimeout = m_connectionSettings.ConnectionTimeout == 0 ? Timeout.InfiniteTimeSpan : TimeSpan.FromMilliseconds(m_connectionSettings.ConnectionTimeoutMilliseconds);
 			using (var timeoutSource = new CancellationTokenSource(connectTimeout))
 			using (var linkedSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeoutSource.Token))
 			{
 				try
 				{
 					// get existing session from the pool if possible
-					if (m_connectionSettings.Pooling)
+					if (pool != null)
 					{
-						var pool = ConnectionPool.GetPool(m_connectionSettings);
 						// this returns an open session
-						return await pool.GetSessionAsync(this, ioBehavior, linkedSource.Token).ConfigureAwait(false);
+						return await pool.GetSessionAsync(this, actualIOBehavior, linkedSource.Token).ConfigureAwait(false);
 					}
 					else
 					{
@@ -390,7 +397,7 @@ private async Task<ServerSession> CreateSessionAsync(IOBehavior ioBehavior, Canc
 
 						var session = new ServerSession();
 						Log.Info("Created new non-pooled Session{0}", session.Id);
-						await session.ConnectAsync(m_connectionSettings, loadBalancer, ioBehavior, linkedSource.Token).ConfigureAwait(false);
+						await session.ConnectAsync(m_connectionSettings, loadBalancer, actualIOBehavior, linkedSource.Token).ConfigureAwait(false);
 						return session;
 					}
 				}
@@ -472,9 +479,16 @@ private void CloseDatabase()
 			}
 		}
 
+		private ConnectionSettings GetConnectionSettings()
+		{
+			if (m_connectionSettings == null)
+				m_connectionSettings = new ConnectionSettings(new MySqlConnectionStringBuilder(m_connectionString));
+			return m_connectionSettings;
+		}
+
 		static readonly IMySqlConnectorLogger Log = MySqlConnectorLogManager.CreateLogger(nameof(MySqlConnection));
 
-		MySqlConnectionStringBuilder m_connectionStringBuilder;
+		string m_connectionString;
 		ConnectionSettings m_connectionSettings;
 		ServerSession m_session;
 		ConnectionState m_connectionState;

tests/Conformance.Tests/ConnectionTests.cs

@@ -10,6 +10,11 @@ public ConnectionTests(DbFactoryFixture fixture)
 		{
 		}
 
+		[Fact(Skip = "Throws MySqlException when it attempts to connect.")]
+		public override void Set_ConnectionString_throws_when_invalid()
+		{
+		}
+
 		[Fact(Skip = "Throws MySqlException when it attempts to connect, not InvalidOperationException before connecting")]
 		public override void Open_throws_when_no_connection_string()
 		{