public static DbConnection GetConnection(Database db) { Dictionary<string, DbConnection> dictionary; DbConnection newOpenConnection; Transaction current = Transaction.Current; if (current == null) { return null; } transactionConnections.TryGetValue(current, out dictionary); if (dictionary != null) { dictionary.TryGetValue(db.ConnectionString.ToString(), out newOpenConnection); if (newOpenConnection != null) { return newOpenConnection; } } else { dictionary = new Dictionary<string, DbConnection>(); lock (transactionConnections) { transactionConnections.Add(current, dictionary); } } if (dictionary.ContainsKey(db.ConnectionString)) { return dictionary[db.ConnectionString]; } newOpenConnection = db.GetNewOpenConnection(); current.TransactionCompleted += new TransactionCompletedEventHandler(TransactionScopeConnections.OnTransactionCompleted); dictionary.Add(db.ConnectionString, newOpenConnection); return newOpenConnection; }
public static DbConnection GetConnection(Database db) { Transaction currentTransaction = Transaction.Current; if (currentTransaction == null) { return(null); } Dictionary <string, DbConnection> connectionList; DbConnection connection; lock (transactionConnections) { if (!transactionConnections.TryGetValue(currentTransaction, out connectionList)) { connectionList = new Dictionary <string, DbConnection>(); transactionConnections.Add(currentTransaction, connectionList); currentTransaction.TransactionCompleted += OnTransactionCompleted; } } lock (connectionList) { if (!connectionList.TryGetValue(db.ConnectionString, out connection)) { connection = db.GetNewOpenConnection(); connectionList.Add(db.ConnectionString, connection); } } return(connection); }
public static DatabaseConnectionWrapper GetConnection(Database db) { Transaction current = Transaction.Current; if (current == (Transaction)null) { return((DatabaseConnectionWrapper)null); } Dictionary <string, DatabaseConnectionWrapper> dictionary; lock (TransactionScopeConnections.transactionConnections) { if (!TransactionScopeConnections.transactionConnections.TryGetValue(current, out dictionary)) { dictionary = new Dictionary <string, DatabaseConnectionWrapper>(); TransactionScopeConnections.transactionConnections.Add(current, dictionary); current.TransactionCompleted += new TransactionCompletedEventHandler(TransactionScopeConnections.OnTransactionCompleted); } } DatabaseConnectionWrapper connectionWrapper; lock (dictionary) { if (!dictionary.TryGetValue(db.ConnectionString, out connectionWrapper)) { connectionWrapper = new DatabaseConnectionWrapper(db.GetNewOpenConnection()); dictionary.Add(db.ConnectionString, connectionWrapper); } connectionWrapper.AddRef(); } return(connectionWrapper); }
/// <summary> /// Returns a connection for the current transaction. This will be an existing <see cref="DbConnection"/> /// instance or a new one if there is a <see cref="TransactionScope"/> active. Otherwise this method /// returns null. /// </summary> /// <param name="db"></param> /// <returns>Either a <see cref="DbConnection"/> instance or null.</returns> public static DbConnection GetConnection(Database db) { Transaction currentTransaction = Transaction.Current; if (currentTransaction == null) { return(null); } Dictionary <string, DbConnection> connectionList; transactionConnections.TryGetValue(currentTransaction, out connectionList); DbConnection connection; if (connectionList != null) { connectionList.TryGetValue(db.ConnectionString.ToString(), out connection); if (connection != null) { return(connection); } } else { // We don't have a list for this transaction, so create a new one connectionList = new Dictionary <string, DbConnection>(); lock (transactionConnections) transactionConnections.Add(currentTransaction, connectionList); } // // Next we'll see if there is already a connection. If not, we'll create a new connection and add it // to the transaction's list of connections. // if (connectionList.ContainsKey(db.ConnectionString)) { connection = connectionList[db.ConnectionString]; } else { connection = db.GetNewOpenConnection(); currentTransaction.TransactionCompleted += new TransactionCompletedEventHandler(OnTransactionCompleted); connectionList.Add(db.ConnectionString, connection); } return(connection); }
/// <summary> /// Returns a connection for the current transaction. This will be an existing <see cref="DbConnection"/> /// instance or a new one if there is a <see cref="TransactionScope"/> active. Otherwise this method /// returns null. /// </summary> /// <param name="db"></param> /// <returns>Either a <see cref="DbConnection"/> instance or null.</returns> public static DatabaseConnectionWrapper GetConnection(Database db) { Transaction currentTransaction = Transaction.Current; if (currentTransaction == null) { return(null); } Dictionary <string, DatabaseConnectionWrapper> connectionList; DatabaseConnectionWrapper connection; lock (transactionConnections) { if (!transactionConnections.TryGetValue(currentTransaction, out connectionList)) { // We don't have a list for this transaction, so create a new one connectionList = new Dictionary <string, DatabaseConnectionWrapper>(); transactionConnections.Add(currentTransaction, connectionList); // We need to know when this previously unknown transaction is completed too currentTransaction.TransactionCompleted += OnTransactionCompleted; } } lock (connectionList) { // Next we'll see if there is already a connection. If not, we'll create a new connection and add it // to the transaction's list of connections. // This collection should only be modified by the thread where the transaction scope was created // while the transaction scope is active. // However there's no documentation to confirm this, so we err on the safe side and lock. if (!connectionList.TryGetValue(db.ConnectionString, out connection)) { // we're betting the cost of acquiring a new finer-grained lock is less than // that of opening a new connection, and besides this allows threads to work in parallel var dbConnection = db.GetNewOpenConnection(); connection = new DatabaseConnectionWrapper(dbConnection); connectionList.Add(db.ConnectionString, connection); } connection.AddRef(); } return(connection); }
/// <summary> /// Returns a connection for the current transaction. This will be an existing <see cref="DbConnection"/> /// instance or a new one if there is a <see cref="TransactionScope"/> active. Otherwise this method /// returns null. /// </summary> /// <param name="db"></param> /// <returns>Either a <see cref="DbConnection"/> instance or null.</returns> public static DatabaseConnectionWrapper GetConnection(Database db) { Transaction currentTransaction = Transaction.Current; if (currentTransaction == null) return null; Dictionary<string, DatabaseConnectionWrapper> connectionList; DatabaseConnectionWrapper connection; lock (transactionConnections) { if (!transactionConnections.TryGetValue(currentTransaction, out connectionList)) { // We don't have a list for this transaction, so create a new one connectionList = new Dictionary<string, DatabaseConnectionWrapper>(); transactionConnections.Add(currentTransaction, connectionList); // We need to know when this previously unknown transaction is completed too currentTransaction.TransactionCompleted += OnTransactionCompleted; } } lock (connectionList) { // Next we'll see if there is already a connection. If not, we'll create a new connection and add it // to the transaction's list of connections. // This collection should only be modified by the thread where the transaction scope was created // while the transaction scope is active. // However there's no documentation to confirm this, so we err on the safe side and lock. if (!connectionList.TryGetValue(db.ConnectionString, out connection)) { // we're betting the cost of acquiring a new finer-grained lock is less than // that of opening a new connection, and besides this allows threads to work in parallel var dbConnection = db.GetNewOpenConnection(); connection = new DatabaseConnectionWrapper(dbConnection); connectionList.Add(db.ConnectionString, connection); } connection.AddRef(); } return connection; }
/// <summary> /// Returns a connection for the current transaction. This will be an existing <see cref="DbConnection"/> /// instance or a new one if there is a <see cref="TransactionScope"/> active. Otherwise this method /// returns null. /// </summary> /// <param name="db"></param> /// <returns>Either a <see cref="DbConnection"/> instance or null.</returns> public static DbConnection GetConnection(Database db) { Transaction currentTransaction = Transaction.Current; if (currentTransaction == null) return null; Dictionary<string, DbConnection> connectionList; transactionConnections.TryGetValue(currentTransaction, out connectionList); DbConnection connection; if (connectionList != null) { connectionList.TryGetValue(db.ConnectionString.ToString(), out connection); if (connection != null) return connection; } else { // We don't have a list for this transaction, so create a new one connectionList = new Dictionary<string, DbConnection>(); lock (transactionConnections) transactionConnections.Add(currentTransaction, connectionList); } // // Next we'll see if there is already a connection. If not, we'll create a new connection and add it // to the transaction's list of connections. // if (connectionList.ContainsKey(db.ConnectionString)) connection = connectionList[db.ConnectionString]; else { connection = db.GetNewOpenConnection(); currentTransaction.TransactionCompleted += new TransactionCompletedEventHandler(OnTransactionCompleted); connectionList.Add(db.ConnectionString, connection); } return connection; }