Code:
/ Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / whidbey / netfxsp / ndp / fx / src / Data / System / Data / ProviderBase / DbConnectionHelper.cs / 5 / DbConnectionHelper.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// [....]
//-----------------------------------------------------------------------------
namespace NAMESPACE {
using System;
using System.ComponentModel;
using System.Data;
using System.Data.Common;
using System.Data.ProviderBase;
using System.Diagnostics;
using System.Globalization;
using System.Runtime.ConstrainedExecution;
using System.Runtime.InteropServices;
using System.Threading;
using SysTx = System.Transactions;
#if WINFSInternalOnly
internal
#else
public
#endif
sealed partial class CONNECTIONOBJECTNAME : DbConnection {
private static readonly DbConnectionFactory _connectionFactory = CONNECTIONFACTORYOBJECTNAME;
internal static readonly System.Security.CodeAccessPermission ExecutePermission = CONNECTIONOBJECTNAME.CreateExecutePermission();
private DbConnectionOptions _userConnectionOptions;
private DbConnectionPoolGroup _poolGroup;
private DbConnectionInternal _innerConnection;
private int _closeCount; // used to distinguish between different uses of this object, so we don't have to maintain a list of it's children
private static int _objectTypeCount; // Bid counter
internal readonly int ObjectID = System.Threading.Interlocked.Increment(ref _objectTypeCount);
public CONNECTIONOBJECTNAME() : base() {
GC.SuppressFinalize(this);
_innerConnection = DbConnectionClosedNeverOpened.SingletonInstance;
}
// Copy Constructor
private void CopyFrom(CONNECTIONOBJECTNAME connection) { // V1.2.3300
ADP.CheckArgumentNull(connection, "connection");
_userConnectionOptions = connection.UserConnectionOptions;
_poolGroup = connection.PoolGroup;
// SQLBU 432115
// Match the original connection's behavior for whether the connection was never opened,
// but ensure Clone is in the closed state.
if (DbConnectionClosedNeverOpened.SingletonInstance == connection._innerConnection)
{
_innerConnection = DbConnectionClosedNeverOpened.SingletonInstance;
}
else
{
_innerConnection = DbConnectionClosedPreviouslyOpened.SingletonInstance;
}
}
/// We use the _closeCount to avoid having to know about all our
/// children; instead of keeping a collection of all the objects that
/// would be affected by a close, we simply increment the _closeCount
/// and have each of our children check to see if they're "orphaned"
///
internal int CloseCount {
get {
return _closeCount;
}
}
internal DbConnectionFactory ConnectionFactory {
get {
return _connectionFactory;
}
}
internal DbConnectionOptions ConnectionOptions {
get {
System.Data.ProviderBase.DbConnectionPoolGroup poolGroup = PoolGroup;
return ((null != poolGroup) ? poolGroup.ConnectionOptions : null);
}
}
private string ConnectionString_Get() {
Bid.Trace( " %d#\n", ObjectID);
bool hidePassword = InnerConnection.ShouldHidePassword;
DbConnectionOptions connectionOptions = UserConnectionOptions;
return ((null != connectionOptions) ? connectionOptions.UsersConnectionString(hidePassword) : "");
}
private void ConnectionString_Set(string value) {
DbConnectionOptions connectionOptions = null;
System.Data.ProviderBase.DbConnectionPoolGroup poolGroup = ConnectionFactory.GetConnectionPoolGroup(value, null, ref connectionOptions);
DbConnectionInternal connectionInternal = InnerConnection;
bool flag = connectionInternal.AllowSetConnectionString;
if (flag) {
//try {
// NOTE: There's a race condition with multiple threads changing
// ConnectionString and any thread throws an exception
// Closed->Busy: prevent Open during set_ConnectionString
flag = SetInnerConnectionFrom(DbConnectionClosedBusy.SingletonInstance, connectionInternal);
if (flag) {
_userConnectionOptions = connectionOptions;
_poolGroup = poolGroup;
_innerConnection = DbConnectionClosedNeverOpened.SingletonInstance;
}
//}
//catch {
// // recover from exceptions to avoid sticking in busy state
// SetInnerConnectionFrom(connectionInternal, DbConnectionClosedBusy.SingletonInstance);
// throw;
//}
}
if (!flag) {
throw ADP.OpenConnectionPropertySet(ADP.ConnectionString, connectionInternal.State);
}
if (Bid.TraceOn) {
string cstr = ((null != connectionOptions) ? connectionOptions.UsersConnectionStringForTrace() : "");
Bid.Trace(" %d#, '%ls'\n", ObjectID, cstr);
}
}
internal DbConnectionInternal InnerConnection {
get {
return _innerConnection;
}
}
internal System.Data.ProviderBase.DbConnectionPoolGroup PoolGroup {
get {
return _poolGroup;
}
set {
// when a poolgroup expires and the connection eventually activates, the pool entry will be replaced
Debug.Assert(null != value, "null poolGroup");
_poolGroup = value;
}
}
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
RESNAMESPACE.ResDescriptionAttribute(Res.DbConnection_State),
]
override public ConnectionState State {
get {
return InnerConnection.State;
}
}
internal DbConnectionOptions UserConnectionOptions {
get {
return _userConnectionOptions;
}
}
// Open->ClosedPreviouslyOpened, and doom the internal connection too...
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
internal void Abort(Exception e) {
DbConnectionInternal innerConnection = _innerConnection; // Should not cause memory allocation...
if (ConnectionState.Open == innerConnection.State) {
Interlocked.CompareExchange(ref _innerConnection, DbConnectionClosedPreviouslyOpened.SingletonInstance, innerConnection);
innerConnection.DoomThisConnection();
}
// NOTE: we put the tracing last, because the ToString() calls (and
// the Bid.Trace, for that matter) have no reliability contract and
// will end the reliable try...
if (e is OutOfMemoryException) {
Bid.Trace(" %d#, Aborting operation due to asynchronous exception: %ls\n", ObjectID, "OutOfMemory");
}
else {
Bid.Trace(" %d#, Aborting operation due to asynchronous exception: %ls\n", ObjectID, e.ToString());
}
}
internal void AddWeakReference(object value, int tag) {
InnerConnection.AddWeakReference(value, tag);
}
override protected DbTransaction BeginDbTransaction(IsolationLevel isolationLevel) {
IntPtr hscp;
Bid.ScopeEnter(out hscp, " %d#, isolationLevel=%d{ds.IsolationLevel}", ObjectID, (int)isolationLevel);
try {
DbTransaction transaction = InnerConnection.BeginTransaction(isolationLevel);
return transaction;
} finally {
Bid.ScopeLeave(ref hscp);
}
}
override protected DbCommand CreateDbCommand() {
DbCommand command = null;
IntPtr hscp;
Bid.ScopeEnter(out hscp, " %d#\n", ObjectID);
try {
DbProviderFactory providerFactory = ConnectionFactory.ProviderFactory;
command = providerFactory.CreateCommand();
command.Connection = this;
}
finally {
Bid.ScopeLeave(ref hscp);
}
return command;
}
private static System.Security.CodeAccessPermission CreateExecutePermission() {
#if ORACLE
OraclePermission p = new OraclePermission(System.Security.Permissions.PermissionState.None);
p.Add(String.Empty, String.Empty, KeyRestrictionBehavior.AllowOnly);
return p;
#else
DBDataPermission p = (DBDataPermission)CONNECTIONFACTORYOBJECTNAME.ProviderFactory.CreatePermission(System.Security.Permissions.PermissionState.None);
p.Add(String.Empty, String.Empty, KeyRestrictionBehavior.AllowOnly);
return p;
#endif
}
override protected void Dispose(bool disposing) {
if (disposing) {
_userConnectionOptions = null;
_poolGroup= null;
Close();
}
DisposeMe(disposing);
base.Dispose(disposing); // notify base classes
}
// NOTE: This is just a private helper because OracleClient V1.1 shipped
// with a different argument name and it's a breaking change to not use
// the same argument names in V2.0 (VB Named Parameter Binding--Ick)
private void EnlistDistributedTransactionHelper(System.EnterpriseServices.ITransaction transaction) {
System.Security.PermissionSet permissionSet = new System.Security.PermissionSet(System.Security.Permissions.PermissionState.None);
permissionSet.AddPermission(CONNECTIONOBJECTNAME.ExecutePermission); // MDAC 81476
permissionSet.AddPermission(new System.Security.Permissions.SecurityPermission(System.Security.Permissions.SecurityPermissionFlag.UnmanagedCode));
permissionSet.Demand();
Bid.Trace( " %d#, Connection enlisting in a transaction.\n", ObjectID);
SysTx.Transaction indigoTransaction = null;
if (null != transaction) {
indigoTransaction = SysTx.TransactionInterop.GetTransactionFromDtcTransaction((SysTx.IDtcTransaction)transaction);
}
// NOTE: since transaction enlistment involves round trips to the
// server, we don't want to lock here, we'll handle the race conditions
// elsewhere.
InnerConnection.EnlistTransaction(indigoTransaction);
// NOTE: If this outer connection were to be GC'd while we're
// enlisting, the pooler would attempt to reclaim the inner connection
// while we're attempting to enlist; not sure how likely that is but
// we should consider a GC.KeepAlive(this) here.
GC.KeepAlive(this);
}
override public void EnlistTransaction(SysTx.Transaction transaction) {
CONNECTIONOBJECTNAME.ExecutePermission.Demand();
Bid.Trace( " %d#, Connection enlisting in a transaction.\n", ObjectID);
// If we're currently enlisted in a transaction and we were called
// on the EnlistTransaction method (Whidbey) we're not allowed to
// enlist in a different transaction.
DbConnectionInternal innerConnection = InnerConnection;
// NOTE: since transaction enlistment involves round trips to the
// server, we don't want to lock here, we'll handle the race conditions
// elsewhere.
if (innerConnection.HasEnlistedTransaction) {
// Allow calling enlist if already enlisted (no-op)
if (innerConnection.EnlistedTransaction.Equals(transaction)) {
return;
}
throw ADP.TransactionPresent();
}
innerConnection.EnlistTransaction(transaction);
// NOTE: If this outer connection were to be GC'd while we're
// enlisting, the pooler would attempt to reclaim the inner connection
// while we're attempting to enlist; not sure how likely that is but
// we should consider a GC.KeepAlive(this) here.
GC.KeepAlive(this);
}
private DbMetaDataFactory GetMetaDataFactory(DbConnectionInternal internalConnection) {
return ConnectionFactory.GetMetaDataFactory(_poolGroup, internalConnection);
}
internal DbMetaDataFactory GetMetaDataFactoryInternal(DbConnectionInternal internalConnection) {
return GetMetaDataFactory(internalConnection);
}
override public DataTable GetSchema() {
return this.GetSchema(DbMetaDataCollectionNames.MetaDataCollections, null);
}
override public DataTable GetSchema(string collectionName) {
return this.GetSchema(collectionName, null);
}
override public DataTable GetSchema(string collectionName, string[] restrictionValues) {
// NOTE: This is virtual because not all providers may choose to support
// returning schema data
CONNECTIONOBJECTNAME.ExecutePermission.Demand();
return InnerConnection.GetSchema(ConnectionFactory, PoolGroup, this, collectionName, restrictionValues);
}
internal void NotifyWeakReference(int message) {
InnerConnection.NotifyWeakReference(message);
}
internal void PermissionDemand() {
Debug.Assert(DbConnectionClosedConnecting.SingletonInstance == _innerConnection, "not connecting");
System.Data.ProviderBase.DbConnectionPoolGroup poolGroup = PoolGroup;
DbConnectionOptions connectionOptions = ((null != poolGroup) ? poolGroup.ConnectionOptions : null);
if ((null == connectionOptions) || connectionOptions.IsEmpty) {
throw ADP.NoConnectionString();
}
DbConnectionOptions userConnectionOptions = UserConnectionOptions;
Debug.Assert(null != userConnectionOptions, "null UserConnectionOptions");
userConnectionOptions.DemandPermission();
}
internal void RemoveWeakReference(object value) {
InnerConnection.RemoveWeakReference(value);
}
// OpenBusy->Closed (previously opened)
// Connecting->Open
internal void SetInnerConnectionEvent(DbConnectionInternal to) {
// Set's the internal connection without verifying that it's a specific value
Debug.Assert(null != _innerConnection, "null InnerConnection");
Debug.Assert(null != to, "to null InnerConnection");
ConnectionState originalState = _innerConnection.State & ConnectionState.Open;
ConnectionState currentState = to.State & ConnectionState.Open;
if ((originalState != currentState) && (ConnectionState.Closed == currentState)) {
// Increment the close count whenever we switch to Closed
unchecked { _closeCount++; }
}
_innerConnection = to;
if (ConnectionState.Closed == originalState && ConnectionState.Open == currentState) {
OnStateChange(DbConnectionInternal.StateChangeOpen);
}
else if (ConnectionState.Open == originalState && ConnectionState.Closed == currentState) {
OnStateChange(DbConnectionInternal.StateChangeClosed);
}
else {
Debug.Assert(false, "unexpected state switch");
if (originalState != currentState) {
OnStateChange(new StateChangeEventArgs(originalState, currentState));
}
}
}
// this method is used to securely change state with the resource being
// the open connection protected by the connectionstring via a permission demand
// Closed->Connecting: prevent set_ConnectionString during Open
// Open->OpenBusy: guarantee internal connection is returned to correct pool
// Closed->ClosedBusy: prevent Open during set_ConnectionString
internal bool SetInnerConnectionFrom(DbConnectionInternal to, DbConnectionInternal from) {
// Set's the internal connection, verifying that it's a specific value before doing so.
Debug.Assert(null != _innerConnection, "null InnerConnection");
Debug.Assert(null != from, "from null InnerConnection");
Debug.Assert(null != to, "to null InnerConnection");
bool result = (from == Interlocked.CompareExchange(ref _innerConnection, to, from));
return result;
}
// ClosedBusy->Closed (never opened)
// Connecting->Closed (exception during open, return to previous closed state)
internal void SetInnerConnectionTo(DbConnectionInternal to) {
// Set's the internal connection without verifying that it's a specific value
Debug.Assert(null != _innerConnection, "null InnerConnection");
Debug.Assert(null != to, "to null InnerConnection");
_innerConnection = to;
}
[ConditionalAttribute("DEBUG")]
internal static void VerifyExecutePermission() {
try {
// use this to help validate this code path is only used after the following permission has been previously demanded in the current codepath
CONNECTIONOBJECTNAME.ExecutePermission.Demand();
}
catch(System.Security.SecurityException) {
System.Diagnostics.Debug.Assert(false, "unexpected SecurityException for current codepath");
throw;
}
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// [....]
//-----------------------------------------------------------------------------
namespace NAMESPACE {
using System;
using System.ComponentModel;
using System.Data;
using System.Data.Common;
using System.Data.ProviderBase;
using System.Diagnostics;
using System.Globalization;
using System.Runtime.ConstrainedExecution;
using System.Runtime.InteropServices;
using System.Threading;
using SysTx = System.Transactions;
#if WINFSInternalOnly
internal
#else
public
#endif
sealed partial class CONNECTIONOBJECTNAME : DbConnection {
private static readonly DbConnectionFactory _connectionFactory = CONNECTIONFACTORYOBJECTNAME;
internal static readonly System.Security.CodeAccessPermission ExecutePermission = CONNECTIONOBJECTNAME.CreateExecutePermission();
private DbConnectionOptions _userConnectionOptions;
private DbConnectionPoolGroup _poolGroup;
private DbConnectionInternal _innerConnection;
private int _closeCount; // used to distinguish between different uses of this object, so we don't have to maintain a list of it's children
private static int _objectTypeCount; // Bid counter
internal readonly int ObjectID = System.Threading.Interlocked.Increment(ref _objectTypeCount);
public CONNECTIONOBJECTNAME() : base() {
GC.SuppressFinalize(this);
_innerConnection = DbConnectionClosedNeverOpened.SingletonInstance;
}
// Copy Constructor
private void CopyFrom(CONNECTIONOBJECTNAME connection) { // V1.2.3300
ADP.CheckArgumentNull(connection, "connection");
_userConnectionOptions = connection.UserConnectionOptions;
_poolGroup = connection.PoolGroup;
// SQLBU 432115
// Match the original connection's behavior for whether the connection was never opened,
// but ensure Clone is in the closed state.
if (DbConnectionClosedNeverOpened.SingletonInstance == connection._innerConnection)
{
_innerConnection = DbConnectionClosedNeverOpened.SingletonInstance;
}
else
{
_innerConnection = DbConnectionClosedPreviouslyOpened.SingletonInstance;
}
}
/// We use the _closeCount to avoid having to know about all our
/// children; instead of keeping a collection of all the objects that
/// would be affected by a close, we simply increment the _closeCount
/// and have each of our children check to see if they're "orphaned"
///
internal int CloseCount {
get {
return _closeCount;
}
}
internal DbConnectionFactory ConnectionFactory {
get {
return _connectionFactory;
}
}
internal DbConnectionOptions ConnectionOptions {
get {
System.Data.ProviderBase.DbConnectionPoolGroup poolGroup = PoolGroup;
return ((null != poolGroup) ? poolGroup.ConnectionOptions : null);
}
}
private string ConnectionString_Get() {
Bid.Trace( " %d#\n", ObjectID);
bool hidePassword = InnerConnection.ShouldHidePassword;
DbConnectionOptions connectionOptions = UserConnectionOptions;
return ((null != connectionOptions) ? connectionOptions.UsersConnectionString(hidePassword) : "");
}
private void ConnectionString_Set(string value) {
DbConnectionOptions connectionOptions = null;
System.Data.ProviderBase.DbConnectionPoolGroup poolGroup = ConnectionFactory.GetConnectionPoolGroup(value, null, ref connectionOptions);
DbConnectionInternal connectionInternal = InnerConnection;
bool flag = connectionInternal.AllowSetConnectionString;
if (flag) {
//try {
// NOTE: There's a race condition with multiple threads changing
// ConnectionString and any thread throws an exception
// Closed->Busy: prevent Open during set_ConnectionString
flag = SetInnerConnectionFrom(DbConnectionClosedBusy.SingletonInstance, connectionInternal);
if (flag) {
_userConnectionOptions = connectionOptions;
_poolGroup = poolGroup;
_innerConnection = DbConnectionClosedNeverOpened.SingletonInstance;
}
//}
//catch {
// // recover from exceptions to avoid sticking in busy state
// SetInnerConnectionFrom(connectionInternal, DbConnectionClosedBusy.SingletonInstance);
// throw;
//}
}
if (!flag) {
throw ADP.OpenConnectionPropertySet(ADP.ConnectionString, connectionInternal.State);
}
if (Bid.TraceOn) {
string cstr = ((null != connectionOptions) ? connectionOptions.UsersConnectionStringForTrace() : "");
Bid.Trace(" %d#, '%ls'\n", ObjectID, cstr);
}
}
internal DbConnectionInternal InnerConnection {
get {
return _innerConnection;
}
}
internal System.Data.ProviderBase.DbConnectionPoolGroup PoolGroup {
get {
return _poolGroup;
}
set {
// when a poolgroup expires and the connection eventually activates, the pool entry will be replaced
Debug.Assert(null != value, "null poolGroup");
_poolGroup = value;
}
}
[
Browsable(false),
DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden),
RESNAMESPACE.ResDescriptionAttribute(Res.DbConnection_State),
]
override public ConnectionState State {
get {
return InnerConnection.State;
}
}
internal DbConnectionOptions UserConnectionOptions {
get {
return _userConnectionOptions;
}
}
// Open->ClosedPreviouslyOpened, and doom the internal connection too...
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
internal void Abort(Exception e) {
DbConnectionInternal innerConnection = _innerConnection; // Should not cause memory allocation...
if (ConnectionState.Open == innerConnection.State) {
Interlocked.CompareExchange(ref _innerConnection, DbConnectionClosedPreviouslyOpened.SingletonInstance, innerConnection);
innerConnection.DoomThisConnection();
}
// NOTE: we put the tracing last, because the ToString() calls (and
// the Bid.Trace, for that matter) have no reliability contract and
// will end the reliable try...
if (e is OutOfMemoryException) {
Bid.Trace(" %d#, Aborting operation due to asynchronous exception: %ls\n", ObjectID, "OutOfMemory");
}
else {
Bid.Trace(" %d#, Aborting operation due to asynchronous exception: %ls\n", ObjectID, e.ToString());
}
}
internal void AddWeakReference(object value, int tag) {
InnerConnection.AddWeakReference(value, tag);
}
override protected DbTransaction BeginDbTransaction(IsolationLevel isolationLevel) {
IntPtr hscp;
Bid.ScopeEnter(out hscp, " %d#, isolationLevel=%d{ds.IsolationLevel}", ObjectID, (int)isolationLevel);
try {
DbTransaction transaction = InnerConnection.BeginTransaction(isolationLevel);
return transaction;
} finally {
Bid.ScopeLeave(ref hscp);
}
}
override protected DbCommand CreateDbCommand() {
DbCommand command = null;
IntPtr hscp;
Bid.ScopeEnter(out hscp, " %d#\n", ObjectID);
try {
DbProviderFactory providerFactory = ConnectionFactory.ProviderFactory;
command = providerFactory.CreateCommand();
command.Connection = this;
}
finally {
Bid.ScopeLeave(ref hscp);
}
return command;
}
private static System.Security.CodeAccessPermission CreateExecutePermission() {
#if ORACLE
OraclePermission p = new OraclePermission(System.Security.Permissions.PermissionState.None);
p.Add(String.Empty, String.Empty, KeyRestrictionBehavior.AllowOnly);
return p;
#else
DBDataPermission p = (DBDataPermission)CONNECTIONFACTORYOBJECTNAME.ProviderFactory.CreatePermission(System.Security.Permissions.PermissionState.None);
p.Add(String.Empty, String.Empty, KeyRestrictionBehavior.AllowOnly);
return p;
#endif
}
override protected void Dispose(bool disposing) {
if (disposing) {
_userConnectionOptions = null;
_poolGroup= null;
Close();
}
DisposeMe(disposing);
base.Dispose(disposing); // notify base classes
}
// NOTE: This is just a private helper because OracleClient V1.1 shipped
// with a different argument name and it's a breaking change to not use
// the same argument names in V2.0 (VB Named Parameter Binding--Ick)
private void EnlistDistributedTransactionHelper(System.EnterpriseServices.ITransaction transaction) {
System.Security.PermissionSet permissionSet = new System.Security.PermissionSet(System.Security.Permissions.PermissionState.None);
permissionSet.AddPermission(CONNECTIONOBJECTNAME.ExecutePermission); // MDAC 81476
permissionSet.AddPermission(new System.Security.Permissions.SecurityPermission(System.Security.Permissions.SecurityPermissionFlag.UnmanagedCode));
permissionSet.Demand();
Bid.Trace( " %d#, Connection enlisting in a transaction.\n", ObjectID);
SysTx.Transaction indigoTransaction = null;
if (null != transaction) {
indigoTransaction = SysTx.TransactionInterop.GetTransactionFromDtcTransaction((SysTx.IDtcTransaction)transaction);
}
// NOTE: since transaction enlistment involves round trips to the
// server, we don't want to lock here, we'll handle the race conditions
// elsewhere.
InnerConnection.EnlistTransaction(indigoTransaction);
// NOTE: If this outer connection were to be GC'd while we're
// enlisting, the pooler would attempt to reclaim the inner connection
// while we're attempting to enlist; not sure how likely that is but
// we should consider a GC.KeepAlive(this) here.
GC.KeepAlive(this);
}
override public void EnlistTransaction(SysTx.Transaction transaction) {
CONNECTIONOBJECTNAME.ExecutePermission.Demand();
Bid.Trace( " %d#, Connection enlisting in a transaction.\n", ObjectID);
// If we're currently enlisted in a transaction and we were called
// on the EnlistTransaction method (Whidbey) we're not allowed to
// enlist in a different transaction.
DbConnectionInternal innerConnection = InnerConnection;
// NOTE: since transaction enlistment involves round trips to the
// server, we don't want to lock here, we'll handle the race conditions
// elsewhere.
if (innerConnection.HasEnlistedTransaction) {
// Allow calling enlist if already enlisted (no-op)
if (innerConnection.EnlistedTransaction.Equals(transaction)) {
return;
}
throw ADP.TransactionPresent();
}
innerConnection.EnlistTransaction(transaction);
// NOTE: If this outer connection were to be GC'd while we're
// enlisting, the pooler would attempt to reclaim the inner connection
// while we're attempting to enlist; not sure how likely that is but
// we should consider a GC.KeepAlive(this) here.
GC.KeepAlive(this);
}
private DbMetaDataFactory GetMetaDataFactory(DbConnectionInternal internalConnection) {
return ConnectionFactory.GetMetaDataFactory(_poolGroup, internalConnection);
}
internal DbMetaDataFactory GetMetaDataFactoryInternal(DbConnectionInternal internalConnection) {
return GetMetaDataFactory(internalConnection);
}
override public DataTable GetSchema() {
return this.GetSchema(DbMetaDataCollectionNames.MetaDataCollections, null);
}
override public DataTable GetSchema(string collectionName) {
return this.GetSchema(collectionName, null);
}
override public DataTable GetSchema(string collectionName, string[] restrictionValues) {
// NOTE: This is virtual because not all providers may choose to support
// returning schema data
CONNECTIONOBJECTNAME.ExecutePermission.Demand();
return InnerConnection.GetSchema(ConnectionFactory, PoolGroup, this, collectionName, restrictionValues);
}
internal void NotifyWeakReference(int message) {
InnerConnection.NotifyWeakReference(message);
}
internal void PermissionDemand() {
Debug.Assert(DbConnectionClosedConnecting.SingletonInstance == _innerConnection, "not connecting");
System.Data.ProviderBase.DbConnectionPoolGroup poolGroup = PoolGroup;
DbConnectionOptions connectionOptions = ((null != poolGroup) ? poolGroup.ConnectionOptions : null);
if ((null == connectionOptions) || connectionOptions.IsEmpty) {
throw ADP.NoConnectionString();
}
DbConnectionOptions userConnectionOptions = UserConnectionOptions;
Debug.Assert(null != userConnectionOptions, "null UserConnectionOptions");
userConnectionOptions.DemandPermission();
}
internal void RemoveWeakReference(object value) {
InnerConnection.RemoveWeakReference(value);
}
// OpenBusy->Closed (previously opened)
// Connecting->Open
internal void SetInnerConnectionEvent(DbConnectionInternal to) {
// Set's the internal connection without verifying that it's a specific value
Debug.Assert(null != _innerConnection, "null InnerConnection");
Debug.Assert(null != to, "to null InnerConnection");
ConnectionState originalState = _innerConnection.State & ConnectionState.Open;
ConnectionState currentState = to.State & ConnectionState.Open;
if ((originalState != currentState) && (ConnectionState.Closed == currentState)) {
// Increment the close count whenever we switch to Closed
unchecked { _closeCount++; }
}
_innerConnection = to;
if (ConnectionState.Closed == originalState && ConnectionState.Open == currentState) {
OnStateChange(DbConnectionInternal.StateChangeOpen);
}
else if (ConnectionState.Open == originalState && ConnectionState.Closed == currentState) {
OnStateChange(DbConnectionInternal.StateChangeClosed);
}
else {
Debug.Assert(false, "unexpected state switch");
if (originalState != currentState) {
OnStateChange(new StateChangeEventArgs(originalState, currentState));
}
}
}
// this method is used to securely change state with the resource being
// the open connection protected by the connectionstring via a permission demand
// Closed->Connecting: prevent set_ConnectionString during Open
// Open->OpenBusy: guarantee internal connection is returned to correct pool
// Closed->ClosedBusy: prevent Open during set_ConnectionString
internal bool SetInnerConnectionFrom(DbConnectionInternal to, DbConnectionInternal from) {
// Set's the internal connection, verifying that it's a specific value before doing so.
Debug.Assert(null != _innerConnection, "null InnerConnection");
Debug.Assert(null != from, "from null InnerConnection");
Debug.Assert(null != to, "to null InnerConnection");
bool result = (from == Interlocked.CompareExchange(ref _innerConnection, to, from));
return result;
}
// ClosedBusy->Closed (never opened)
// Connecting->Closed (exception during open, return to previous closed state)
internal void SetInnerConnectionTo(DbConnectionInternal to) {
// Set's the internal connection without verifying that it's a specific value
Debug.Assert(null != _innerConnection, "null InnerConnection");
Debug.Assert(null != to, "to null InnerConnection");
_innerConnection = to;
}
[ConditionalAttribute("DEBUG")]
internal static void VerifyExecutePermission() {
try {
// use this to help validate this code path is only used after the following permission has been previously demanded in the current codepath
CONNECTIONOBJECTNAME.ExecutePermission.Demand();
}
catch(System.Security.SecurityException) {
System.Diagnostics.Debug.Assert(false, "unexpected SecurityException for current codepath");
throw;
}
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- PropertyValueUIItem.cs
- PrivilegedConfigurationManager.cs
- Matrix.cs
- ResourceExpressionBuilder.cs
- FormViewUpdateEventArgs.cs
- EventMap.cs
- DateBoldEvent.cs
- KeyEventArgs.cs
- IntSecurity.cs
- NotificationContext.cs
- COM2TypeInfoProcessor.cs
- SchemaSetCompiler.cs
- PerspectiveCamera.cs
- CopyOfAction.cs
- MSAAEventDispatcher.cs
- ByteStack.cs
- PassportAuthenticationEventArgs.cs
- Number.cs
- TemplateApplicationHelper.cs
- HierarchicalDataBoundControl.cs
- SystemIcmpV6Statistics.cs
- ReturnEventArgs.cs
- Identity.cs
- TypeUsage.cs
- TypeDescriptor.cs
- WinFormsUtils.cs
- M3DUtil.cs
- XPathAxisIterator.cs
- StrokeCollection2.cs
- Subordinate.cs
- UnmanagedMarshal.cs
- ReachUIElementCollectionSerializer.cs
- XmlArrayItemAttributes.cs
- DbProviderConfigurationHandler.cs
- PropertyContainer.cs
- EndPoint.cs
- WebFormsRootDesigner.cs
- _LocalDataStoreMgr.cs
- RSACryptoServiceProvider.cs
- sqlstateclientmanager.cs
- XmlQualifiedName.cs
- ApplicationSecurityInfo.cs
- PropertyEmitterBase.cs
- ResolveMatchesMessage11.cs
- ObjectPersistData.cs
- Nullable.cs
- ValidationHelpers.cs
- FlowDocumentScrollViewer.cs
- MenuCommands.cs
- XmlSerializationReader.cs
- Profiler.cs
- EventLogEntry.cs
- TypeTypeConverter.cs
- TextTreeRootTextBlock.cs
- TraceContextRecord.cs
- WindowsListViewItemCheckBox.cs
- CanExecuteRoutedEventArgs.cs
- SqlNodeAnnotation.cs
- CacheOutputQuery.cs
- Certificate.cs
- TextBoxLine.cs
- PageCache.cs
- NumericUpDownAccelerationCollection.cs
- EnumValidator.cs
- ManualWorkflowSchedulerService.cs
- SoapUnknownHeader.cs
- DataGridViewCellValidatingEventArgs.cs
- SchemaLookupTable.cs
- EntityDataSourceConfigureObjectContextPanel.cs
- XPathNodePointer.cs
- StrokeSerializer.cs
- RIPEMD160Managed.cs
- StringArrayConverter.cs
- EnvironmentPermission.cs
- SecurityChannelFactory.cs
- EventSetter.cs
- AdditionalEntityFunctions.cs
- MethodRental.cs
- SurrogateEncoder.cs
- KnownBoxes.cs
- TextEditorSelection.cs
- Types.cs
- OdbcDataAdapter.cs
- InkCanvasAutomationPeer.cs
- Delay.cs
- ChannelServices.cs
- PropertyMapper.cs
- UnmanagedMarshal.cs
- CodeGeneratorOptions.cs
- DataSourceView.cs
- CodeParameterDeclarationExpression.cs
- ContentFileHelper.cs
- HttpSessionStateWrapper.cs
- StateFinalizationActivity.cs
- ListBox.cs
- Gdiplus.cs
- SqlDataAdapter.cs
- EDesignUtil.cs
- Errors.cs
- TwoPhaseCommitProxy.cs