/// <summary>
        /// Shut down this instance.  Disposes all connections it holds and restores the prior scope.
        /// </summary>
        public void Dispose()
        {
            if (!IsDisposed)
            {
                // Firstly, remove ourselves from the stack (but, only if we are the one on the stack)
                //  Note: Thread-local _currentScope, and requirement that scopes not be disposed on other threads
                //      means we can get away with not locking.
                if (__currentScope == this)
                {
                    // In case the user called dispose out of order, skip up the chain until we find
                    //  an undisposed scope.
                    DbConnectionScope prior = _priorScope;
                    while (null != prior && prior.IsDisposed)
                    {
                        prior = prior._priorScope;
                    }
                    __currentScope = prior;
                }

                // secondly, make sure our internal state is set to "Disposed"
                IDictionary <object, DbConnection> connections = _connections;
                _connections = null;

                // Lastly, clean up the connections we own
                foreach (DbConnection connection in connections.Values)
                {
                    connection.Dispose();
                }
            }
        }
 /// <summary>
 /// Constructor
 /// </summary>
 public DbConnectionScope()
 {
     // Devnote:  Order of initial assignment is important in cases of failure!
     //  _priorScope first makes sure we know who we need to restore
     //  _connections second, to make sure we no-op dispose until we're as close to
     //      correct setup as possible
     //  __currentScope last, to make sure the thread static only holds validly set up objects
     _priorScope    = __currentScope;
     _connections   = new Dictionary <object, DbConnection>();
     __currentScope = this;
 }