internal static OracleException CreateException(int rc, OracleInternalConnection internalConnection)
{
using (NativeBuffer buffer = new NativeBuffer_Exception(0x3e8))
{
string str;
int length = buffer.Length;
int dwErr = 0;
int num2 = TracedNativeMethods.OraMTSOCIErrGet(ref dwErr, buffer, ref length);
if (1 == num2)
{
str = buffer.PtrToStringAnsi(0, length);
}
else
{
str = Res.GetString("ADP_NoMessageAvailable", new object[] { rc, num2 });
dwErr = 0;
}
if (ConnectionIsBroken(dwErr))
{
internalConnection.DoomThisConnection();
}
return(new OracleException(str, dwErr));
}
}
internal static OracleException CreateException(int rc, OracleInternalConnection internalConnection)
{
using (NativeBuffer buffer = new NativeBuffer_Exception(0x3e8))
{
string str;
int length = buffer.Length;
int dwErr = 0;
int num2 = TracedNativeMethods.OraMTSOCIErrGet(ref dwErr, buffer, ref length);
if (1 == num2)
{
str = buffer.PtrToStringAnsi(0, length);
}
else
{
str = Res.GetString("ADP_NoMessageAvailable", new object[] { rc, num2 });
dwErr = 0;
}
if (ConnectionIsBroken(dwErr))
{
internalConnection.DoomThisConnection();
}
return new OracleException(str, dwErr);
}
}
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);
}
}
}
