MySql數據庫鏈接操做

主要封裝爲MySqlHelper類

namespace CiWong.LearningLevelApi.MySqlHelp
{
    /// <summary>
    /// MySqlHelper 類是基於.net框架開發的數據庫操做類
    /// </summary>
    public class MySqlHelper
    {
        #region 緩存Hashtable
        // 存儲緩存參數的Hashtable
        private static Hashtable parmCache = Hashtable.Synchronized(new Hashtable());
        #endregion

        #region 重載+1 獲取鏈接字符串
        /// <summary>
        /// 重載+1 獲取鏈接字符串 [GetStrCon()]
        /// </summary>
        /// <returns>鏈接字符串(若是配置文件中無[SQL]名稱的鏈接字符串，則拋出異常)</returns>
        public static string GetStrCon()
        {
            try
            {
                string CONN_STRING = ConfigurationManager.ConnectionStrings["QuesContext"].ConnectionString;
                return CONN_STRING;
            }
            catch (Exception ex)
            {
                Console.WriteLine(string.Format("配置文件中沒有[SQL]名稱的connectionStrings！錯誤緣由：{0}", ex.ToString()));
                throw;
            }
        }
        #endregion

        #region 重載+2 獲取鏈接字符串
        /// <summary>
        /// 重載+2 獲取鏈接字符串 [GetStrCon(string strConfig)]
        ///     若是配置文件中有strConfig爲名稱的鏈接字符串，則
        ///         獲取它的內容
        ///     若是沒有，則默認strConfig爲鏈接字符串
        /// </summary>
        /// <param name="strConfig">配置文件中鏈接字符串的名稱</param>
        /// <returns>鏈接字符串</returns>
        public static string GetStrCon(string strConfig)
        {
            string CONN_STRING = string.Empty;
            if (ConfigurationManager.ConnectionStrings[strConfig] != null)
                CONN_STRING = ConfigurationManager.ConnectionStrings[strConfig].ConnectionString;
            else
                CONN_STRING = strConfig;
            return CONN_STRING;
        }
        #endregion

        #region 重載+1 建立鏈接對象 [GetConn()]
        /// <summary>
        /// 重載+1 返回 conn鏈接對象 [GetConn()]
        /// </summary>
        /// <returns> MySqlConnection </returns>
        public static MySqlConnection GetConn()
        {
            try
            {
                return new MySqlConnection(GetStrCon());
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
                throw;
            }
        }
        #endregion

        #region 重載+2 建立鏈接對象 [GetConn()]
        /// <summary>
        /// 重載+2 返回 conn鏈接對象 [GetConn()]
        ///     若是配置文件中有strConfig名稱的連拉字符串，則
        ///         獲取它的內容
        ///     若是沒有，則默認strConfig爲鏈接字符串
        /// </summary>
        /// <param name="strConfig">配置文件中鏈接字符串的名稱</param>
        /// <returns> MySqlConnection </returns>
        public static MySqlConnection GetConn(string strConfig)
        {
            try
            {
                return new MySqlConnection(GetStrCon(strConfig));
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
                throw;
            }
        }
        #endregion

        #region 關閉鏈接[CloseConn(...)]
        /// <summary>
        /// 關閉 conn鏈接對象
        /// </summary>
        /// <param name="conn">鏈接對象</param>
        public static void CloseConn(MySqlConnection conn)
        {
            if (conn.State != ConnectionState.Closed)
                conn.Close();
        }
        #endregion

        #region 清空與指定鏈接相關的鏈接池
        /// <summary>
        /// 清空與指定鏈接相關的鏈接池 [ClosePool(MySqlConnection conn)]
        /// </summary>
        public static void ClosePool(MySqlConnection conn)
        {
            MySqlConnection.ClearPool(conn);
        }
        #endregion

        #region 清空全部鏈接池
        /// <summary>
        /// 清空全部鏈接池 [ClosePool()]
        /// </summary>
        public static void ClosePool()
        {
            MySqlConnection.ClearAllPools();
        }
        #endregion

        #region 返回MySqlCommand對象[GetCmd(...)]
        /// <summary>
        /// 返回MySqlCommand對象
        /// </summary>
        /// <param name="conn">conn 鏈接對象</param>
        /// <param name="trans">事物對象</param>
        /// <param name="cmdType">SQL 執行的類型</param>
        /// <param name="cmdText">SQL	執行語句</param>
        /// <param name="cmdParms">MySqlParameter[] 對象</param>
        /// <returns> 返回comm 對象</returns>
        public static MySqlCommand GetCmd(MySqlConnection conn, MySqlTransaction trans, CommandType cmdType, string cmdText, params MySqlParameter[] cmdParms)
        {
            try
            {
                if (conn.State != ConnectionState.Open)
                    conn.Open();

                MySqlCommand cmd = new MySqlCommand();
                cmd.Connection = conn;
                cmd.CommandType = cmdType;
                cmd.CommandText = cmdText;

                if (trans != null)
                    cmd.Transaction = trans;

                if (cmdParms != null)
                {
                    foreach (MySqlParameter parm in cmdParms)
                        cmd.Parameters.Add(parm);
                }

                return cmd;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
                throw;
            }
        }
        #endregion

        #region 重載+1 經過鏈接字符串，執行SqlCommand(不返回結果集)[ExecuteNonQuery(...)]
        /// <summary>
        /// 重載+1 經過鏈接字符串，執行SqlCommand(不返回結果集)
        /// 利用提供的參數值		
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new MySqlParameter("@prodid", 24));
        /// </remarks>
        /// <param name="connString">爲MySqlConnection對象提供：一個有效的鏈接字符串</param>
        /// <param name="cmdType">命令類別：存儲過程、文本字符串等</param>
        /// <param name="cmdText">存儲過程名稱或SQL命令文本</param>
        /// <param name="cmdParms">執行命令的參數列表</param>
        /// <returns>執行命令受影響的記錄條數</returns>
        public static int ExecuteNonQuery(string connString, CommandType cmdType, string cmdText, params MySqlParameter[] cmdParms)
        {
            try
            {
                MySqlCommand cmd = new MySqlCommand();

                using (MySqlConnection conn = new MySqlConnection(connString))
                {
                    PrepareCommand(cmd, conn, null, cmdType, cmdText, cmdParms);
                    int val = cmd.ExecuteNonQuery();
                    cmd.Parameters.Clear();
                    cmd.Dispose();
                    return val;
                }
            }
            catch (Exception ex)
            {
                //引起異常，沒有記錄受影響
                Console.WriteLine(ex.ToString());
                throw;
            }
        }
        #endregion

        #region 重載+2 經過存在的MySqlConnection對象，執行MySqlCommand(不返回結果集)[ExecuteNonQuery(...)]
        /// <summary>
        /// 重載+2 經過存在的MySqlConnection對象，執行MySqlCommand(不返回結果集)
        /// 利用提供的參數值	
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders", new MySqlParameter("@prodid", 24));
        /// </remarks>
        /// <param name="conn">一個已經存在的SqlConnection對象</param>
        /// <param name="cmdType">命令類別：存儲過程、文本字符串等</param>
        /// <param name="cmdText">存儲過程名稱或SQL命令文本</param>
        /// <param name="cmdParms">執行命令的參數列表</param>
        /// <returns>執行命令受影響的記錄條數</returns>
        public static int ExecuteNonQuery(MySqlConnection conn, CommandType cmdType, string cmdText, params MySqlParameter[] cmdParms)
        {
            try
            {
                MySqlCommand cmd = new MySqlCommand();

                PrepareCommand(cmd, conn, null, cmdType, cmdText, cmdParms);
                int val = cmd.ExecuteNonQuery();
                cmd.Parameters.Clear();
                cmd.Dispose();
                return val;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
                //引起異常，沒有記錄受影響
                throw;
            }
            finally
            {
                conn.Close();
            }
        }
        #endregion

        #region 重載+3  經過存在的 MySqlTransaction，執行MySqlCommand(不返回結果集)[ExecuteNonQuery(...)]
        /// <summary>
        /// 重載+3  經過存在的 MySqlTransaction，執行MySqlCommand(不返回結果集)
        /// 利用提供的參數值		
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "PublishOrders", new MySqlParameter("@prodid", 24));
        /// </remarks>		
        /// <param name="trans">一個已經存在的 trans</param>
        /// <param name="cmdType">命令類別：存儲過程、文本字符串等</param>
        /// <param name="cmdText">存儲過程名稱或SQL命令文本</param>
        /// <param name="cmdParms">執行命令的參數列表</param>
        /// <returns>執行命令受影響的記錄條數</returns>
        public static int ExecuteNonQuery(MySqlTransaction trans, CommandType cmdType, string cmdText, params MySqlParameter[] cmdParms)
        {
            try
            {
                MySqlCommand cmd = new MySqlCommand();

                PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, cmdParms);
                int val = cmd.ExecuteNonQuery();
                cmd.Parameters.Clear();
                cmd.Dispose();
                return val;
            }
            catch (Exception ex)
            {
                //引起異常，沒有記錄受影響
                Console.WriteLine(ex.ToString());
                throw;
            }
            finally
            {
                trans.Connection.Close();
            }
        }
        #endregion

        #region 重載+1 經過鏈接字符串，執行MySqlCommand(返回結果集)  [ExecuteDataSet(...)]
        /// <summary>
        /// 重載+1 經過鏈接字符串，執行MySqlCommand(返回結果集)
        /// 利用提供的參數值		
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  DataSet ds = ExecuteDataSet(connString, CommandType.StoredProcedure, "PublishOrders", new MySqlParameter("@prodid", 24));
        /// </remarks>
        /// <param name="connString">爲MySqlConnection對象提供：一個有效的鏈接字符串</param>
        /// <param name="cmdType">命令類別：存儲過程、文本字符串等</param>
        /// <param name="cmdText">存儲過程名稱或SQL命令文本</param>
        /// <param name="cmdParms">執行命令的參數列表</param>
        /// <returns>返回一個結果集：DataSet對象</returns>
        public static DataSet ExecuteDataSet(string connString, CommandType cmdType, string cmdText, params MySqlParameter[] cmdParms)
        {
            DataSet ds = new DataSet();
            //使用一個異常，若是發生異常，則將鏈接關閉	
            try
            {
                using (MySqlConnection conn = new MySqlConnection(connString))
                {
                    MySqlCommand cmd = new MySqlCommand();
                    PrepareCommand(cmd, conn, null, cmdType, cmdText, cmdParms);
                    MySqlDataAdapter adp = new MySqlDataAdapter(cmd);
                    adp.Fill(ds);
                    cmd.Parameters.Clear();
                    cmd.Dispose();
                    return ds;
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
                throw;
            }
        }
        #endregion

        #region 重載+2 經過已經存在的MySqlConnection對象，執行MySqlCommand(返回結果集)  [ExecuteDataSet(...)]
        /// <summary>
        /// 重載+2 經過已經存在的MySqlConnection對象，執行MySqlCommand(返回結果集)
        /// 利用提供的參數值		
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  DataSet ds = ExecuteDataSet(conn, CommandType.StoredProcedure, "PublishOrders", new MySqlParameter("@prodid", 24));
        /// </remarks>
        /// <param name="conn">一個已經存在的MySqlConnection對象</param>
        /// <param name="cmdType">命令類別：存儲過程、文本字符串等</param>
        /// <param name="cmdText">存儲過程名稱或SQL命令文本</param>
        /// <param name="cmdParms">執行命令的參數列表</param>
        /// <returns>返回一個結果集：DataSet對象</returns>
        public static DataSet ExecuteDataSet(MySqlConnection conn, CommandType cmdType, string cmdText, params MySqlParameter[] cmdParms)
        {
            DataSet ds = new DataSet();
            //使用一個異常，若是發生異常，則將鏈接關閉	
            try
            {
                MySqlCommand cmd = new MySqlCommand();
                PrepareCommand(cmd, conn, null, cmdType, cmdText, cmdParms);
                MySqlDataAdapter adp = new MySqlDataAdapter(cmd);
                adp.Fill(ds);
                cmd.Parameters.Clear();
                cmd.Dispose();
                return ds;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
                throw;
            }
            finally
            {
                conn.Close();
            }
        }
        #endregion

        #region 重載+1 經過鏈接字符串，執行MySqlCommand(返回結果集的一個MySqlDataReader對象)[ExecuteReader(...)]
        /// <summary>
        /// 重載+1 經過鏈接字符串，執行MySqlCommand(返回結果集的一個MySqlDataReader對象)
        /// 利用提供的參數值		
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  MySqlDataReader r = ExecuteReader(connString, CommandType.StoredProcedure, "PublishOrders", new MySqlParameter("@prodid", 24));
        /// </remarks>
        /// <param name="connString">爲MySqlConnection對象提供：一個有效的鏈接字符串</param>
        /// <param name="cmdType">命令類別：存儲過程、文本字符串等</param>
        /// <param name="cmdText">存儲過程名稱或SQL命令文本</param>
        /// <param name="cmdParms">執行命令的參數列表</param>	
        /// <returns>包含結果集的一個：MySqlDataReader對象</returns>
        public static MySqlDataReader ExecuteReader(string connString, CommandType cmdType, string cmdText, params MySqlParameter[] cmdParms)
        {
            MySqlConnection conn = new MySqlConnection(connString);

            //使用一個異常，若是發生異常，則將鏈接關閉			
            try
            {
                MySqlCommand cmd = new MySqlCommand();
                PrepareCommand(cmd, conn, null, cmdType, cmdText, cmdParms);
                MySqlDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                cmd.Parameters.Clear();
                cmd.Dispose();
                return rdr;
            }
            catch (Exception ex)
            {
                CloseConn(conn);
                Console.WriteLine(ex.ToString());
                throw;
            }
        }
        #endregion

        #region 重載+2 經過已經存在的MySqlConnection對象，執行MySqlCommand(返回結果集的一個MySqlDataReader對象) [ExecuteReader(...)]
        /// <summary>
        /// 重載+2 經過已經存在的MySqlConnection對象，執行MySqlCommand(返回結果集的一個MySqlDataReader對象)
        /// 利用提供的參數值		
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  MySqlDataReader r = ExecuteReader(conn, CommandType.StoredProcedure, "PublishOrders", new MySqlParameter("@prodid", 24));
        /// </remarks>
        /// <param name="conn">一個已經存在的SqlConnection對象</param>
        /// <param name="cmdType">命令類別：存儲過程、文本字符串等</param>
        /// <param name="cmdText">存儲過程名稱或SQL命令文本</param>
        /// <param name="cmdParms">執行命令的參數列表</param>			
        /// <returns>包含結果集的一個：MySqlDataReader對象</returns>
        public static MySqlDataReader ExecuteReader(MySqlConnection conn, CommandType cmdType, string cmdText, params MySqlParameter[] cmdParms)
        {
            //使用一個異常，若是發生異常，則將鏈接關閉	
            try
            {
                MySqlCommand cmd = new MySqlCommand();
                PrepareCommand(cmd, conn, null, cmdType, cmdText, cmdParms);
                MySqlDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                cmd.Parameters.Clear();
                cmd.Dispose();
                return rdr;
            }
            catch (Exception ex)
            {
                CloseConn(conn);
                Console.WriteLine(ex.ToString());
                throw;
            }
        }
        #endregion

        #region 重載+1 經過鏈接字符串，執行MySqlCommand [ExecuteScalar(...)]
        /// <summary>
        /// 重載+1 經過鏈接字符串，執行MySqlCommand(返回第一條記錄的第一列的值，通常是返回彙總值等;如：select max(id) from userTab)
        /// 利用提供的參數值				
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new MySqlParameter("@prodid", 24));
        /// </remarks>
        /// <param name="connString">爲MySqlConnection對象提供：一個有效的鏈接字符串</param>
        /// <param name="cmdType">命令類別：存儲過程、文本字符串等</param>
        /// <param name="cmdText">存儲過程名稱或SQL命令文本</param>
        /// <param name="cmdParms">執行命令的參數列表</param>	
        /// <returns>返回一個對象：若是要使用具體的值，須要使用Convert.To{Type}進行轉換</returns>
        public static object ExecuteScalar(string connString, CommandType cmdType, string cmdText, params MySqlParameter[] cmdParms)
        {
            try
            {
                MySqlCommand cmd = new MySqlCommand();

                using (MySqlConnection conn = new MySqlConnection(connString))
                {
                    PrepareCommand(cmd, conn, null, cmdType, cmdText, cmdParms);
                    object val = cmd.ExecuteScalar();
                    cmd.Parameters.Clear();
                    cmd.Dispose();
                    return val;
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
                throw;
            }
        }
        #endregion

        #region 重載+2 經過已經存在的MySqlConnection對象，執行MySqlCommand [ExecuteScalar(...)]
        /// <summary>
        /// 重載+2 經過已經存在的MySqlConnection對象，執行MySqlCommand(返回第一條記錄的第一列的值，通常是返回彙總值等;如：Select max(ColumnName) From TableName)
        /// 利用提供的參數值	
        /// </summary>
        /// <remarks>
        /// e.g.:  
        ///  Object obj = ExecuteScalar(conn, CommandType.StoredProcedure, "PublishOrders", new MySqlParameter("@prodid", 24));
        /// </remarks>
        /// <param name="conn">一個已經存在的SqlConnection對象</param>
        /// <param name="cmdType">命令類別：存儲過程、文本字符串等</param>
        /// <param name="cmdText">存儲過程名稱或SQL命令文本</param>
        /// <param name="cmdParms">執行命令的參數列表</param>
        /// <returns>返回一個對象：若是要使用具體的值，須要使用Convert.To{Type}進行轉換</returns>
        public static object ExecuteScalar(MySqlConnection conn, CommandType cmdType, string cmdText, params MySqlParameter[] cmdParms)
        {
            try
            {
                MySqlCommand cmd = new MySqlCommand();

                PrepareCommand(cmd, conn, null, cmdType, cmdText, cmdParms);
                object val = cmd.ExecuteScalar();
                cmd.Parameters.Clear();
                cmd.Dispose();
                return val;
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
                throw;
            }
            finally
            {
                CloseConn(conn);
            }
        }
        #endregion

        #region 將參數數組增長至Hashtable，緩存在緩衝區 [CacheParameters(...)]
        /// <summary>
        /// 存儲：將參數數組增長至緩衝區		
        /// </summary>
        /// <param name="cacheKey">緩衝區參數的鍵名</param>
        /// <param name="cmdParms">緩衝區對應鍵名的參數值</param>
        public static void CacheParameters(string cacheKey, params MySqlParameter[] cmdParms)
        {
            parmCache[cacheKey] = cmdParms;
        }
        #endregion

        #region 從緩衝區獲得Hashtable中的參數列表的值 [GetCachedParameters(...)]
        /// <summary>
        /// 檢索值：獲得緩衝區中的參數列表值
        /// </summary>
        /// <param name="cacheKey">緩衝區參數的鍵名</param>
        /// <returns>緩衝區對應鍵名的參數值</returns>
        public static MySqlParameter[] GetCachedParameters(string cacheKey)
        {
            //獲取 key 爲cachekey 的值 parmCache[參數化SQL語句]=parameter[]數據組對象
            MySqlParameter[] cachedParms = (MySqlParameter[])parmCache[cacheKey];

            //若是不存在 則返回爲空
            if (cachedParms == null)
                return null;
            //反之 Hashtable表中存在 key爲cacheky 的對象則返回 他的 副本 對象 par[]
            MySqlParameter[] clonedParms = new MySqlParameter[cachedParms.Length];

            for (int i = 0, j = cachedParms.Length; i < j; i++)
                clonedParms[i] = (MySqlParameter)((ICloneable)cachedParms[i]).Clone();

            return clonedParms;
        }
        #endregion

        #region 執行預約義Command對象[PrepareCommand(...)]
        /// <summary>
        /// 要執行:預約義Command對象(PrepareCommand)
        /// </summary>
        /// <param name="cmd">MySqlCommand 對象</param>
        /// <param name="conn">MySqlConnection 對象</param>
        /// <param name="trans">MySqlTransaction 對象</param>
        /// <param name="cmdType">命令類別：存儲過程、文本字符串等</param>
        /// <param name="cmdText">存儲過程名稱或SQL命令文本,如：select * from UserTab</param>		
        /// <param name="cmdParms">Command對象須要使用的參數列表</param>
        public static void PrepareCommand(MySqlCommand cmd, MySqlConnection conn, MySqlTransaction trans, CommandType cmdType, string cmdText, MySqlParameter[] cmdParms)
        {
            try
            {
                if (conn.State != ConnectionState.Open)
                    conn.Open();

                cmd.Connection = conn;
                cmd.CommandText = cmdText;

                if (trans != null)
                    cmd.Transaction = trans;

                cmd.CommandType = cmdType;

                if (cmdParms != null)
                {
                    foreach (MySqlParameter parm in cmdParms)
                        cmd.Parameters.Add(parm);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
                throw;
            }
        }
        #endregion

        #region 提交事務 [TransactionCommit(...)]
        /// <summary>
        /// 提交事務
        /// </summary>
        /// <param name="trans">事務</param>
        public static void TransactionCommit(MySqlTransaction trans)
        {
            trans.Commit();
        }
        #endregion

        #region 回滾事務 [TransactionRollback(...)]
        /// <summary>
        /// 回滾事務
        /// </summary>
        /// <param name="trans">事務</param>
        public static void TransactionRollback(MySqlTransaction trans)
        {
            trans.Rollback();
        }
        #endregion
    }
}