C# 对mysql 操作的封装

最近写了一个类，实现了对mysql数据库的基本操作的封装。有需要的可以拿去。先上效果，另外有问题可以自己修改或者联系。

数据库结构：

一：效果

1.1原数据表

 1.2：连接数据库

   MySQLBase sqlbase = new MySQLBase("test", "localhost", "root", "Zhong123456789");

1.3：增加操作

 var restult =  sqlbase.InsertDTTableOneRow("userinfo", new string[] { "username", "userage" }, new MySqlDbType[] {MySqlDbType.VarChar, MySqlDbType.Int16}, new string[] { "dfd2323fdf", "19" });

 1.4:删除操作

 restult= sqlbase.DeleteDTTableOneRow("userinfo", new string[] { "userage","username" }, new MySqlDbType[] { MySqlDbType.Int16 , MySqlDbType.VarChar }, new string[] { "99" ,"zwf"},"or");

 1.5修改操作

restult= sqlbase.UpdateDTTableOneRow("userinfo", "userage", MySqlDbType.Int16,"99", new string[] { "userage", "username" }, new MySqlDbType[] { MySqlDbType.Int16, MySqlDbType.VarChar }, new string[] { "19", "zwf1" }, "or");

1.6 执行存储过程，无参数。

  restult= sqlbase.RunStoredProcedure("test_userinfo_run");

 存储过程如下：workbecnch 编写

CREATE DEFINER=`root`@`localhost` PROCEDURE `test_userinfo_run`()
BEGIN
select userage from userinfo where iduserinfo=1;
insert into userinfo (username,userage) values("sssss","99");
END

二：源码，封装到类里面了。log 部分请自行注销。

public class MySQLBase
    {
        //连接数据库字符串
        string Connstr;
       

        //数据库连接字符串
        //数据库连接字符串
        //  public static string Conn = "Database='wp';Data Source='localhost';User Id='root';Password='root';charset='utf8';pooling=true";
        // public static string Conn = "Database='数据库名';Data Source='数据库服务器地址';User Id='数据库用户名';Password='密码';charset='utf8';pooling=true";
        /// <summary>
        /// Conn = "Database='数据库名';Data Source='数据库服务器地址';User Id='数据库用户名';Password='密码';charset='utf8';pooling=true";
        /// </summary>
        /// <param name="connectionstr"></param>
        public MySQLBase(string connectionstr)
        {
            Connstr = connectionstr;
        }
        public MySQLBase(string dtname, string dtsource, string userid, string userpassword)
        {
            Connstr = string.Format("Database='{0}';Data Source={1};User Id={2};Password={3};charset='utf8';pooling=true", dtname, dtsource, userid, userpassword);
        }


        // 用于缓存参数的HASH表
      //  private Hashtable parmCache = Hashtable.Synchronized(new Hashtable());       

        /// <summary>
        /// 用现有的数据库连接执行一个sql命令（不返回数据集）,适用于数据库的基本操作
        /// </summary>
        /// <param name="connection">一个现有的数据库连接</param>
        /// <param name="cmdType">命令类型(存储过程, 文本, 等等)</param>
        /// <param name="cmdText">存储过程名称或者sql命令语句</param>
        /// <param name="commandParameters">执行命令所用参数的集合</param>
        /// <returns>执行命令所影响的行数</returns>
        public int ExecuteNonQuery(CommandType cmdType, string cmdText, params MySqlParameter[] commandParameters)
        {
            try
            {
                using (MySqlConnection con = new MySqlConnection(Connstr))
                {
                    MySqlCommand cmd = new MySqlCommand();
                    PrepareCommand(cmd, con, null, cmdType, cmdText, commandParameters);
                    int val = cmd.ExecuteNonQuery();
                    cmd.Parameters.Clear();
                    return val;
                }

            }
            catch(Exception ex)
            {
                MyBasicFun.LogWarn("ExecuteNonQuery Abnormal!" + ex.Message);
                return -1;
            }
            
        }



        /// <summary>
        ///使用现有的SQL事务执行一个sql命令（不返回数据集），适用于数据库的基本操作
        /// </summary>
        /// <remarks>
        ///举例:
        ///  int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new MySqlParameter("@prodid", 24));
        /// </remarks>
        /// <param name="trans">一个现有的事务</param>
        /// <param name="cmdType">命令类型(存储过程, 文本, 等等)</param>
        /// <param name="cmdText">存储过程名称或者sql命令语句</param>
        /// <param name="commandParameters">执行命令所用参数的集合</param>
        /// <returns>执行命令所影响的行数</returns>
        public int ExecuteNonQuery(MySqlTransaction trans, CommandType cmdType, string cmdText, params MySqlParameter[] commandParameters)
        {
            try
            {
                MySqlCommand cmd = new MySqlCommand();
                PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, commandParameters);
                int val = cmd.ExecuteNonQuery();
                cmd.Parameters.Clear();
                return val;
            }
            catch(Exception ex)
            {
                MyBasicFun.LogWarn("ExecuteNonQuery(MySqlTransaction trans," +
                    " CommandType cmdType, string cmdText, params MySqlParameter[] commandParameters) Abnormal!" + ex.Message);
                return -1;
            }
       
        }

        /// <summary>
        /// 用执行的数据库连接执行一个返回数据集的sql命令，适用于数据库的基本操作
        /// </summary>
        /// <remarks>
        /// 举例:
        ///  MySqlDataReader r = ExecuteReader(connString, CommandType.StoredProcedure, "PublishOrders", new MySqlParameter("@prodid", 24));
        /// </remarks>
        /// <param name="connectionString">一个有效的连接字符串</param>
        /// <param name="cmdType">命令类型(存储过程, 文本, 等等)</param>
        /// <param name="cmdText">存储过程名称或者sql命令语句</param>
        /// <param name="commandParameters">执行命令所用参数的集合</param>
        /// <returns>包含结果的读取器</returns>
        public MySqlDataReader ExecuteReader( CommandType cmdType, string cmdText, params MySqlParameter[] commandParameters)
        {
            try
            {
                //创建一个MySqlConnection对象
                using (MySqlConnection conn = new MySqlConnection(Connstr))
                {
                    //创建一个MySqlCommand对象
                    MySqlCommand cmd = new MySqlCommand();
                    //调用 PrepareCommand 方法，对 MySqlCommand 对象设置参数
                    PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
                    //调用 MySqlCommand  的 ExecuteReader 方法
                    MySqlDataReader reader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                    //清除参数
                    cmd.Parameters.Clear();
                    return reader;


                }
            }
            catch(Exception ex)
            {
                MyBasicFun.LogWarn("ExecuteReader Abnormal!" + ex.Message);
                return null;
            }
           
            
        }
        /// <summary>
        /// 返回DataSet
        /// </summary>
        /// <param name="connectionString">一个有效的连接字符串</param>
        /// <param name="cmdType">命令类型(存储过程, 文本, 等等)</param>
        /// <param name="cmdText">存储过程名称或者sql命令语句</param>
        /// <param name="commandParameters">执行命令所用参数的集合</param>
        /// <returns></returns>
        public DataSet GetDataSet( CommandType cmdType, string cmdText, params MySqlParameter[] commandParameters)
        {
            try
            {
                //创建一个MySqlConnection对象
                using (MySqlConnection conn = new MySqlConnection(Connstr))
                {
                    MySqlCommand cmd = new MySqlCommand();
                    //调用 PrepareCommand 方法，对 MySqlCommand 对象设置参数
                    PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
                    //调用 MySqlCommand  的 ExecuteReader 方法
                    MySqlDataAdapter adapter = new MySqlDataAdapter();
                    adapter.SelectCommand = cmd;
                    DataSet ds = new DataSet();

                    adapter.Fill(ds);

                    //清除参数
                    cmd.Parameters.Clear();
                    return ds;

                }
            }
            catch(Exception ex)
            {

                MyBasicFun.LogWarn("GetDataSet Abnormal!" + ex.Message);
                return null;
            }
          
          

        }

        /// <summary>
        /// 输出多一个dataadapter,用了返回更新数据库
        /// </summary>
        /// <param name="connectionString"></param>
        /// <param name="cmdType"></param>
        /// <param name="cmdText"></param>
        /// <param name="commandParameters"></param>
        /// <param name="adapter"></param>
        /// <returns></returns>
        public DataSet GetDataSet(CommandType cmdType, string cmdText, out MySqlDataAdapter adapter, params MySqlParameter[] commandParameters)
        {
            adapter = new MySqlDataAdapter();
            try
            {
             
                //创建一个MySqlConnection对象             
                using (MySqlConnection conn = new MySqlConnection(Connstr))
                {
                    //创建一个MySqlCommand对象
                    MySqlCommand cmd = new MySqlCommand();
                    //调用 PrepareCommand 方法，对 MySqlCommand 对象设置参数
                    PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
                    //调用 MySqlCommand  的 ExecuteReader 方法

                    adapter.SelectCommand = cmd;
                    DataSet ds = new DataSet();

                    adapter.Fill(ds);
                    //清除参数
                    cmd.Parameters.Clear();
                    conn.Close();
                    return ds;

                }
            }
            catch(Exception ex)
            {
                MyBasicFun.LogWarn("GetDataSet Abnormal!" + ex.Message);
                return null;

            }

        }

        /// <summary>
        /// 通过dataset更新数据库
        /// </summary>
        /// <param name="adapter"></param>
        /// <param name="dataSet"></param>
        public void UpdateDB(MySqlDataAdapter adapter, DataSet dataSet)
        {

            try
            {
               // MySqlCommandBuilder thisBuilder = new MySqlCommandBuilder(adapter);
                adapter.Update(dataSet);

            }
            catch (Exception ex)
            {
                MyBasicFun.LogWarn(" UpdateDB(MySqlDataAdapter adapter, DataSet dataSet) Abnormal!" + ex.Message);

            }

        }

        /// <summary>
        /// 用指定的数据库连接字符串执行一个命令并返回一个数据集的第一列
        /// </summary>
        /// <remarks>
        ///例如:
        ///  Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new MySqlParameter("@prodid", 24));
        /// </remarks>
        ///<param name="connectionString">一个有效的连接字符串</param>
        /// <param name="cmdType">命令类型(存储过程, 文本, 等等)</param>
        /// <param name="cmdText">存储过程名称或者sql命令语句</param>
        /// <param name="commandParameters">执行命令所用参数的集合</param>
        /// <returns>用 Convert.To{Type}把类型转换为想要的 </returns>
        public object ExecuteScalar( CommandType cmdType, string cmdText, params MySqlParameter[] commandParameters)
        {
            try
            {
                using (MySqlConnection connection = new MySqlConnection(Connstr))
                {
                    MySqlCommand cmd = new MySqlCommand();
                    PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
                    object val = cmd.ExecuteScalar();
                    cmd.Parameters.Clear();
                    return val;
                }
            }
            catch(Exception ex)
            {
                MyBasicFun.LogWarn(" ExecuteScalar( CommandType cmdType, string cmdText, params MySqlParameter[] commandParameters) Abnormal!" + ex.Message);
                return null;
            }
          

           
        }


        ///// <summary>
        ///// 将参数集合添加到缓存
        ///// </summary>
        ///// <param name="cacheKey">添加到缓存的变量</param>
        ///// <param name="commandParameters">一个将要添加到缓存的sql参数集合</param>
        //public void CacheParameters(string cacheKey, params MySqlParameter[] commandParameters)
        //{
        //    parmCache[cacheKey] = commandParameters;
        //}

        ///// <summary>
        ///// 找回缓存参数集合
        ///// </summary>
        ///// <param name="cacheKey">用于找回参数的关键字</param>
        ///// <returns>缓存的参数集合</returns>
        //public MySqlParameter[] GetCachedParameters(string cacheKey)
        //{
        //    MySqlParameter[] cachedParms = (MySqlParameter[])parmCache[cacheKey];

        //    if (cachedParms == null)
        //        return null;

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

        /// <summary>
        /// 准备执行一个命令
        /// </summary>
        /// <param name="cmd">sql命令</param>
        /// <param name="conn">OleDb连接</param>
        /// <param name="trans">OleDb事务</param>
        /// <param name="cmdType">命令类型例如 存储过程或者文本</param>
        /// <param name="cmdText">命令文本,例如:Select * from Products</param>
        /// <param name="cmdParms">执行命令的参数</param>
        private void PrepareCommand(MySqlCommand cmd, MySqlConnection conn, MySqlTransaction trans, CommandType cmdType, string cmdText, MySqlParameter[] cmdParms)
        {

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



        /// <summary>
        /// 在数据库的tablename数据表里面加入一行，返回，返回受影响的行数，-1返回则代表异常。"commandType">commandType.tex
        /// </summary>
        /// <param name="tablename"></param>
        /// <param name="dtparaname"></param>
        /// <param name="dtparatypes"></param>
        /// <param name="dtvalues"></param>
        /// <returns></returns>
        public int InsertDTTableOneRow(string tablename,string[] dtparaname,  MySqlDbType[] dtparatypes,string[] dtvalues)
        {
            int result = 0;
            try
            {
                //string commandtext = "insert into userinfo (username,userage) values (@name,@age)";
                //     para[0].Value = 5;
                //     para[1].Value = "zwf";
              //  var commandtext = string.Format("insert into {0}({0},{0});charset='utf8';pooling=true", dtname, dtsource, userid, userpassword);

              var  commandtext = "insert into " + tablename.ToString() + " (";
                var endstr = "values (";
              
              
                MySqlParameter[] para = new MySqlParameter[dtparaname.Length];
                for (int i = 0; i < dtparaname.Length; i++)
                {
               
                    if(i == dtparaname.Length - 1)
                    {
                        endstr += "@para" + i.ToString();
                        commandtext += dtparaname[i].ToString();
                    }
                    else
                    {
                        endstr += "@para" + i.ToString() + ",";
                        commandtext += dtparaname[i].ToString() + ",";
                    }
                  

                    if (i == dtparaname.Length - 1)
                    {
                        commandtext += ") ";
                        endstr += ") ";
                    }
                    para[i] = new MySqlParameter("@para" + i.ToString(), dtparatypes[i]);
                    para[i] .Value= dtvalues[i];
                }
                commandtext += endstr;            
                result = ExecuteNonQuery(CommandType.Text, commandtext, para);
            }
            catch(Exception ex)
            {
                result = -1;
                MyBasicFun.LogWarn("InsertDTTableOneRow Abnormal!" + ex.Message);
            }
            return result;
        }

        /// <summary>
        /// 删除数据库里面的tablename 数据表的满足特定条件的一行，返回受影响的行数，-1返回则代表异常。"commandType">commandType.tex
        /// </summary>
        /// <param name="tablename">数据表名称</param>
        /// <param name="dtparaname">删除条件对于的数据表的字段名称，可以多个</param>       
        /// <param name="dtparatypes">MySqlDbType[]</param>
        /// <param name="dtvalues">删除条件对于的数据表的字段名称对应的字段的值 </param>
        ///  <param name="condition_connectstr">连接条件的逻辑字符串，可以是 and  或者 or </param>
        /// 
        /// <returns></returns>
        public int DeleteDTTableOneRow(string tablename, string[] dtparaname,  MySqlDbType[] dtparatypes, string[] dtvalues,string condition_connectstr="and")
        {
            int result = 0;
            try
            {
               // commandtext = "delete  from userinfo where iduserinfo=@id and ";

                var commandtext = "delete  from  " + tablename.ToString() + " where ";
                MySqlParameter[] para = new MySqlParameter[dtparaname.Length];
                for (int i = 0; i < dtparaname.Length; i++)
                {

                    if (i == dtparaname.Length - 1)
                    {
                      
                        commandtext += dtparaname[i].ToString()+"=@para"+i.ToString();
                    }
                    else
                    {
                        commandtext += dtparaname[i].ToString() + "=@para" + i.ToString() + " "+condition_connectstr+" ";
                    }
                    para[i] = new MySqlParameter("@para" + i.ToString(), dtparatypes[i]);
                    para[i].Value = dtvalues[i];
                }
                result= ExecuteNonQuery(CommandType.Text, commandtext, para);
            }
            catch (Exception ex)
            {
                result = -1;
                MyBasicFun.LogWarn("DeleteDTTableOneRow Abnormal!" + ex.Message);
            }
            return result;
        }


        public int UpdateDTTableOneRow(string tablename,
            string set_dtparaname, MySqlDbType set_dtparatypes, string set_dtvalues,
            string[] condition_dtparaname,MySqlDbType[] condition_dtparatypes, string[] condition_dtvalues, string condition_connectstr = "and")
        {
            int result = 0;
            try
            {
                // commandtext = "delete  from userinfo where iduserinfo=@id and ";

                var commandtext = "update  " + tablename.ToString() + " set "+ set_dtparaname+ "=@para0 where ";
                MySqlParameter[] set_para = new MySqlParameter[condition_dtparaname.Length+1];
                set_para[0] = new MySqlParameter("@para0", set_dtparatypes);
                set_para[0].Value = set_dtvalues;

                for (int i = 1; i < condition_dtparaname.Length+1; i++)
                {

                    if (i == condition_dtparaname.Length)
                    {

                        commandtext += condition_dtparaname[i-1].ToString() + "=@para" + i.ToString();
                    }
                    else
                    {
                        commandtext += condition_dtparaname[i-1].ToString() + "=@para" + i.ToString() + " " + condition_connectstr + " ";
                    }

                    set_para[i] = new MySqlParameter("@para" + i.ToString(), condition_dtparatypes[i-1]);
                    set_para[i].Value = condition_dtvalues[i-1];
                }
                result = ExecuteNonQuery(CommandType.Text, commandtext, set_para);
            }
            catch (Exception ex)
            {
                result = -1;
                MyBasicFun.LogWarn("UpdateDTTableOneRow Abnormal!" + ex.Message);
            }
            return result;
        }


        /// <summary>
        /// 执行一个无参数的存储过程
        /// </summary>
        /// <param name="procedurename">存储过程的名称</param>
        /// <returns></returns>
        public int RunStoredProcedure(string procedurename)
        {
            int result = 0;
            try
            {
               var commandType = CommandType.StoredProcedure;
               result = ExecuteNonQuery(commandType, procedurename, null);
            }
            catch (Exception ex)
            {
                result = -1;
                MyBasicFun.LogWarn("RunStoredProcedure Abnormal!" + ex.Message);
            }
            return result;
        }






    }

转载请说明出处。

BR!