Remove Func allocation when creating a ServerSession.

Introduce IConnectionPoolMetadata to unify the code between pooled and non-pooled sessions.

Signed-off-by: Bradley Grainger <[email protected]>

Author: bgrainger

src/MySqlConnector/Core/ConnectionPool.cs

@@ -8,10 +8,16 @@
 
 namespace MySqlConnector.Core;
 
-internal sealed class ConnectionPool : IDisposable
+internal sealed class ConnectionPool : IConnectionPoolMetadata, IDisposable
 {
 	public int Id { get; }
 
+	ConnectionPool? IConnectionPoolMetadata.ConnectionPool => this;
+
+	int IConnectionPoolMetadata.Generation => m_generation;
+
+	int IConnectionPoolMetadata.GetNewSessionId() => Interlocked.Increment(ref m_lastSessionId); 
+
 	public string? Name { get; }
 
 	public ConnectionSettings ConnectionSettings { get; }
@@ -107,11 +113,8 @@ public async ValueTask<ServerSession> GetSessionAsync(MySqlConnection connection
 			}
 
 			// create a new session
-			session = await ServerSession.ConnectAndRedirectAsync(
-					() => new ServerSession(m_connectionLogger, this, m_generation,
-						Interlocked.Increment(ref m_lastSessionId)), m_logger, Id, ConnectionSettings, m_loadBalancer,
-					connection, s_createdNewSession, startingTimestamp, activity, ioBehavior, cancellationToken)
-				.ConfigureAwait(false);
+			session = await ServerSession.ConnectAndRedirectAsync(m_connectionLogger, m_logger, this, ConnectionSettings, m_loadBalancer,
+				connection, s_createdNewSession, startingTimestamp, activity, ioBehavior, cancellationToken).ConfigureAwait(false);
 			AdjustHostConnectionCount(session, 1);
 			session.OwningConnection = new(connection);
 			int leasedSessionsCountNew;
@@ -407,11 +410,8 @@ private async Task CreateMinimumPooledSessions(MySqlConnection connection, IOBeh
 
 			try
 			{
-				var session = await ServerSession.ConnectAndRedirectAsync(
-					() => new ServerSession(m_connectionLogger, this, m_generation,
-						Interlocked.Increment(ref m_lastSessionId)), m_logger, Id, ConnectionSettings, m_loadBalancer,
-					connection, s_createdToReachMinimumPoolSize, Stopwatch.GetTimestamp(), null, ioBehavior,
-					cancellationToken).ConfigureAwait(false);
+				var session = await ServerSession.ConnectAndRedirectAsync(m_connectionLogger, m_logger, this, ConnectionSettings, m_loadBalancer,
+					connection, s_createdToReachMinimumPoolSize, Stopwatch.GetTimestamp(), null, ioBehavior, cancellationToken).ConfigureAwait(false);
 				AdjustHostConnectionCount(session, 1);
 				lock (m_sessions)
 					_ = m_sessions.AddFirst(session);

src/MySqlConnector/Core/IConnectionPoolMetadata.cs

@@ -0,0 +1,26 @@
+namespace MySqlConnector.Core;
+
+internal interface IConnectionPoolMetadata
+{
+	/// <summary>
+	/// Returns the <see cref="ConnectionPool"/> this <see cref="IConnectionPoolMetadata"/> is associated with,
+	/// or <c>null</c> if it represents a non-pooled connection.
+	/// </summary>
+	ConnectionPool? ConnectionPool { get; }
+
+	/// <summary>
+	/// Returns the ID of the connection pool, or 0 if this is a non-pooled connection.
+	/// </summary>
+	int Id { get; }
+
+	/// <summary>
+	/// Returns the generation of the connection pool, or 0 if this is a non-pooled connection.
+	/// </summary>
+	int Generation { get; }
+
+	/// <summary>
+	/// Returns a new session ID.
+	/// </summary>
+	/// <returns>A new session ID.</returns>
+	int GetNewSessionId();
+}

src/MySqlConnector/Core/NonPooledConnectionPoolMetadata.cs

@@ -0,0 +1,13 @@
+namespace MySqlConnector.Core;
+
+internal sealed class NonPooledConnectionPoolMetadata : IConnectionPoolMetadata
+{
+	public static IConnectionPoolMetadata Instance { get; } = new NonPooledConnectionPoolMetadata();
+
+	public ConnectionPool? ConnectionPool => null;
+	public int Id => 0;
+	public int Generation => 0;
+	public int GetNewSessionId() => Interlocked.Increment(ref m_lastId);
+
+	private int m_lastId;
+}

src/MySqlConnector/Core/ServerSession.cs

@@ -25,21 +25,16 @@ namespace MySqlConnector.Core;
 
 internal sealed partial class ServerSession : IServerCapabilities
 {
-	public ServerSession(ILogger logger)
-		: this(logger, null, 0, Interlocked.Increment(ref s_lastId))
-	{
-	}
-
-	public ServerSession(ILogger logger, ConnectionPool? pool, int poolGeneration, int id)
+	public ServerSession(ILogger logger, IConnectionPoolMetadata pool)
 	{
 		m_logger = logger;
 		m_lock = new();
 		m_payloadCache = new();
-		Id = (pool?.Id ?? 0) + "." + id;
+		Id = pool.Id + "." + pool.GetNewSessionId();
 		ServerVersion = ServerVersion.Empty;
 		CreatedTimestamp = Stopwatch.GetTimestamp();
-		Pool = pool;
-		PoolGeneration = poolGeneration;
+		Pool = pool.ConnectionPool;
+		PoolGeneration = pool.Generation;
 		HostName = "";
 		m_activityTags = [];
 		DataReader = new();
@@ -573,10 +568,11 @@ public async Task DisposeAsync(IOBehavior ioBehavior, CancellationToken cancella
 		}
 	}
 
-	public static async ValueTask<ServerSession> ConnectAndRedirectAsync(Func<ServerSession> createSession, ILogger logger, int? poolId, ConnectionSettings cs, ILoadBalancer? loadBalancer, MySqlConnection connection, Action<ILogger, int, string, Exception?>? logMessage, long startingTimestamp, Activity? activity, IOBehavior ioBehavior, CancellationToken cancellationToken)
+	public static async ValueTask<ServerSession> ConnectAndRedirectAsync(ILogger connectionLogger, ILogger poolLogger, IConnectionPoolMetadata pool, ConnectionSettings cs, ILoadBalancer? loadBalancer, MySqlConnection connection, Action<ILogger, int, string, Exception?>? logMessage, long startingTimestamp, Activity? activity, IOBehavior ioBehavior, CancellationToken cancellationToken)
 	{
-		var session = createSession();
-		if (poolId is not null && logger.IsEnabled(LogLevel.Debug)) logMessage!(logger, poolId.Value, session.Id, null);
+		var session = new ServerSession(connectionLogger, pool);
+		if (logMessage is not null && poolLogger.IsEnabled(LogLevel.Debug))
+			logMessage(poolLogger, pool.Id, session.Id, null);
 
 		string? redirectionUrl;
 		try
@@ -592,10 +588,10 @@ public static async ValueTask<ServerSession> ConnectAndRedirectAsync(Func<Server
 		Exception? redirectionException = null;
 		if (redirectionUrl is not null)
 		{
-			Log.HasServerRedirectionHeader(logger, session.Id, redirectionUrl);
+			Log.HasServerRedirectionHeader(poolLogger, session.Id, redirectionUrl);
 			if (cs.ServerRedirectionMode == MySqlServerRedirectionMode.Disabled)
 			{
-				Log.ServerRedirectionIsDisabled(logger, session.Id);
+				Log.ServerRedirectionIsDisabled(poolLogger, session.Id);
 				return session;
 			}
 
@@ -604,19 +600,19 @@ public static async ValueTask<ServerSession> ConnectAndRedirectAsync(Func<Server
 				if (host != cs.HostNames![0] || port != cs.Port || user != cs.UserID)
 				{
 					var redirectedSettings = cs.CloneWith(host, port, user);
-					Log.OpeningNewConnection(logger, host, port, user);
-					var redirectedSession = createSession();
+					Log.OpeningNewConnection(poolLogger, host, port, user);
+					var redirectedSession = new ServerSession(connectionLogger, pool);
 					try
 					{
 						await redirectedSession.ConnectAsync(redirectedSettings, connection, startingTimestamp, loadBalancer, activity, ioBehavior, cancellationToken).ConfigureAwait(false);
-						Log.ClosingSessionToUseRedirectedSession(logger, session.Id, redirectedSession.Id);
+						Log.ClosingSessionToUseRedirectedSession(poolLogger, session.Id, redirectedSession.Id);
 						await session.DisposeAsync(ioBehavior, cancellationToken).ConfigureAwait(false);
 						return redirectedSession;
 					}
 					catch (Exception ex)
 					{
 						redirectionException = ex;
-						Log.FailedToConnectRedirectedSession(logger, ex, redirectedSession.Id);
+						Log.FailedToConnectRedirectedSession(poolLogger, ex, redirectedSession.Id);
 						try
 						{
 							await redirectedSession.DisposeAsync(ioBehavior, cancellationToken).ConfigureAwait(false);
@@ -628,14 +624,14 @@ public static async ValueTask<ServerSession> ConnectAndRedirectAsync(Func<Server
 				}
 				else
 				{
-					Log.SessionAlreadyConnectedToServer(logger, session.Id);
+					Log.SessionAlreadyConnectedToServer(poolLogger, session.Id);
 				}
 			}
 		}
 
 		if (cs.ServerRedirectionMode == MySqlServerRedirectionMode.Required)
 		{
-			Log.RequiresServerRedirection(logger, session.Id);
+			Log.RequiresServerRedirection(poolLogger, session.Id);
 			throw new MySqlException(MySqlErrorCode.UnableToConnectToHost, "Server does not support redirection", redirectionException);
 		}
 		return session;
@@ -1991,7 +1987,6 @@ protected override void OnStatementBegin(int index)
 	private static readonly PayloadData s_sleepWithAttributesPayload = QueryPayload.Create(true, "SELECT SLEEP(0) INTO @\uE001MySqlConnector\uE001Sleep;"u8);
 	private static readonly PayloadData s_selectConnectionIdVersionNoAttributesPayload = QueryPayload.Create(false, "SELECT CONNECTION_ID(), VERSION();"u8);
 	private static readonly PayloadData s_selectConnectionIdVersionWithAttributesPayload = QueryPayload.Create(true, "SELECT CONNECTION_ID(), VERSION();"u8);
-	private static int s_lastId;
 
 	private readonly ILogger m_logger;
 	private readonly object m_lock;

src/MySqlConnector/MySqlConnection.cs

@@ -1064,7 +1064,7 @@ private async ValueTask<ServerSession> CreateSessionAsync(ConnectionPool? pool,
 				// only "fail over" and "random" load balancers supported without connection pooling
 				var loadBalancer = connectionSettings.LoadBalance == MySqlLoadBalance.Random && connectionSettings.HostNames!.Count > 1 ?
 					RandomLoadBalancer.Instance : FailOverLoadBalancer.Instance;
-				var session = await ServerSession.ConnectAndRedirectAsync(() => new ServerSession(m_logger), m_logger, null, connectionSettings, loadBalancer, this, null, startingTimestamp, null, actualIOBehavior, connectToken).ConfigureAwait(false);
+				var session = await ServerSession.ConnectAndRedirectAsync(m_logger, m_logger, NonPooledConnectionPoolMetadata.Instance, connectionSettings, loadBalancer, this, null, startingTimestamp, null, actualIOBehavior, connectToken).ConfigureAwait(false);
 				session.OwningConnection = new WeakReference<MySqlConnection>(this);
 				Log.CreatedNonPooledSession(m_logger, session.Id);
 				return session;