Replace all usages of DbConnectionFactory with SqlConnectionFactory let's see how this goes...

benrr101 · benrr101 · commit b75c7c0c0333 · 2025-06-23T16:40:20.000-05:00
diff --git a/src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/SqlClient/SqlConnectionHelper.cs b/src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/SqlClient/SqlConnectionHelper.cs
@@ -17,7 +17,7 @@ namespace Microsoft.Data.SqlClient
 {
     public sealed partial class SqlConnection : DbConnection
     {
-        private static readonly DbConnectionFactory s_connectionFactory = SqlConnectionFactory.SingletonInstance;
+        private static readonly SqlConnectionFactory s_connectionFactory = SqlConnectionFactory.SingletonInstance;
 
         private DbConnectionOptions _userConnectionOptions;
         private DbConnectionPoolGroup _poolGroup;
@@ -42,7 +42,7 @@ internal int CloseCount
             }
         }
 
-        internal DbConnectionFactory ConnectionFactory
+        internal SqlConnectionFactory ConnectionFactory
         {
             get
             {
diff --git a/src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/SqlClient/SqlInternalConnectionTds.cs b/src/Microsoft.Data.SqlClient/netcore/src/Microsoft/Data/SqlClient/SqlInternalConnectionTds.cs
@@ -3049,10 +3049,12 @@ internal bool ThreadHasParserLockForClose
             }
         }
 
-        internal override bool TryReplaceConnection(DbConnection outerConnection, DbConnectionFactory connectionFactory, TaskCompletionSource<DbConnectionInternal> retry, DbConnectionOptions userOptions)
-        {
-            return base.TryOpenConnectionInternal(outerConnection, connectionFactory, retry, userOptions);
-        }
+        internal override bool TryReplaceConnection(
+            DbConnection outerConnection,
+            SqlConnectionFactory connectionFactory,
+            TaskCompletionSource<DbConnectionInternal> retry,
+            DbConnectionOptions userOptions) =>
+            TryOpenConnectionInternal(outerConnection, connectionFactory, retry, userOptions);
     }
 
     internal sealed class ServerInfo
diff --git a/src/Microsoft.Data.SqlClient/netfx/src/Microsoft/Data/SqlClient/SqlConnectionHelper.cs b/src/Microsoft.Data.SqlClient/netfx/src/Microsoft/Data/SqlClient/SqlConnectionHelper.cs
@@ -18,7 +18,7 @@ namespace Microsoft.Data.SqlClient
 {
     public sealed partial class SqlConnection : DbConnection
     {
-        private static readonly DbConnectionFactory _connectionFactory = SqlConnectionFactory.SingletonInstance;
+        private static readonly SqlConnectionFactory _connectionFactory = SqlConnectionFactory.SingletonInstance;
         internal static readonly System.Security.CodeAccessPermission ExecutePermission = SqlConnection.CreateExecutePermission();
 
         private DbConnectionOptions _userConnectionOptions;
@@ -69,7 +69,7 @@ internal int CloseCount
             }
         }
 
-        internal DbConnectionFactory ConnectionFactory
+        internal SqlConnectionFactory ConnectionFactory
         {
             get
             {
diff --git a/src/Microsoft.Data.SqlClient/netfx/src/Microsoft/Data/SqlClient/SqlInternalConnectionTds.cs b/src/Microsoft.Data.SqlClient/netfx/src/Microsoft/Data/SqlClient/SqlInternalConnectionTds.cs
@@ -3081,10 +3081,12 @@ internal bool ThreadHasParserLockForClose
             }
         }
 
-        internal override bool TryReplaceConnection(DbConnection outerConnection, DbConnectionFactory connectionFactory, TaskCompletionSource<DbConnectionInternal> retry, DbConnectionOptions userOptions)
-        {
-            return base.TryOpenConnectionInternal(outerConnection, connectionFactory, retry, userOptions);
-        }
+        internal override bool TryReplaceConnection(
+            DbConnection outerConnection,
+            SqlConnectionFactory connectionFactory,
+            TaskCompletionSource<DbConnectionInternal> retry,
+            DbConnectionOptions userOptions) =>
+            base.TryOpenConnectionInternal(outerConnection, connectionFactory, retry, userOptions);
     }
 
     internal sealed class ServerInfo
diff --git a/src/Microsoft.Data.SqlClient/src/Microsoft/Data/ProviderBase/DbConnectionClosed.cs b/src/Microsoft.Data.SqlClient/src/Microsoft/Data/ProviderBase/DbConnectionClosed.cs
@@ -8,6 +8,7 @@
 using System.Threading.Tasks;
 using Microsoft.Data.Common;
 using Microsoft.Data.Common.ConnectionString;
+using Microsoft.Data.SqlClient;
 using Microsoft.Data.SqlClient.ConnectionPool;
 
 namespace Microsoft.Data.ProviderBase
@@ -27,7 +28,7 @@ protected DbConnectionClosed(ConnectionState state, bool hidePassword, bool allo
 
         public override void ChangeDatabase(string database) => throw ADP.ClosedConnectionError();
 
-        internal override void CloseConnection(DbConnection owningObject, DbConnectionFactory connectionFactory)
+        internal override void CloseConnection(DbConnection owningObject, SqlConnectionFactory connectionFactory)
         {
             // not much to do here...
         }
@@ -36,13 +37,22 @@ internal override void CloseConnection(DbConnection owningObject, DbConnectionFa
 
         public override void EnlistTransaction(System.Transactions.Transaction transaction) => throw ADP.ClosedConnectionError();
 
-        protected internal override DataTable GetSchema(DbConnectionFactory factory, DbConnectionPoolGroup poolGroup, DbConnection outerConnection, string collectionName, string[] restrictions)
+        protected internal override DataTable GetSchema(
+            SqlConnectionFactory factory,
+            DbConnectionPoolGroup poolGroup,
+            DbConnection outerConnection,
+            string collectionName,
+            string[] restrictions)
             => throw ADP.ClosedConnectionError();
 
         protected override DbReferenceCollection CreateReferenceCollection() => throw ADP.ClosedConnectionError();
 
-        internal override bool TryOpenConnection(DbConnection outerConnection, DbConnectionFactory connectionFactory, TaskCompletionSource<DbConnectionInternal> retry, DbConnectionOptions userOptions)
-            => base.TryOpenConnectionInternal(outerConnection, connectionFactory, retry, userOptions);
+        internal override bool TryOpenConnection(
+            DbConnection outerConnection,
+            SqlConnectionFactory connectionFactory,
+            TaskCompletionSource<DbConnectionInternal> retry,
+            DbConnectionOptions userOptions) =>
+            TryOpenConnectionInternal(outerConnection, connectionFactory, retry, userOptions);
     }
 
     internal abstract class DbConnectionBusy : DbConnectionClosed
@@ -51,7 +61,11 @@ protected DbConnectionBusy(ConnectionState state) : base(state, true, false)
         {
         }
 
-        internal override bool TryOpenConnection(DbConnection outerConnection, DbConnectionFactory connectionFactory, TaskCompletionSource<DbConnectionInternal> retry, DbConnectionOptions userOptions)
+        internal override bool TryOpenConnection(
+            DbConnection outerConnection,
+            SqlConnectionFactory connectionFactory,
+            TaskCompletionSource<DbConnectionInternal> retry,
+            DbConnectionOptions userOptions)
             => throw ADP.ConnectionAlreadyOpen(State);
     }
 
@@ -84,15 +98,23 @@ private DbConnectionClosedConnecting() : base(ConnectionState.Connecting)
         {
         }
 
-        internal override void CloseConnection(DbConnection owningObject, DbConnectionFactory connectionFactory)
+        internal override void CloseConnection(DbConnection owningObject, SqlConnectionFactory connectionFactory)
         {
             connectionFactory.SetInnerConnectionTo(owningObject, DbConnectionClosedPreviouslyOpened.SingletonInstance);
         }
 
-        internal override bool TryReplaceConnection(DbConnection outerConnection, DbConnectionFactory connectionFactory, TaskCompletionSource<DbConnectionInternal> retry, DbConnectionOptions userOptions)
-            => TryOpenConnection(outerConnection, connectionFactory, retry, userOptions);
-
-        internal override bool TryOpenConnection(DbConnection outerConnection, DbConnectionFactory connectionFactory, TaskCompletionSource<DbConnectionInternal> retry, DbConnectionOptions userOptions)
+        internal override bool TryReplaceConnection(
+            DbConnection outerConnection,
+            SqlConnectionFactory connectionFactory,
+            TaskCompletionSource<DbConnectionInternal> retry,
+            DbConnectionOptions userOptions) =>
+            TryOpenConnection(outerConnection, connectionFactory, retry, userOptions);
+
+        internal override bool TryOpenConnection(
+            DbConnection outerConnection,
+            SqlConnectionFactory connectionFactory,
+            TaskCompletionSource<DbConnectionInternal> retry,
+            DbConnectionOptions userOptions)
         {
             if (retry == null || !retry.Task.IsCompleted)
             {
@@ -137,7 +159,11 @@ private DbConnectionClosedPreviouslyOpened() : base(ConnectionState.Closed, true
         {
         }
 
-        internal override bool TryReplaceConnection(DbConnection outerConnection, DbConnectionFactory connectionFactory, TaskCompletionSource<DbConnectionInternal> retry, DbConnectionOptions userOptions)
-            => TryOpenConnection(outerConnection, connectionFactory, retry, userOptions);
+        internal override bool TryReplaceConnection(
+            DbConnection outerConnection,
+            SqlConnectionFactory connectionFactory,
+            TaskCompletionSource<DbConnectionInternal> retry,
+            DbConnectionOptions userOptions) =>
+            TryOpenConnection(outerConnection, connectionFactory, retry, userOptions);
     }
 }
diff --git a/src/Microsoft.Data.SqlClient/src/Microsoft/Data/ProviderBase/DbConnectionFactory.cs b/src/Microsoft.Data.SqlClient/src/Microsoft/Data/ProviderBase/DbConnectionFactory.cs
@@ -50,7 +50,7 @@ public abstract DbProviderFactory ProviderFactory
 
         public void ClearAllPools()
         {
-            using (TryEventScope.Create(nameof(DbConnectionFactory)))
+            using (TryEventScope.Create(nameof(SqlConnectionFactory)))
             {
                 Dictionary<DbConnectionPoolKey, DbConnectionPoolGroup> connectionPoolGroups = _connectionPoolGroups;
                 foreach (KeyValuePair<DbConnectionPoolKey, DbConnectionPoolGroup> entry in connectionPoolGroups)
@@ -399,7 +399,7 @@ private IDbConnectionPool GetConnectionPool(DbConnection owningObject, DbConnect
                 Debug.Assert(connectionPoolGroup != null, "null connectionPoolGroup?");
                 SetConnectionPoolGroup(owningObject, connectionPoolGroup);
             }
-            IDbConnectionPool connectionPool = connectionPoolGroup.GetConnectionPool(this);
+            IDbConnectionPool connectionPool = connectionPoolGroup.GetConnectionPool((SqlConnectionFactory)this);
             return connectionPool;
         }
 
diff --git a/src/Microsoft.Data.SqlClient/src/Microsoft/Data/ProviderBase/DbConnectionInternal.cs b/src/Microsoft.Data.SqlClient/src/Microsoft/Data/ProviderBase/DbConnectionInternal.cs
@@ -398,7 +398,7 @@ internal void CleanupConnectionOnTransactionCompletion(Transaction transaction)
             pool?.TransactionEnded(transaction, this);
         }
 
-        internal virtual void CloseConnection(DbConnection owningObject, DbConnectionFactory connectionFactory)
+        internal virtual void CloseConnection(DbConnection owningObject, SqlConnectionFactory connectionFactory)
         {
             // The implementation here is the implementation required for the
             // "open" internal connections, since our own private "closed"
@@ -708,7 +708,7 @@ internal void MakePooledConnection(IDbConnectionPool connectionPool)
         internal void NotifyWeakReference(int message) =>
             ReferenceCollection?.Notify(message);
 
-        internal virtual void OpenConnection(DbConnection outerConnection, DbConnectionFactory connectionFactory)
+        internal virtual void OpenConnection(DbConnection outerConnection, SqlConnectionFactory connectionFactory)
         {
             if (!TryOpenConnection(outerConnection, connectionFactory, null, null))
             {
@@ -814,7 +814,7 @@ internal void SetInStasis()
         /// </remarks>
         internal virtual bool TryOpenConnection(
             DbConnection outerConnection,
-            DbConnectionFactory connectionFactory,
+            SqlConnectionFactory connectionFactory,
             TaskCompletionSource<DbConnectionInternal> retry,
             DbConnectionOptions userOptions)
         {
@@ -823,7 +823,7 @@ internal virtual bool TryOpenConnection(
 
         internal virtual bool TryReplaceConnection(
             DbConnection outerConnection,
-            DbConnectionFactory connectionFactory,
+            SqlConnectionFactory connectionFactory,
             TaskCompletionSource<DbConnectionInternal> retry,
             DbConnectionOptions userOptions)
         {
@@ -871,7 +871,7 @@ protected internal void DoomThisConnection()
         }
 
         protected internal virtual DataTable GetSchema(
-            DbConnectionFactory factory,
+            SqlConnectionFactory factory,
             DbConnectionPoolGroup poolGroup,
             DbConnection outerConnection,
             string collectionName,
@@ -901,7 +901,11 @@ protected virtual void ReleaseAdditionalLocksForClose(bool lockToken)
             // No additional locks in default implementation
         }
 
-        protected bool TryOpenConnectionInternal(DbConnection outerConnection, DbConnectionFactory connectionFactory, TaskCompletionSource<DbConnectionInternal> retry, DbConnectionOptions userOptions)
+        protected bool TryOpenConnectionInternal(
+            DbConnection outerConnection,
+            SqlConnectionFactory connectionFactory,
+            TaskCompletionSource<DbConnectionInternal> retry,
+            DbConnectionOptions userOptions)
         {
             // ?->Connecting: prevent set_ConnectionString during Open
             if (connectionFactory.SetInnerConnectionFrom(outerConnection, DbConnectionClosedConnecting.SingletonInstance, this))
diff --git a/src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/ConnectionPool/ChannelDbConnectionPool.cs b/src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/ConnectionPool/ChannelDbConnectionPool.cs
@@ -25,7 +25,7 @@ internal sealed class ChannelDbConnectionPool : IDbConnectionPool
         public ConcurrentDictionary<DbConnectionPoolAuthenticationContextKey, DbConnectionPoolAuthenticationContext> AuthenticationContexts => throw new NotImplementedException();
 
         /// <inheritdoc />
-        public DbConnectionFactory ConnectionFactory => throw new NotImplementedException();
+        public SqlConnectionFactory ConnectionFactory => throw new NotImplementedException();
 
         /// <inheritdoc />
         public int Count => throw new NotImplementedException();
diff --git a/src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/ConnectionPool/DbConnectionPoolGroup.cs b/src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/ConnectionPool/DbConnectionPoolGroup.cs
@@ -132,7 +132,7 @@ internal int Clear()
                     IDbConnectionPool pool = entry.Value;
                     if (pool != null)
                     {
-                        DbConnectionFactory connectionFactory = pool.ConnectionFactory;
+                        SqlConnectionFactory connectionFactory = pool.ConnectionFactory;
 
                         connectionFactory.QueuePoolForRelease(pool, true);
                     }
@@ -143,7 +143,7 @@ internal int Clear()
             return _poolCollection.Count;
         }
 
-        internal IDbConnectionPool GetConnectionPool(DbConnectionFactory connectionFactory)
+        internal IDbConnectionPool GetConnectionPool(SqlConnectionFactory connectionFactory)
         {
             // When this method returns null it indicates that the connection
             // factory should not use pooling.
@@ -282,7 +282,7 @@ internal bool Prune()
                                 // to use it while we're processing and finally we put the
                                 // pool into a list of pools to be released when they
                                 // are completely empty.
-                                DbConnectionFactory connectionFactory = pool.ConnectionFactory;
+                                SqlConnectionFactory connectionFactory = pool.ConnectionFactory;
 
                                 connectionFactory.QueuePoolForRelease(pool, false);
                             }
diff --git a/src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/ConnectionPool/IDbConnectionPool.cs b/src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/ConnectionPool/IDbConnectionPool.cs
@@ -28,7 +28,7 @@ internal interface IDbConnectionPool
         /// <summary>
         /// Gets the factory used to create database connections.
         /// </summary>
-        DbConnectionFactory ConnectionFactory { get; }
+        SqlConnectionFactory ConnectionFactory { get; }
 
         /// <summary>
         /// The number of connections currently managed by the pool.
diff --git a/src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/ConnectionPool/WaitHandleDbConnectionPool.cs b/src/Microsoft.Data.SqlClient/src/Microsoft/Data/SqlClient/ConnectionPool/WaitHandleDbConnectionPool.cs
@@ -403,7 +403,7 @@ internal WaitHandle[] GetHandles(bool withCreate)
         private readonly int _cleanupWait;
         private readonly DbConnectionPoolIdentity _identity;
 
-        private readonly DbConnectionFactory _connectionFactory;
+        private readonly SqlConnectionFactory _connectionFactory;
         private readonly DbConnectionPoolGroup _connectionPoolGroup;
         private readonly DbConnectionPoolGroupOptions _connectionPoolGroupOptions;
         private DbConnectionPoolProviderInfo _connectionPoolProviderInfo;
@@ -439,10 +439,10 @@ internal WaitHandle[] GetHandles(bool withCreate)
 
         // only created by DbConnectionPoolGroup.GetConnectionPool
         internal WaitHandleDbConnectionPool(
-                            DbConnectionFactory connectionFactory,
-                            DbConnectionPoolGroup connectionPoolGroup,
-                            DbConnectionPoolIdentity identity,
-                            DbConnectionPoolProviderInfo connectionPoolProviderInfo)
+            SqlConnectionFactory connectionFactory,
+            DbConnectionPoolGroup connectionPoolGroup,
+            DbConnectionPoolIdentity identity,
+            DbConnectionPoolProviderInfo connectionPoolProviderInfo)
         {
             Debug.Assert(connectionPoolGroup != null, "null connectionPoolGroup");
 
@@ -492,7 +492,7 @@ private int CreationTimeout
 
         public int Count => _totalObjects;
 
-        public DbConnectionFactory ConnectionFactory => _connectionFactory;
+        public SqlConnectionFactory ConnectionFactory => _connectionFactory;
 
         public bool ErrorOccurred => _errorOccurred;
 

Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ namespace Microsoft.Data.SqlClient`
`17`	`17`	`{`
`18`	`18`	`public sealed partial class SqlConnection : DbConnection`
`19`	`19`	`{`
`20`		`- private static readonly DbConnectionFactory s_connectionFactory = SqlConnectionFactory.SingletonInstance;`
	`20`	`+ private static readonly SqlConnectionFactory s_connectionFactory = SqlConnectionFactory.SingletonInstance;`
`21`	`21`
`22`	`22`	`private DbConnectionOptions _userConnectionOptions;`
`23`	`23`	`private DbConnectionPoolGroup _poolGroup;`
`@@ -42,7 +42,7 @@ internal int CloseCount`
`42`	`42`	`}`
`43`	`43`	`}`
`44`	`44`
`45`		`- internal DbConnectionFactory ConnectionFactory`
	`45`	`+ internal SqlConnectionFactory ConnectionFactory`
`46`	`46`	`{`
`47`	`47`	`get`
`48`	`48`	`{`
Original file line number	Diff line number	Diff line change
`@@ -3049,10 +3049,12 @@ internal bool ThreadHasParserLockForClose`
`3049`	`3049`	`}`
`3050`	`3050`	`}`
`3051`	`3051`
`3052`		`- internal override bool TryReplaceConnection(DbConnection outerConnection, DbConnectionFactory connectionFactory, TaskCompletionSource<DbConnectionInternal> retry, DbConnectionOptions userOptions)`
`3053`		`- {`
`3054`		`- return base.TryOpenConnectionInternal(outerConnection, connectionFactory, retry, userOptions);`
`3055`		`- }`
	`3052`	`+ internal override bool TryReplaceConnection(`
	`3053`	`+ DbConnection outerConnection,`
	`3054`	`+ SqlConnectionFactory connectionFactory,`
	`3055`	`+ TaskCompletionSource<DbConnectionInternal> retry,`
	`3056`	`+ DbConnectionOptions userOptions) =>`
	`3057`	`+ TryOpenConnectionInternal(outerConnection, connectionFactory, retry, userOptions);`
`3056`	`3058`	`}`
`3057`	`3059`
`3058`	`3060`	`internal sealed class ServerInfo`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ namespace Microsoft.Data.SqlClient`
`18`	`18`	`{`
`19`	`19`	`public sealed partial class SqlConnection : DbConnection`
`20`	`20`	`{`
`21`		`- private static readonly DbConnectionFactory _connectionFactory = SqlConnectionFactory.SingletonInstance;`
	`21`	`+ private static readonly SqlConnectionFactory _connectionFactory = SqlConnectionFactory.SingletonInstance;`
`22`	`22`	`internal static readonly System.Security.CodeAccessPermission ExecutePermission = SqlConnection.CreateExecutePermission();`
`23`	`23`
`24`	`24`	`private DbConnectionOptions _userConnectionOptions;`
`@@ -69,7 +69,7 @@ internal int CloseCount`
`69`	`69`	`}`
`70`	`70`	`}`
`71`	`71`
`72`		`- internal DbConnectionFactory ConnectionFactory`
	`72`	`+ internal SqlConnectionFactory ConnectionFactory`
`73`	`73`	`{`
`74`	`74`	`get`
`75`	`75`	`{`
Original file line number	Diff line number	Diff line change
`@@ -3081,10 +3081,12 @@ internal bool ThreadHasParserLockForClose`
`3081`	`3081`	`}`
`3082`	`3082`	`}`
`3083`	`3083`
`3084`		`- internal override bool TryReplaceConnection(DbConnection outerConnection, DbConnectionFactory connectionFactory, TaskCompletionSource<DbConnectionInternal> retry, DbConnectionOptions userOptions)`
`3085`		`- {`
`3086`		`- return base.TryOpenConnectionInternal(outerConnection, connectionFactory, retry, userOptions);`
`3087`		`- }`
	`3084`	`+ internal override bool TryReplaceConnection(`
	`3085`	`+ DbConnection outerConnection,`
	`3086`	`+ SqlConnectionFactory connectionFactory,`
	`3087`	`+ TaskCompletionSource<DbConnectionInternal> retry,`
	`3088`	`+ DbConnectionOptions userOptions) =>`
	`3089`	`+ base.TryOpenConnectionInternal(outerConnection, connectionFactory, retry, userOptions);`
`3088`	`3090`	`}`
`3089`	`3091`
`3090`	`3092`	`internal sealed class ServerInfo`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,7 @@`
`8`	`8`	`using System.Threading.Tasks;`
`9`	`9`	`using Microsoft.Data.Common;`
`10`	`10`	`using Microsoft.Data.Common.ConnectionString;`
	`11`	`+using Microsoft.Data.SqlClient;`
`11`	`12`	`using Microsoft.Data.SqlClient.ConnectionPool;`
`12`	`13`
`13`	`14`	`namespace Microsoft.Data.ProviderBase`
`@@ -27,7 +28,7 @@ protected DbConnectionClosed(ConnectionState state, bool hidePassword, bool allo`
`27`	`28`
`28`	`29`	`public override void ChangeDatabase(string database) => throw ADP.ClosedConnectionError();`
`29`	`30`
`30`		`- internal override void CloseConnection(DbConnection owningObject, DbConnectionFactory connectionFactory)`
	`31`	`+ internal override void CloseConnection(DbConnection owningObject, SqlConnectionFactory connectionFactory)`
`31`	`32`	`{`
`32`	`33`	`// not much to do here...`
`33`	`34`	`}`
`@@ -36,13 +37,22 @@ internal override void CloseConnection(DbConnection owningObject, DbConnectionFa`
`36`	`37`
`37`	`38`	`public override void EnlistTransaction(System.Transactions.Transaction transaction) => throw ADP.ClosedConnectionError();`
`38`	`39`
`39`		`- protected internal override DataTable GetSchema(DbConnectionFactory factory, DbConnectionPoolGroup poolGroup, DbConnection outerConnection, string collectionName, string[] restrictions)`
	`40`	`+ protected internal override DataTable GetSchema(`
	`41`	`+ SqlConnectionFactory factory,`
	`42`	`+ DbConnectionPoolGroup poolGroup,`
	`43`	`+ DbConnection outerConnection,`
	`44`	`+ string collectionName,`
	`45`	`+ string[] restrictions)`
`40`	`46`	`=> throw ADP.ClosedConnectionError();`
`41`	`47`
`42`	`48`	`protected override DbReferenceCollection CreateReferenceCollection() => throw ADP.ClosedConnectionError();`
`43`	`49`
`44`		`- internal override bool TryOpenConnection(DbConnection outerConnection, DbConnectionFactory connectionFactory, TaskCompletionSource<DbConnectionInternal> retry, DbConnectionOptions userOptions)`
`45`		`- => base.TryOpenConnectionInternal(outerConnection, connectionFactory, retry, userOptions);`
	`50`	`+ internal override bool TryOpenConnection(`
	`51`	`+ DbConnection outerConnection,`
	`52`	`+ SqlConnectionFactory connectionFactory,`
	`53`	`+ TaskCompletionSource<DbConnectionInternal> retry,`
	`54`	`+ DbConnectionOptions userOptions) =>`
	`55`	`+ TryOpenConnectionInternal(outerConnection, connectionFactory, retry, userOptions);`
`46`	`56`	`}`
`47`	`57`
`48`	`58`	`internal abstract class DbConnectionBusy : DbConnectionClosed`
`@@ -51,7 +61,11 @@ protected DbConnectionBusy(ConnectionState state) : base(state, true, false)`
`51`	`61`	`{`
`52`	`62`	`}`
`53`	`63`
`54`		`- internal override bool TryOpenConnection(DbConnection outerConnection, DbConnectionFactory connectionFactory, TaskCompletionSource<DbConnectionInternal> retry, DbConnectionOptions userOptions)`
	`64`	`+ internal override bool TryOpenConnection(`
	`65`	`+ DbConnection outerConnection,`
	`66`	`+ SqlConnectionFactory connectionFactory,`
	`67`	`+ TaskCompletionSource<DbConnectionInternal> retry,`
	`68`	`+ DbConnectionOptions userOptions)`
`55`	`69`	`=> throw ADP.ConnectionAlreadyOpen(State);`
`56`	`70`	`}`
`57`	`71`
`@@ -84,15 +98,23 @@ private DbConnectionClosedConnecting() : base(ConnectionState.Connecting)`
`84`	`98`	`{`
`85`	`99`	`}`
`86`	`100`
`87`		`- internal override void CloseConnection(DbConnection owningObject, DbConnectionFactory connectionFactory)`
	`101`	`+ internal override void CloseConnection(DbConnection owningObject, SqlConnectionFactory connectionFactory)`
`88`	`102`	`{`
`89`	`103`	`connectionFactory.SetInnerConnectionTo(owningObject, DbConnectionClosedPreviouslyOpened.SingletonInstance);`
`90`	`104`	`}`
`91`	`105`
`92`		`- internal override bool TryReplaceConnection(DbConnection outerConnection, DbConnectionFactory connectionFactory, TaskCompletionSource<DbConnectionInternal> retry, DbConnectionOptions userOptions)`
`93`		`- => TryOpenConnection(outerConnection, connectionFactory, retry, userOptions);`
`94`		`-`
`95`		`- internal override bool TryOpenConnection(DbConnection outerConnection, DbConnectionFactory connectionFactory, TaskCompletionSource<DbConnectionInternal> retry, DbConnectionOptions userOptions)`
	`106`	`+ internal override bool TryReplaceConnection(`
	`107`	`+ DbConnection outerConnection,`
	`108`	`+ SqlConnectionFactory connectionFactory,`
	`109`	`+ TaskCompletionSource<DbConnectionInternal> retry,`
	`110`	`+ DbConnectionOptions userOptions) =>`
	`111`	`+ TryOpenConnection(outerConnection, connectionFactory, retry, userOptions);`
	`112`	`+`
	`113`	`+ internal override bool TryOpenConnection(`
	`114`	`+ DbConnection outerConnection,`
	`115`	`+ SqlConnectionFactory connectionFactory,`
	`116`	`+ TaskCompletionSource<DbConnectionInternal> retry,`
	`117`	`+ DbConnectionOptions userOptions)`
`96`	`118`	`{`
`97`	`119`	`if (retry == null \|\| !retry.Task.IsCompleted)`
`98`	`120`	`{`
`@@ -137,7 +159,11 @@ private DbConnectionClosedPreviouslyOpened() : base(ConnectionState.Closed, true`
`137`	`159`	`{`
`138`	`160`	`}`
`139`	`161`
`140`		`- internal override bool TryReplaceConnection(DbConnection outerConnection, DbConnectionFactory connectionFactory, TaskCompletionSource<DbConnectionInternal> retry, DbConnectionOptions userOptions)`
`141`		`- => TryOpenConnection(outerConnection, connectionFactory, retry, userOptions);`
	`162`	`+ internal override bool TryReplaceConnection(`
	`163`	`+ DbConnection outerConnection,`
	`164`	`+ SqlConnectionFactory connectionFactory,`
	`165`	`+ TaskCompletionSource<DbConnectionInternal> retry,`
	`166`	`+ DbConnectionOptions userOptions) =>`
	`167`	`+ TryOpenConnection(outerConnection, connectionFactory, retry, userOptions);`
`142`	`168`	`}`
`143`	`169`	`}`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ public abstract DbProviderFactory ProviderFactory`
`50`	`50`
`51`	`51`	`public void ClearAllPools()`
`52`	`52`	`{`
`53`		`- using (TryEventScope.Create(nameof(DbConnectionFactory)))`
	`53`	`+ using (TryEventScope.Create(nameof(SqlConnectionFactory)))`
`54`	`54`	`{`
`55`	`55`	`Dictionary<DbConnectionPoolKey, DbConnectionPoolGroup> connectionPoolGroups = _connectionPoolGroups;`
`56`	`56`	`foreach (KeyValuePair<DbConnectionPoolKey, DbConnectionPoolGroup> entry in connectionPoolGroups)`
`@@ -399,7 +399,7 @@ private IDbConnectionPool GetConnectionPool(DbConnection owningObject, DbConnect`
`399`	`399`	`Debug.Assert(connectionPoolGroup != null, "null connectionPoolGroup?");`
`400`	`400`	`SetConnectionPoolGroup(owningObject, connectionPoolGroup);`
`401`	`401`	`}`
`402`		`- IDbConnectionPool connectionPool = connectionPoolGroup.GetConnectionPool(this);`
	`402`	`+ IDbConnectionPool connectionPool = connectionPoolGroup.GetConnectionPool((SqlConnectionFactory)this);`
`403`	`403`	`return connectionPool;`
`404`	`404`	`}`
`405`	`405`
Original file line number	Diff line number	Diff line change
`@@ -398,7 +398,7 @@ internal void CleanupConnectionOnTransactionCompletion(Transaction transaction)`
`398`	`398`	`pool?.TransactionEnded(transaction, this);`
`399`	`399`	`}`
`400`	`400`
`401`		`- internal virtual void CloseConnection(DbConnection owningObject, DbConnectionFactory connectionFactory)`
	`401`	`+ internal virtual void CloseConnection(DbConnection owningObject, SqlConnectionFactory connectionFactory)`
`402`	`402`	`{`
`403`	`403`	`// The implementation here is the implementation required for the`
`404`	`404`	`// "open" internal connections, since our own private "closed"`
`@@ -708,7 +708,7 @@ internal void MakePooledConnection(IDbConnectionPool connectionPool)`
`708`	`708`	`internal void NotifyWeakReference(int message) =>`
`709`	`709`	`ReferenceCollection?.Notify(message);`
`710`	`710`
`711`		`- internal virtual void OpenConnection(DbConnection outerConnection, DbConnectionFactory connectionFactory)`
	`711`	`+ internal virtual void OpenConnection(DbConnection outerConnection, SqlConnectionFactory connectionFactory)`
`712`	`712`	`{`
`713`	`713`	`if (!TryOpenConnection(outerConnection, connectionFactory, null, null))`
`714`	`714`	`{`
`@@ -814,7 +814,7 @@ internal void SetInStasis()`
`814`	`814`	`/// </remarks>`
`815`	`815`	`internal virtual bool TryOpenConnection(`
`816`	`816`	`DbConnection outerConnection,`
`817`		`- DbConnectionFactory connectionFactory,`
	`817`	`+ SqlConnectionFactory connectionFactory,`
`818`	`818`	`TaskCompletionSource<DbConnectionInternal> retry,`
`819`	`819`	`DbConnectionOptions userOptions)`
`820`	`820`	`{`
`@@ -823,7 +823,7 @@ internal virtual bool TryOpenConnection(`
`823`	`823`
`824`	`824`	`internal virtual bool TryReplaceConnection(`
`825`	`825`	`DbConnection outerConnection,`
`826`		`- DbConnectionFactory connectionFactory,`
	`826`	`+ SqlConnectionFactory connectionFactory,`
`827`	`827`	`TaskCompletionSource<DbConnectionInternal> retry,`
`828`	`828`	`DbConnectionOptions userOptions)`
`829`	`829`	`{`
`@@ -871,7 +871,7 @@ protected internal void DoomThisConnection()`
`871`	`871`	`}`
`872`	`872`
`873`	`873`	`protected internal virtual DataTable GetSchema(`
`874`		`- DbConnectionFactory factory,`
	`874`	`+ SqlConnectionFactory factory,`
`875`	`875`	`DbConnectionPoolGroup poolGroup,`
`876`	`876`	`DbConnection outerConnection,`
`877`	`877`	`string collectionName,`
`@@ -901,7 +901,11 @@ protected virtual void ReleaseAdditionalLocksForClose(bool lockToken)`
`901`	`901`	`// No additional locks in default implementation`
`902`	`902`	`}`
`903`	`903`
`904`		`- protected bool TryOpenConnectionInternal(DbConnection outerConnection, DbConnectionFactory connectionFactory, TaskCompletionSource<DbConnectionInternal> retry, DbConnectionOptions userOptions)`
	`904`	`+ protected bool TryOpenConnectionInternal(`
	`905`	`+ DbConnection outerConnection,`
	`906`	`+ SqlConnectionFactory connectionFactory,`
	`907`	`+ TaskCompletionSource<DbConnectionInternal> retry,`
	`908`	`+ DbConnectionOptions userOptions)`
`905`	`909`	`{`
`906`	`910`	`// ?->Connecting: prevent set_ConnectionString during Open`
`907`	`911`	`if (connectionFactory.SetInnerConnectionFrom(outerConnection, DbConnectionClosedConnecting.SingletonInstance, this))`
Original file line number	Diff line number	Diff line change
`@@ -132,7 +132,7 @@ internal int Clear()`
`132`	`132`	`IDbConnectionPool pool = entry.Value;`
`133`	`133`	`if (pool != null)`
`134`	`134`	`{`
`135`		`- DbConnectionFactory connectionFactory = pool.ConnectionFactory;`
	`135`	`+ SqlConnectionFactory connectionFactory = pool.ConnectionFactory;`
`136`	`136`
`137`	`137`	`connectionFactory.QueuePoolForRelease(pool, true);`
`138`	`138`	`}`
`@@ -143,7 +143,7 @@ internal int Clear()`
`143`	`143`	`return _poolCollection.Count;`
`144`	`144`	`}`
`145`	`145`
`146`		`- internal IDbConnectionPool GetConnectionPool(DbConnectionFactory connectionFactory)`
	`146`	`+ internal IDbConnectionPool GetConnectionPool(SqlConnectionFactory connectionFactory)`
`147`	`147`	`{`
`148`	`148`	`// When this method returns null it indicates that the connection`
`149`	`149`	`// factory should not use pooling.`
`@@ -282,7 +282,7 @@ internal bool Prune()`
`282`	`282`	`// to use it while we're processing and finally we put the`
`283`	`283`	`// pool into a list of pools to be released when they`
`284`	`284`	`// are completely empty.`
`285`		`- DbConnectionFactory connectionFactory = pool.ConnectionFactory;`
	`285`	`+ SqlConnectionFactory connectionFactory = pool.ConnectionFactory;`
`286`	`286`
`287`	`287`	`connectionFactory.QueuePoolForRelease(pool, false);`
`288`	`288`	`}`