public OracleConnectionPool(OracleConnectionPoolManager manager, OracleConnectionInfo info, int minPoolSize, int maxPoolSize)
{
this.info = info;
this.manager = manager;
initialized = false;
PoolMinSize = minPoolSize;
PoolMaxSize = maxPoolSize;
}
public OracleConnectionPool (OracleConnectionPoolManager manager, OracleConnectionInfo info, int minPoolSize, int maxPoolSize)
{
this.info = info;
this.manager = manager;
initialized = false;
PoolMinSize = minPoolSize;
PoolMaxSize = maxPoolSize;
}
/// <include file='doc\OracleConnection.uex' path='docs/doc[@for="OracleConnection.Open"]/*' />
private void OpenInternal(OracleConnectionString parsedConnectionString, object transact)
{
bool isInTransaction;
try
{
try
{
if (null == parsedConnectionString)
{
throw ADP.NoConnectionString();
}
_state = ConnectionState.Connecting;
if (false == parsedConnectionString.Pooling || null != transact)
{
_internalConnection = new OracleInternalConnection(parsedConnectionString, transact);
}
else
{
#if ALLOWTRACING
if (ADP._traceObjectPoolActivity)
{
if (ContextUtil.IsInTransaction)
{
Debug.WriteLine("Getting Pooled Connection For TransactionId=" + ContextUtil.TransactionId + " ContextId=" + ContextUtil.ContextId);
}
else
{
Debug.WriteLine("Getting Pooled Connection without Transaction Context");
}
}
#endif //ALLOWTRACING
_internalConnection = OracleConnectionPoolManager.GetPooledConnection(
parsedConnectionString.EncryptedActualConnectionString,
parsedConnectionString,
this,
out isInTransaction
);
#if USEORAMTS
// Note that we'll only have a non-null transact object when we are manually
// enlisted -- automatically enlisted connections take a different path.
_internalConnection.ManualEnlistedTransaction = (ITransaction)transact;
#endif //USEORAMTS
}
_hidePassword = true;
_state = ConnectionState.Open;
_parsedConnectionString = parsedConnectionString;
if (UnicodeEnabled)
{
_encodingDatabase = System.Text.Encoding.Unicode; // for environments initialized in UTF16 mode, we can use straight Unicode
}
else if (ServerVersionAtLeastOracle8i)
{
_encodingDatabase = new OracleEncoding(this); // for Oracle8i or greater we'll use Oracle's conversion routines.
}
else
{
_encodingDatabase = System.Text.Encoding.Default; // anything prior to Oracle8i doesn't work with Oracle's conversion routines.
}
_encodingNational = System.Text.Encoding.Unicode; // we use Unicode for the NCHAR/NVARCHAR/NCLOB and let Oracle perform the conversion automatically.
}
finally
{
if (ConnectionState.Open != _state)
{
Cleanup(true, true);
}
}
}
catch // Prevent exception filters from running in our space
{
throw;
}
}
internal void Cleanup(bool disposing, bool silent)
{
// Cleanup the connection as best we can, releasing as many objects
// as we can. We use this when we fail to connect completely, when
// we are closing the connection, and when we're disposing of this
// object.
bool fireEvent = false;
_serverTimeZoneAdjustment = TimeSpan.MinValue;
// Increment the close counter so the child objects can know when their
// connection is toast (or being re-used)
Interlocked.Increment(ref _closeCount);
// If we're not disposing, it's because we went out of scope, and we're
// being garbage collected. We shouldn't touch any managed objects
// or bad things can happen.
if (disposing)
{
// We need to "dispose" of the internal connection object, either
// by returning it to the pool (if it came from one) or by closing it
// outright.
if (null != _internalConnection)
{
if (null == _internalConnection.Pool)
{
// We just close the connection; there is no need to rollback
// here because Oracle will do it for us.
_internalConnection.Close();
}
else
{
// Before we return the connection to the pool, we rollback any
// active transaction that may have been created. Note that we
// don't bother with distributed transactions because we don't
// want to them back (it's handled by the TM). We also don't
// worry about implicit transactions (like "select...for update")
// because we don't want to take the performance hit of the server
// round-trip when it isn't very likely.
if (TransactionState.LocalStarted == TransState)
{
// On the off chance that we have some failure during rollback
// we just eat it and make sure that the connection is doomed.
try
{
Rollback();
}
catch (Exception e)
{
ADP.TraceException(e);
_internalConnection.DoomThisConnection();
}
}
OracleConnectionPoolManager.ReturnPooledConnection(_internalConnection, this);
}
_internalConnection = null;
}
if (null != _scratchBuffer)
{
_scratchBuffer.Dispose();
_scratchBuffer = null;
}
// Mark this connection as closed
if (_state != ConnectionState.Closed)
{
_state = ConnectionState.Closed;
fireEvent = true;
}
_encodingDatabase = null;
_encodingNational = null;
if (fireEvent && !silent)
{
OnStateChange(ConnectionState.Open, ConnectionState.Closed);
}
}
}