C# IDbConnection.Dispose方法代码示例

        public virtual void ReleaseClientConnection(IDbConnection dbConnection)
        {
            if (dbConnection == null)
                return;

            dbConnection.Close();
            dbConnection.Dispose();
        }

		public void ReleaseServerConnection(IDbConnection dbConnection)
		{
			if (dbConnection == null)
				return;

			if (dbConnection.State != ConnectionState.Closed)
				dbConnection.Close();

			dbConnection.Dispose();
		}

		protected virtual void OnDisposeConnection( IDbConnection connection )
		{
			if( connection != null )
			{
				if( connection.State == ConnectionState.Open )
				{
					connection.Close();
				}

				connection.Dispose();
			}
		}

 public bool Close(IDbConnection c)
 {
     try
     {
         c.Dispose();
         c = null;
         return true;
     }
     catch
     {
         return false;
     }
 }

    protected void FinishTransaction(IDbConnection vConn, Boolean isPostRequest, SQLTransactionCmd cmd) {
      if (!isPostRequest) {
        if (vConn != null) {
          vConn.Close();
          vConn.Dispose();
        }
        return;
      }

      var vCommited = false;
      if (this.AutoCommitTransaction || (cmd == SQLTransactionCmd.Commit)) {
        vCommited = true;
        if (!String.IsNullOrEmpty(this.TransactionID))
          this.BioSession.Cfg.dbSession.StoreTransaction(this.TransactionID, null);
      } else if (cmd == SQLTransactionCmd.Rollback)
        this.BioSession.Cfg.dbSession.KillTransaction(this.TransactionID);
      if (vCommited || (cmd == SQLTransactionCmd.Rollback)) {
        if (vConn != null) {
          vConn.Close();
          vConn.Dispose();
        }
      }
    }

        /// <summary>
        /// Opens an <see cref="IDbConnection"/> for the provided connection string..
        /// </summary>
        /// <param name="conn">The <see cref="IDbConnection"/> to open.</param>
        /// <param name="connectionString">The connection string.</param>
        public virtual void OpenConnection(IDbConnection conn, string connectionString)
        {
            try
            {
                conn.ConnectionString = connectionString;
                conn.Open();
            }
            catch (Exception)
            {
                conn.Dispose();
                throw;
            }

        }

        /// <summary>
        ///  关闭MDB数据库
        /// </summary>
        /// <param name="pAdoConn"></param>
        /// <returns></returns>
        public static bool CloseDbConnection(IDbConnection pAdoConn)
        {
            try
            {
                if (pAdoConn != null && pAdoConn.State != null)
                {
                    pAdoConn.Close();
                    pAdoConn.Dispose();
                    GC.Collect();
                }
            }
            catch (Exception exp)
            {
                Hy.Common.Utility.Log.OperationalLogManager.AppendMessage(exp.ToString());

                return false;
            }
            return true;
        }

        private static void DoDisposeConnection(IDbConnection conn, IDbProvider dbProvider)
        {
            if (conn == null)
            {
                return;
            }

            if (dbProvider != null)
            {
                ConnectionHolder conHolder = (ConnectionHolder)TransactionSynchronizationManager.GetResource(dbProvider);
                if (conHolder != null && ConnectionEquals(conHolder.Connection, conn))
                {
                    // It's the transactional connection bound to the thread so don't close it.
                    conHolder.Released();
                    return;
                }
            }
            if (LOG.IsDebugEnabled)
            {
                LOG.Debug("Disposing of IDbConnection with connection string = [" + dbProvider.ConnectionString + "]");
            }
            conn.Dispose();
        }

 public virtual void ReleaseConnection(IDbConnection cnx)
 {
     // if it's writable connection we keep it open
     // for transaction
     if (cnx == writableConnection)
         return;
     cnx.Close();
     cnx.Dispose();
     this.connections.Remove(cnx);
 }

 public virtual void initDatabase(IDbConnection db)
 {
     db.Dispose ();
 }

        static void CloseConnection(IDbConnection conn)
        {
            if (conn == null)
            {
                Debug.Fail("conn is null.");
                return;
            }

            try
            {
                conn.Close();
                conn.Dispose();
            }
            catch (ObjectDisposedException)
            {
                const string errmsg = "Connection `{0}` already disposed.";
                if (log.IsDebugEnabled)
                    log.DebugFormat(errmsg, conn);
            }
            catch (Exception ex)
            {
                const string errmsg = "Failed to dispose `{0}`. Exception: {1}";
                if (log.IsErrorEnabled)
                    log.ErrorFormat(errmsg, conn, ex);
                Debug.Fail(string.Format(errmsg, conn, ex));
            }
        }

        /// <summary>
        /// Closes a DB connection. Also calls the <c>Dispose()</c> Method on the DB connection object.
        /// </summary>
        /// <remarks>
        /// Although the .NET FCL allows the <see cref="IDbConnection.Close" /> method to be
        /// called even on already closed connections without causing an error,
        /// for the purposes of cleaner application development this method throws
        /// an exception when the caller tries to close an already/still closed
        /// connection.
        /// </remarks>
        /// <param name="AConnection">Open Database connection</param>
        /// <returns>void</returns>
        /// <exception cref="EDBConnectionAlreadyClosedException">When trying to close an
        /// already/still closed DB connection.</exception>
        public void CloseDBConnection(IDbConnection AConnection)
        {
            if (AConnection == null)
            {
                throw new ArgumentNullException("AConnection", "AConnection must not be null!");
            }

            if (AConnection.State != ConnectionState.Closed)
            {
                try
                {
                    AConnection.Close();
                    AConnection.Dispose();

                    // TLogging.Log("Database connection closed.");
                }
                catch (Exception exp)
                {
                    TLogging.Log("Error closing Database connection!" + "Exception: " + exp.ToString());
                    throw;
                }
            }
            else
            {
                throw new EDBConnectionAlreadyClosedException();
            }
        }

 public static void DisposeConnection(IDbConnection conn)
 {
     conn.Close();
     conn.Dispose();
 }

 public void CloseConnection(IDbConnection conn)
 {
     if (conn != null && conn.State != ConnectionState.Closed)
     {
         conn.Close();
         conn.Dispose();
     }
 }

        public MenuUtama(IDbConnection conn)
        {
            InitializeComponent();
            _conn = conn;

            DAL shipper = null;
            IDataReader reader = null;
            current = DateTime.Now;

            try
            {
                shipper = new DAL();
                reader = shipper.Cek_Sales(_conn);

                if (reader.Read())
                {
                    Hide();
                    using (Login l = new Login(_conn)) //if data ok, form will close it self!
                    {
                        if (l.ShowDialog() == DialogResult.OK)
                        {
                            this.Visible = true;
                        }
                        else
                        {
                            _conn.Close();
                            _conn.Dispose();
                            Application.Exit();
                        }
                    }
                }
                else
                {
                    Hide();
                    using (Register c = new Register(_conn)) //if data ok, form will close it self!
                    {
                        if (c.ShowDialog() == DialogResult.OK)
                        {
                            this.Visible = true;
                        }
                        else
                        {
                            _conn.Close();
                            _conn.Dispose();
                            Application.Exit();
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
            finally
            {
                if (reader != null)
                {
                    reader.Close();
                    reader.Dispose();
                }
            }
            retrieve_salesData();
            retrieve_pageData(current);
        }