private PrePush ( object expectedOwner ) : void | ||
expectedOwner | object | |
return | void |
private PooledStream Create(CreateConnectionDelegate createConnectionCallback) { PooledStream stream = null; try { stream = createConnectionCallback(this); if (stream == null) { throw new InternalException(); } if (!stream.CanBePooled) { throw new InternalException(); } stream.PrePush(null); lock (this.m_ObjectList.SyncRoot) { this.m_ObjectList.Add(stream); this.m_TotalObjects = this.m_ObjectList.Count; } } catch (Exception exception) { stream = null; this.m_ResError = exception; this.Abort(); } return(stream); }
/// <devdoc> /// <para> /// Attempts to return a PooledStream to the pool. If canReuse is false, then the /// connection will be destroyed even if it is marked as reusable and a new conneciton will /// be created. If it is true, then the connection will still be checked to ensure that /// it can be pooled and will be cleaned up if it can not for another reason. /// </para> /// </devdoc> internal void PutConnection(PooledStream pooledStream, object owningObject, int creationTimeout, bool canReuse) { GlobalLog.Print("ConnectionPool#" + ValidationHelper.HashString(this) + "::PutConnection"); if (pooledStream == null) { throw new ArgumentNullException("pooledStream"); } pooledStream.PrePush(owningObject); if (m_State != State.ShuttingDown) { pooledStream.Deactivate(); // cancel our error status, if we have no new requests waiting anymore if (m_WaitCount == 0) { CancelErrorCallback(); } if (canReuse && pooledStream.CanBePooled) { PutNew(pooledStream); } else { try { Destroy(pooledStream); } finally { // Make sure to release the mutex even under error conditions. // Make sure we recreate a new pooled stream, if there are requests for a stream // at this point if (m_WaitCount > 0) { if (!CreationMutex.WaitOne(creationTimeout, false)) { Abort(); } else { try { pooledStream = UserCreateRequest(); if (null != pooledStream) { PutNew(pooledStream); } } finally { CreationMutex.ReleaseMutex(); } } } } } } else { // If we're shutting down, we destroy the object. Destroy(pooledStream); } }
internal void PutConnection(PooledStream pooledStream, object owningObject, int creationTimeout, bool canReuse) { if (pooledStream == null) { throw new ArgumentNullException("pooledStream"); } pooledStream.PrePush(owningObject); if (this.m_State != State.ShuttingDown) { pooledStream.Deactivate(); if (this.m_WaitCount == 0) { this.CancelErrorCallback(); } if (canReuse && pooledStream.CanBePooled) { this.PutNew(pooledStream); } else { this.Destroy(pooledStream); if (this.m_WaitCount > 0) { if (!this.CreationMutex.WaitOne(creationTimeout, false)) { this.Abort(); } else { try { pooledStream = this.UserCreateRequest(); if (pooledStream != null) { this.PutNew(pooledStream); } } finally { this.CreationMutex.ReleaseMutex(); } } } } } else { this.Destroy(pooledStream); } }
/// <summary> /// <para>Creates a new PooledStream, performs checks as well on the new stream</para> /// </summary> private PooledStream Create(CreateConnectionDelegate createConnectionCallback) { GlobalLog.Enter("ConnectionPool#" + ValidationHelper.HashString(this) + "::Create"); PooledStream newObj = null; try { newObj = createConnectionCallback(this); if (null == newObj) { throw new InternalException(); // Create succeeded, but null object } if (!newObj.CanBePooled) { throw new InternalException(); // Create succeeded, but non-poolable object } newObj.PrePush(null); lock (m_ObjectList.SyncRoot) { m_ObjectList.Add(newObj); m_TotalObjects = m_ObjectList.Count; } GlobalLog.Print("Create pooledStream#" + ValidationHelper.HashString(newObj)); } catch (Exception e) { GlobalLog.Print("Pool Exception: " + e.Message); newObj = null; // set to null, so we do not return bad new object // Failed to create instance m_ResError = e; Abort(); } catch { GlobalLog.Print("Pool Exception: Non-CLS Compliant Exception"); newObj = null; // set to null, so we do not return bad new object // Failed to create instance m_ResError = new Exception(SR.GetString(SR.net_nonClsCompliantException)); Abort(); } GlobalLog.Leave("ConnectionPool#" + ValidationHelper.HashString(this) + "::Create", ValidationHelper.HashString(newObj)); return(newObj); }
/// <devdoc> /// <para>Attempts to return a PooledStream to the pool</para> /// </devdoc> internal void PutConnection(PooledStream pooledStream, object owningObject, int creationTimeout) { GlobalLog.Print("ConnectionPool#" + ValidationHelper.HashString(this) + "::PutConnection"); if (pooledStream == null) { throw new ArgumentNullException("pooledStream"); } pooledStream.PrePush(owningObject); if (m_State != State.ShuttingDown) { pooledStream.Deactivate(); // cancel our error status, if we have no new requests waiting anymore if (m_WaitCount == 0) { CancelErrorCallback(); } if (pooledStream.CanBePooled) { PutNew(pooledStream); } else { Destroy(pooledStream); // Make sure we recreate a new pooled stream, if there are requests for a stream // at this point if (m_WaitCount > 0) { if (!CreationMutex.WaitOne(creationTimeout, false)) { Abort(); } else { try { pooledStream = UserCreateRequest(); if (null != pooledStream) { PutNew(pooledStream); } } finally { CreationMutex.ReleaseMutex(); } } } } } else { // If we're shutting down, we destroy the object. Destroy(pooledStream); } }
internal void PutConnection(PooledStream pooledStream, object owningObject, int creationTimeout, bool canReuse) { if (pooledStream == null) { throw new ArgumentNullException("pooledStream"); } pooledStream.PrePush(owningObject); if (this.m_State != State.ShuttingDown) { pooledStream.Deactivate(); if (this.m_WaitCount == 0) { this.CancelErrorCallback(); } if (canReuse && pooledStream.CanBePooled) { this.PutNew(pooledStream); } else { this.Destroy(pooledStream); if (this.m_WaitCount > 0) { if (!this.CreationMutex.WaitOne(creationTimeout, false)) { this.Abort(); } else { try { pooledStream = this.UserCreateRequest(); if (pooledStream != null) { this.PutNew(pooledStream); } } finally { this.CreationMutex.ReleaseMutex(); } } } } } else { this.Destroy(pooledStream); } }