internal DbConnectionPool GetConnectionPool(DbConnectionFactory connectionFactory)
{
object obj2 = null;
if (this._poolGroupOptions != null)
{
DbConnectionPoolIdentity noIdentity = DbConnectionPoolIdentity.NoIdentity;
if (this._poolGroupOptions.PoolByIdentity)
{
noIdentity = DbConnectionPoolIdentity.GetCurrent();
if (noIdentity.IsRestricted)
{
noIdentity = null;
}
}
if (noIdentity != null)
{
obj2 = this._poolCollection[noIdentity];
if (obj2 == null)
{
DbConnectionPoolProviderInfo connectionPoolProviderInfo = connectionFactory.CreateConnectionPoolProviderInfo(this.ConnectionOptions);
DbConnectionPool pool = new DbConnectionPool(connectionFactory, this, noIdentity, connectionPoolProviderInfo);
lock (this)
{
HybridDictionary dictionary = this._poolCollection;
obj2 = dictionary[noIdentity];
if ((obj2 == null) && this.MarkPoolGroupAsActive())
{
pool.Startup();
HybridDictionary dictionary2 = new HybridDictionary(1 + dictionary.Count, false);
foreach (DictionaryEntry entry in dictionary)
{
dictionary2.Add(entry.Key, entry.Value);
}
dictionary2.Add(noIdentity, pool);
connectionFactory.PerformanceCounters.NumberOfActiveConnectionPools.Increment();
this._poolCollection = dictionary2;
this._poolCount = dictionary2.Count;
obj2 = pool;
pool = null;
}
}
if (pool != null)
{
pool.Shutdown();
}
}
}
}
if (obj2 == null)
{
lock (this)
{
this.MarkPoolGroupAsActive();
}
}
return((DbConnectionPool)obj2);
}
internal DbConnectionPool GetConnectionPool(DbConnectionFactory connectionFactory)
{
// When this method returns null it indicates that the connection
// factory should not use pooling.
// We don't support connection pooling on Win9x; it lacks too
// many of the APIs we require.
// PoolGroupOptions will only be null when we're not supposed to pool
// connections.
DbConnectionPool pool = null;
if (null != _poolGroupOptions)
{
Debug.Assert(ADP.IsWindowsNT, "should not be pooling on Win9x");
DbConnectionPoolIdentity currentIdentity = DbConnectionPoolIdentity.NoIdentity;
if (_poolGroupOptions.PoolByIdentity)
{
// if we're pooling by identity (because integrated security is
// being used for these connections) then we need to go out and
// search for the connectionPool that matches the current identity.
currentIdentity = DbConnectionPoolIdentity.GetCurrent();
// If the current token is restricted in some way, then we must
// not attempt to pool these connections.
if (currentIdentity.IsRestricted)
{
currentIdentity = null;
}
}
if (null != currentIdentity)
{
if (!_poolCollection.TryGetValue(currentIdentity, out pool)) // find the pool
{
DbConnectionPoolProviderInfo connectionPoolProviderInfo = connectionFactory.CreateConnectionPoolProviderInfo(this.ConnectionOptions);
// optimistically create pool, but its callbacks are delayed until after actual add
DbConnectionPool newPool = new DbConnectionPool(connectionFactory, this, currentIdentity, connectionPoolProviderInfo);
lock (this) {
// Did someone already add it to the list?
if (!_poolCollection.TryGetValue(currentIdentity, out pool))
{
if (MarkPoolGroupAsActive())
{
// If we get here, we know for certain that we there isn't
// a pool that matches the current identity, so we have to
// add the optimistically created one
newPool.Startup(); // must start pool before usage
bool addResult = _poolCollection.TryAdd(currentIdentity, newPool);
Debug.Assert(addResult, "No other pool with current identity should exist at this point");
#if !MOBILE
connectionFactory.PerformanceCounters.NumberOfActiveConnectionPools.Increment();
#endif
pool = newPool;
newPool = null;
}
else
{
// else pool entry has been disabled so don't create new pools
Debug.Assert(PoolGroupStateDisabled == _state, "state should be disabled");
}
}
else
{
// else found an existing pool to use instead
Debug.Assert(PoolGroupStateActive == _state, "state should be active since a pool exists and lock holds");
}
}
if (null != newPool)
{
// don't need to call connectionFactory.QueuePoolForRelease(newPool) because
// pool callbacks were delayed and no risk of connections being created
newPool.Shutdown();
}
}
// the found pool could be in any state
}
}
if (null == pool)
{
lock (this) {
// keep the pool entry state active when not pooling
MarkPoolGroupAsActive();
}
}
return(pool);
}
internal DbConnectionPool GetConnectionPool(DbConnectionFactory connectionFactory) {
// When this method returns null it indicates that the connection
// factory should not use pooling.
// We don't support connection pooling on Win9x; it lacks too
// many of the APIs we require.
// PoolGroupOptions will only be null when we're not supposed to pool
// connections.
DbConnectionPool pool = null;
if (null != _poolGroupOptions) {
Debug.Assert(ADP.IsWindowsNT, "should not be pooling on Win9x");
DbConnectionPoolIdentity currentIdentity = DbConnectionPoolIdentity.NoIdentity;
if (_poolGroupOptions.PoolByIdentity) {
// if we're pooling by identity (because integrated security is
// being used for these connections) then we need to go out and
// search for the connectionPool that matches the current identity.
currentIdentity = DbConnectionPoolIdentity.GetCurrent();
// If the current token is restricted in some way, then we must
// not attempt to pool these connections.
if (currentIdentity.IsRestricted) {
currentIdentity = null;
}
}
if (null != currentIdentity) {
if (!_poolCollection.TryGetValue(currentIdentity, out pool)) { // find the pool
DbConnectionPoolProviderInfo connectionPoolProviderInfo = connectionFactory.CreateConnectionPoolProviderInfo(this.ConnectionOptions);
// optimistically create pool, but its callbacks are delayed until after actual add
DbConnectionPool newPool = new DbConnectionPool(connectionFactory, this, currentIdentity, connectionPoolProviderInfo);
lock (this) {
// Did someone already add it to the list?
if (!_poolCollection.TryGetValue(currentIdentity, out pool)) {
if (MarkPoolGroupAsActive()) {
// If we get here, we know for certain that we there isn't
// a pool that matches the current identity, so we have to
// add the optimistically created one
newPool.Startup(); // must start pool before usage
bool addResult = _poolCollection.TryAdd(currentIdentity, newPool);
Debug.Assert(addResult, "No other pool with current identity should exist at this point");
#if !MOBILE
connectionFactory.PerformanceCounters.NumberOfActiveConnectionPools.Increment();
#endif
pool = newPool;
newPool = null;
}
else {
// else pool entry has been disabled so don't create new pools
Debug.Assert(PoolGroupStateDisabled == _state, "state should be disabled");
}
}
else {
// else found an existing pool to use instead
Debug.Assert(PoolGroupStateActive == _state, "state should be active since a pool exists and lock holds");
}
}
if (null != newPool) {
// don't need to call connectionFactory.QueuePoolForRelease(newPool) because
// pool callbacks were delayed and no risk of connections being created
newPool.Shutdown();
}
}
// the found pool could be in any state
}
}
if (null == pool) {
lock(this) {
// keep the pool entry state active when not pooling
MarkPoolGroupAsActive();
}
}
return pool;
}
internal DbConnectionPool GetConnectionPool(DbConnectionFactory connectionFactory)
{
object obj2 = null;
if (this._poolGroupOptions != null)
{
DbConnectionPoolIdentity noIdentity = DbConnectionPoolIdentity.NoIdentity;
if (this._poolGroupOptions.PoolByIdentity)
{
noIdentity = DbConnectionPoolIdentity.GetCurrent();
if (noIdentity.IsRestricted)
{
noIdentity = null;
}
}
if (noIdentity != null)
{
obj2 = this._poolCollection[noIdentity];
if (obj2 == null)
{
DbConnectionPoolProviderInfo connectionPoolProviderInfo = connectionFactory.CreateConnectionPoolProviderInfo(this.ConnectionOptions);
DbConnectionPool pool = new DbConnectionPool(connectionFactory, this, noIdentity, connectionPoolProviderInfo);
lock (this)
{
HybridDictionary dictionary = this._poolCollection;
obj2 = dictionary[noIdentity];
if ((obj2 == null) && this.MarkPoolGroupAsActive())
{
pool.Startup();
HybridDictionary dictionary2 = new HybridDictionary(1 + dictionary.Count, false);
foreach (DictionaryEntry entry in dictionary)
{
dictionary2.Add(entry.Key, entry.Value);
}
dictionary2.Add(noIdentity, pool);
connectionFactory.PerformanceCounters.NumberOfActiveConnectionPools.Increment();
this._poolCollection = dictionary2;
this._poolCount = dictionary2.Count;
obj2 = pool;
pool = null;
}
}
if (pool != null)
{
pool.Shutdown();
}
}
}
}
if (obj2 == null)
{
lock (this)
{
this.MarkPoolGroupAsActive();
}
}
return (DbConnectionPool) obj2;
}
