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
    }
}