VisualStudio 连接 MySql 实现增删查改

首先创建数据库，建立一个用户登录表

2、visualStudio默认是不支持MySql的，要想通过Ado.Net 操作MySql

需要在管理NeGet包添加对MySql.Data  和 MySql.Data.Entity的引用

3、在app.Config中添加数据库连接信息

4、前端页面代码：

       <WrapPanel>    
            <Button Content="是否存在" Name="IsExitBtn" Click="IsExitBtn_Click"
                    Width="60" Height="30" ></Button>
            <Button Content="新增" Name="AddBtn" Click="AddBtn_Click"
                    Width="60" Height="30"></Button>
            <Button Content="修改" Name="UpdateBtn" Click="UpdateBtn_Click"
                    Width="60" Height="30"></Button>
            <Button Content="删除" Name="DelBtn" Click="DelBtn_Click"
                    Width="60" Height="30"></Button>
            <Button Content="批量删除" Name="BatchDelBtn" Click="BatchDelBtn_Click"
                    Width="60" Height="30"></Button>
            <Button Content="批量获取" Name="BatchGetListBtn" Click="BatchGetListBtn_Click"
                    Width="60" Height="30" ></Button>   
        </WrapPanel>

5、cs后台代码：

         private void AddBtn_Click(object sender, RoutedEventArgs e)
        {
            #region 新增
            StringBuilder addStrSql = new StringBuilder();
            addStrSql.Append("insert into LoginUser(");
            addStrSql.Append("UserId,Name,Age)");
            addStrSql.Append(" values (");
            addStrSql.Append("@UserId,@Name,@Age)");

            MySqlParameter[] parameters = {
                    new MySqlParameter("@UserId", 3),
                    new MySqlParameter("@Name", "张三"),
                    new MySqlParameter("@Age", 32)};
            var add = new CaseUserData().Add(addStrSql.ToString(), parameters);
            #endregion
        }

        private void UpdateBtn_Click(object sender, RoutedEventArgs e)
        {
            #region 修改
            StringBuilder updateStrSql = new StringBuilder();
            updateStrSql.Append("update LoginUser set ");
            updateStrSql.Append("Name=@Name,");
            updateStrSql.Append("Age=@Age");
            updateStrSql.Append(" WHERE UserId=@UserId");
            MySqlParameter[] uparameters = {
                    new MySqlParameter("@UserId", 1),
                    new MySqlParameter("@Name", "王五"),
                    new MySqlParameter("@Age", 33) };
            var update = new CaseUserData().Update(updateStrSql.ToString(), uparameters);
            #endregion
        }

        private void DelBtn_Click(object sender, RoutedEventArgs e)
        {
            #region 删除一条数据
            StringBuilder DelStrSql = new StringBuilder();
            DelStrSql.Append("delete from LoginUser ");
            DelStrSql.Append(" where UserId=@ID ");
            MySqlParameter[] delparameters = {
                    new MySqlParameter("@ID", 1) };
            var del = new CaseUserData().Delete(DelStrSql.ToString(), delparameters);
            #endregion
        }

        private void BatchDelBtn_Click(object sender, RoutedEventArgs e)
        {
            #region 批量删除数据
            List<int> idLists = new List<int>();
            string ids = string.Join(",", idLists);                //List数组的每个元素加上引号,如（"12","32","5456","876455"）
            string s1 = string.Format("'{0}'", ids.Replace(",", "','"));

            StringBuilder BatchDelStrSql = new StringBuilder();
            BatchDelStrSql.Append("delete from LoginUser ");
            BatchDelStrSql.Append(" where UserId in (" + s1 + ")");
            var batchDel = new CaseUserData().DeleteList(BatchDelStrSql.ToString());
            #endregion
        }

        private void BatchGetListBtn_Click(object sender, RoutedEventArgs e)
        {
            #region 批量获取数据
            StringBuilder batchGetStrSql = new StringBuilder();
            batchGetStrSql.Append("select UserId,Name,Age FROM LoginUser ");
            batchGetStrSql.Append(" where Age > 30");
            var batchGetList = new CaseUserData().GetList(batchGetStrSql.ToString());
            #endregion 
        }

        private void IsExitBtn_Click(object sender, RoutedEventArgs e)
        {
            #region 数据是否存在
            StringBuilder strSql = new StringBuilder();
            strSql.Append("select count(1) from LoginUser");
            strSql.Append(" where UserId=@ID ");
            var d = new CaseUserData().Exists(strSql.ToString(), 1);
            #endregion
        }

6、定义一些基本方法的接口：

using System;
using System.Data;
using System.Collections.Generic;
using MvvmFuncationApp.DbHelper;
using MySql.Data.MySqlClient;

namespace iPIS.Server.IDAL
{
    /// <summary>
    /// 接口层caseuserdata
    /// </summary>
    public interface ICaseUserData
    {
        #region  成员方法
        /// <summary>
        /// 是否存在该记录
        /// </summary>
        bool Exists(string StrSql,int ID);
        /// <summary>
        /// 增加一条数据
        /// </summary>
        bool Add(string strSql,MySqlParameter[] parameters);
        /// <summary>
        /// 更新一条数据
        /// </summary>
        bool Update(string strSql, MySqlParameter[] parameters);
        /// <summary>
        /// 删除一条数据
        /// </summary>
        bool Delete(string strSql, MySqlParameter[] parameters);
        bool DeleteList(string strSql);
        /// <summary>
        /// 得到一个对象实体
        /// </summary>
        ParametersModel GetModel(int ID);
        /// <summary>
        /// 获得数据列表
        /// </summary>
        List<ParametersModel> GetList(string strWhere);
        
        #endregion  成员方法
        #region  MethodEx

        #endregion  MethodEx
    } 
}

7、定义一个类，实现方法接口：

using iPIS.Server.IDAL;
using MvvmFuncationApp.DbHelper;
using MySql.Data.MySqlClient;
using System;
using System.Collections.Generic;
using System.Data;
using System.Runtime.Serialization;
using System.Text;
using System.Xml.Linq;

namespace iPIS.Server.Core
{
    /// <summary>
    /// 数据访问类
    /// </summary>
    public partial class CaseUserData : ICaseUserData
    {
        public CaseUserData()
        { }
        /// <summary>
        /// 是否存在该记录
        /// </summary>
        public bool Exists(string StrSql,int ID)
        {
            MySqlParameter[] parameters = {
                    new MySqlParameter("@ID", MySqlDbType.Int32,10)         };
            parameters[0].Value = ID;

            return DbHelperMySql.Exists(StrSql.ToString(), parameters);
        }

        /// <summary>
        /// 增加一条数据
        /// </summary>
        public bool Add(string StrSql, MySqlParameter[] parameters)
        {
            int rows = DbHelperMySql.ExecuteSql(StrSql.ToString(), parameters);
            if (rows > 0)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// 更新一条数据
        /// </summary>
        public bool Update(string StrSql, MySqlParameter[] parameters)
        {       
            int rows = DbHelperMySql.ExecuteSql(StrSql.ToString(), parameters);
            if (rows > 0)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// 删除一条数据
        /// </summary>
        public bool Delete(string StrSql,MySqlParameter[] parameters)
        {
            int rows = DbHelperMySql.ExecuteSql(StrSql.ToString(), parameters);
            if (rows > 0)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// 批量删除数据
        /// </summary>
        public bool DeleteList(string BatchDelStrSql)
        {
            int rows = DbHelperMySql.ExecuteSql(BatchDelStrSql.ToString());
            if (rows > 0)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// 得到一个对象实体
        /// </summary>
        public ParametersModel GetModel(int ID)
        {
            StringBuilder strSql = new StringBuilder();
            strSql.Append("select UserId,Name,Age from LoginUser ");
            strSql.Append(" where UserId=@ID ");
            MySqlParameter[] parameters = {
                    new MySqlParameter("@ID", MySqlDbType.Int32,10)         };
            parameters[0].Value = ID;

            ParametersModel model = new ParametersModel();
            using (var ds = DbHelperMySql.ExecuteReader(strSql.ToString(), parameters))
            {
                while (ds.Read())
                {
                    return DataRowToModel(ds);
                }
            }
            return null;
        }

        /// <summary>
        /// 得到一个对象实体
        /// </summary>
        public ParametersModel DataRowToModel(IDataReader row)
        {
            ParametersModel model = new ParametersModel();
            if (row != null)
            {
                if (row["UserId"] != null && row["UserId"].ToString() != "")
                {
                    model.ID = int.Parse(row["UserId"].ToString());
                }
                if (row["Name"] != null)
                {
                    model.Name = row["Name"].ToString();
                }
                if (row["Age"] != null && row["Age"].ToString() != "")
                {
                    model.Age = int.Parse(row["Age"].ToString());
                }
                
            }
            return model;
        }

        /// <summary>
        /// 获得数据列表
        /// </summary>
        public List<ParametersModel> GetList(string strSql)
        {
            using (var ds = DbHelperMySql.ExecuteReader(strSql.ToString()))
            {
                var list = new List<ParametersModel>();
                while (ds.Read())
                {
                    list.Add(DataRowToModel(ds));
                }
                return list;
            }
        }
    }
}

8、数据库操作封装类：

using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using MySql.Data.MySqlClient;

namespace MvvmFuncationApp.DbHelper
{
    public abstract class DbHelperMySql
    {
        //数据库连接字符串(web.config来配置)，可以动态更改connectionString支持多数据库.        
        public static string connectionString = System.Configuration.ConfigurationManager.AppSettings["ConnectionString"]; // "server=127.0.0.1;port=3306;database=lktest;uid=root;pwd=123456";

        protected DbHelperMySql()
        {
        }

        #region 公用方法
        /// <summary>
        /// 得到最大值
        /// </summary>
        /// <param name="fieldName"></param>
        /// <param name="tableName"></param>
        /// <returns></returns>
        public static int GetMaxId(string fieldName, string tableName)
        {
            string strsql = "select max(" + fieldName + ")+1 from " + tableName;
            object obj = GetSingle(strsql);
            return obj == null ? 1 : int.Parse(obj.ToString());
        }

        /// <summary>
        /// 是否存在（基于MySqlParameter）
        /// </summary>
        /// <param name="strSql"></param>
        /// <param name="cmdParms"></param>
        /// <returns></returns>
        public static bool Exists(string strSql, params MySqlParameter[] cmdParms)
        {
            var obj = GetSingle(strSql, cmdParms);
            int cmdresult;
            if ((Equals(obj, null)) || (Equals(obj, DBNull.Value)))
            {
                cmdresult = 0;
            }
            else
            {
                cmdresult = int.Parse(obj.ToString());
            }
            return cmdresult != 0;
        }
        #endregion

        #region  执行简单SQL语句

        /// <summary>
        /// 执行SQL语句，返回影响的记录数
        /// </summary>
        /// <param name="sqlString">SQL语句</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSql(string sqlString)
        {
            using (var connection = new MySqlConnection(connectionString))
            {
                using (var cmd = new MySqlCommand(sqlString, connection))
                {
                    try
                    {
                        connection.Open();
                        var rows = cmd.ExecuteNonQuery();
                        return rows;
                    }
                    catch (MySqlException e)
                    {
                        connection.Close();
                        throw e;
                    }
                }
            }
        }

        public static int ExecuteSqlByTime(string sqlString, int times)
        {
            using (var connection = new MySqlConnection(connectionString))
            {
                using (var cmd = new MySqlCommand(sqlString, connection))
                {
                    try
                    {
                        connection.Open();
                        cmd.CommandTimeout = times;
                        var rows = cmd.ExecuteNonQuery();
                        return rows;
                    }
                    catch (MySqlException e)
                    {
                        connection.Close();
                        throw e;
                    }
                }
            }
        }

        /// <summary>
        /// 执行多条SQL语句，实现数据库事务。
        /// </summary>
        /// <param name="sqlStringList">多条SQL语句</param>        
        public static int ExecuteSqlTran(List<String> sqlStringList)
        {
            using (var conn = new MySqlConnection(connectionString))
            {
                conn.Open();
                var cmd = new MySqlCommand { Connection = conn };
                var tx = conn.BeginTransaction();
                cmd.Transaction = tx;
                try
                {
                    var count = 0;
                    foreach (var strsql in sqlStringList.Where(strsql => strsql.Trim().Length > 1))
                    {
                        cmd.CommandText = strsql;
                        count += cmd.ExecuteNonQuery();
                    }
                    tx.Commit();
                    return count;
                }
                catch (Exception ex)
                {
                    tx.Rollback();
                    throw ex;
                }
            }
        }

        /// <summary>
        /// 执行带一个存储过程参数的的SQL语句。
        /// </summary>
        /// <param name="sqlString">SQL语句</param>
        /// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSql(string sqlString, string content)
        {
            using (var connection = new MySqlConnection(connectionString))
            {
                var cmd = new MySqlCommand(sqlString, connection);
                var myParameter = new MySqlParameter("@content", SqlDbType.NText) { Value = content };
                cmd.Parameters.Add(myParameter);
                try
                {
                    connection.Open();
                    var rows = cmd.ExecuteNonQuery();
                    return rows;
                }
                catch (MySqlException e)
                {
                    throw e;
                }
                finally
                {
                    cmd.Dispose();
                    connection.Close();
                }
            }
        }

        /// <summary>
        /// 执行带一个存储过程参数的的SQL语句。
        /// </summary>
        /// <param name="sqlString">SQL语句</param>
        /// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
        /// <returns>影响的记录数</returns>
        public static object ExecuteSqlGet(string sqlString, string content)
        {
            using (var connection = new MySqlConnection(connectionString))
            {
                var cmd = new MySqlCommand(sqlString, connection);
                var myParameter = new MySqlParameter("@content", SqlDbType.NText) { Value = content };
                cmd.Parameters.Add(myParameter);
                try
                {
                    connection.Open();
                    var obj = cmd.ExecuteScalar();
                    if ((Equals(obj, null)) || (Equals(obj, DBNull.Value)))
                    {
                        return null;
                    }
                    else
                    {
                        return obj;
                    }
                }
                catch (MySqlException e)
                {
                    throw e;
                }
                finally
                {
                    cmd.Dispose();
                    connection.Close();
                }
            }
        }

        /// <summary>
        /// 向数据库里插入图像格式的字段(和上面情况类似的另一种实例)
        /// </summary>
        /// <param name="strSql">SQL语句</param>
        /// <param name="fs">图像字节,数据库的字段类型为image的情况</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSqlInsertImg(string strSql, byte[] fs)
        {
            using (var connection = new MySqlConnection(connectionString))
            {
                var cmd = new MySqlCommand(strSql, connection);
                var myParameter = new MySqlParameter("@fs", SqlDbType.Image) { Value = fs };
                cmd.Parameters.Add(myParameter);
                try
                {
                    connection.Open();
                    var rows = cmd.ExecuteNonQuery();
                    return rows;
                }
                catch (MySqlException e)
                {
                    throw e;
                }
                finally
                {
                    cmd.Dispose();
                    connection.Close();
                }
            }
        }

        /// <summary>
        /// 执行一条计算查询结果语句，返回查询结果（object）。
        /// </summary>
        /// <param name="sqlString">计算查询结果语句</param>
        /// <returns>查询结果（object）</returns>
        public static object GetSingle(string sqlString)
        {
            using (var connection = new MySqlConnection(connectionString))
            {
                using (var cmd = new MySqlCommand(sqlString, connection))
                {
                    try
                    {
                        connection.Open();
                        var obj = cmd.ExecuteScalar();
                        if ((Equals(obj, null)) || (Equals(obj, DBNull.Value)))
                        {
                            return null;
                        }
                        else
                        {
                            return obj;
                        }
                    }
                    catch (MySqlException e)
                    {
                        connection.Close();
                        throw e;
                    }
                }
            }
        }

        public static object GetSingle(string sqlString, int times)
        {
            using (var connection = new MySqlConnection(connectionString))
            {
                using (var cmd = new MySqlCommand(sqlString, connection))
                {
                    try
                    {
                        connection.Open();
                        cmd.CommandTimeout = times;
                        var obj = cmd.ExecuteScalar();
                        if ((Equals(obj, null)) || (Equals(obj, DBNull.Value)))
                        {
                            return null;
                        }
                        else
                        {
                            return obj;
                        }
                    }
                    catch (MySqlException e)
                    {
                        connection.Close();
                        throw e;
                    }
                }
            }
        }
        /// <summary>
        /// 执行查询语句，返回MySqlDataReader ( 注意：调用该方法后，一定要对MySqlDataReader进行Close )
        /// </summary>
        /// <param name="strSql">查询语句</param>
        /// <returns>MySqlDataReader</returns>
        public static MySqlDataReader ExecuteReader(string strSql)
        {
            var connection = new MySqlConnection(connectionString);
            var cmd = new MySqlCommand(strSql, connection);
            try
            {
                connection.Open();
                var myReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                return myReader;
            }
            catch (MySqlException e)
            {
                throw e;
            }

        }

        /// <summary>
        /// 执行查询语句，返回DataSet
        /// </summary>
        /// <param name="sqlString">查询语句</param>
        /// <returns>DataSet</returns>
        [Obsolete("不再使用该接口，请使用ExecuteReader(string strSql)")]
        public static DataSet Query(string sqlString)
        {
            using (var connection = new MySqlConnection(connectionString))
            {
                var ds = new DataSet();
                try
                {
                    connection.Open();
                    var command = new MySqlDataAdapter(sqlString, connection);
                    command.Fill(ds, "ds");
                }
                catch (MySqlException ex)
                {
                    throw new Exception(ex.Message);
                }
                return ds;
            }
        }

        /// <summary>
        /// 执行查询语句，返回DataSet
        /// </summary>
        /// <param name="sqlString"></param>
        /// <param name="times">超时时间</param>
        /// <returns></returns>
        [Obsolete("不再使用该接口，请使用ExecuteReader(string strSql)")]
        public static DataSet Query(string sqlString, int times)
        {
            using (var connection = new MySqlConnection(connectionString))
            {
                var ds = new DataSet();
                try
                {
                    connection.Open();
                    var command = new MySqlDataAdapter(sqlString, connection) { SelectCommand = { CommandTimeout = times } };
                    command.Fill(ds, "ds");
                }
                catch (MySqlException ex)
                {
                    throw new Exception(ex.Message);
                }
                return ds;
            }
        }

        /// <summary>
        /// 删除案件
        /// </summary>
        /// <returns></returns>
        public static int ExecuteProcedure(string caseid)
        {
            using (var connection = new MySqlConnection(connectionString))
            {
                using (var cmd = new MySqlCommand())
                {
                    try
                    {
                        cmd.Connection = connection;
                        connection.Open();
                        cmd.CommandText = "sp_DeleteCaseInfo";
                        cmd.CommandType = CommandType.StoredProcedure;

                        MySqlParameter id = new MySqlParameter("?id", MySqlDbType.VarChar, 50);
                        id.Value = caseid;
                        cmd.Parameters.Add(id);

                        MySqlParameter result = new MySqlParameter("?result", MySqlDbType.Int32, 4);
                        result.Direction = ParameterDirection.Output;
                        cmd.Parameters.Add(result);

                        cmd.ExecuteNonQuery();
                        int state = int.Parse(result.Value.ToString());
                        return state;
                    }
                    catch (MySqlException e)
                    {
                        throw e;
                    }
                }
            }
        }

        #endregion

        #region 执行带参数的SQL语句

        /// <summary>
        /// 执行SQL语句，返回影响的记录数
        /// </summary>
        /// <param name="sqlString">SQL语句</param>
        /// <param name="cmdParms">参数化</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSql(string sqlString, params MySqlParameter[] cmdParms)
        {
            using (var connection = new MySqlConnection(connectionString))
            {
                using (var cmd = new MySqlCommand())
                {
                    try
                    {
                        PrepareCommand(cmd, connection, null, sqlString, cmdParms);
                        var rows = cmd.ExecuteNonQuery();
                        cmd.Parameters.Clear();
                        return rows;
                    }
                    catch (MySqlException e)
                    {
                        throw e;
                    }
                }
            }
        }


        /// <summary>
        /// 执行多条SQL语句，实现数据库事务。
        /// </summary>
        /// <param name="sqlStringList">SQL语句的哈希表（key为sql语句，value是该语句的MySqlParameter[]）</param>
        public static void ExecuteSqlTran(Hashtable sqlStringList)
        {
            using (var conn = new MySqlConnection(connectionString))
            {
                conn.Open();
                using (var trans = conn.BeginTransaction())
                {
                    var cmd = new MySqlCommand();
                    try
                    {
                        //循环
                        foreach (DictionaryEntry myDe in sqlStringList)
                        {
                            var cmdText = myDe.Key.ToString();
                            var cmdParms = (MySqlParameter[])myDe.Value;
                            PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
                            var val = cmd.ExecuteNonQuery();
                            cmd.Parameters.Clear();
                        }
                        trans.Commit();
                    }
                    catch
                    {
                        trans.Rollback();
                        throw;
                    }
                }
            }
        }

        /// <summary>
        /// 执行多条SQL语句，实现数据库事务。
        /// </summary>
        /// <param name="cmdList">SQL语句的哈希表（key为sql语句，value是该语句的MySqlParameter[]）</param>
        public static int ExecuteSqlTran(List<CommandInfo> cmdList)
        {
            using (var conn = new MySqlConnection(connectionString))
            {
                conn.Open();
                using (var trans = conn.BeginTransaction())
                {
                    var cmd = new MySqlCommand();
                    try
                    {
                        var count = 0;
                        //循环
                        foreach (var myDe in cmdList)
                        {
                            string cmdText = myDe.CommandText;
                            var cmdParms = (MySqlParameter[])myDe.Parameters;
                            PrepareCommand(cmd, conn, trans, cmdText, cmdParms);

                            if (myDe.EffentNextType == EffentNextType.WhenHaveContine || myDe.EffentNextType == EffentNextType.WhenNoHaveContine)
                            {
                                if (myDe.CommandText.ToLower().IndexOf("count(") == -1)
                                {
                                    trans.Rollback();
                                    return 0;
                                }

                                object obj = cmd.ExecuteScalar();
                                bool isHave = false;
                                if (obj == null && obj == DBNull.Value)
                                {
                                    isHave = false;
                                }
                                isHave = Convert.ToInt32(obj) > 0;

                                if (myDe.EffentNextType == EffentNextType.WhenHaveContine && !isHave)
                                {
                                    trans.Rollback();
                                    return 0;
                                }
                                if (myDe.EffentNextType == EffentNextType.WhenNoHaveContine && isHave)
                                {
                                    trans.Rollback();
                                    return 0;
                                }
                                continue;
                            }
                            int val = cmd.ExecuteNonQuery();
                            count += val;
                            if (myDe.EffentNextType == EffentNextType.ExcuteEffectRows && val == 0)
                            {
                                trans.Rollback();
                                return 0;
                            }
                            cmd.Parameters.Clear();
                        }
                        trans.Commit();
                        return count;
                    }
                    catch
                    {
                        trans.Rollback();
                        throw;
                    }
                }
            }
        }

        /// <summary>
        /// 执行多条SQL语句，实现数据库事务。
        /// </summary>
        /// <param name="sqlStringList">SQL语句的哈希表（key为sql语句，value是该语句的MySqlParameter[]）</param>
        public static void ExecuteSqlTranWithIndentity(System.Collections.Generic.List<CommandInfo> sqlStringList)
        {
            using (var conn = new MySqlConnection(connectionString))
            {
                conn.Open();
                using (var trans = conn.BeginTransaction())
                {
                    var cmd = new MySqlCommand();
                    try
                    {
                        var indentity = 0;
                        //循环
                        foreach (var myDe in sqlStringList)
                        {
                            var cmdText = myDe.CommandText;
                            var cmdParms = (MySqlParameter[])myDe.Parameters;
                            foreach (var q in cmdParms)
                            {
                                if (q.Direction == ParameterDirection.InputOutput)
                                {
                                    q.Value = indentity;
                                }
                            }
                            PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
                            int val = cmd.ExecuteNonQuery();
                            foreach (var q in cmdParms)
                            {
                                if (q.Direction == ParameterDirection.Output)
                                {
                                    indentity = Convert.ToInt32(q.Value);
                                }
                            }
                            cmd.Parameters.Clear();
                        }
                        trans.Commit();
                    }
                    catch
                    {
                        trans.Rollback();
                        throw;
                    }
                }
            }
        }

        /// <summary>
        /// 执行多条SQL语句，实现数据库事务。
        /// </summary>
        /// <param name="sqlStringList">SQL语句的哈希表（key为sql语句，value是该语句的MySqlParameter[]）</param>
        public static void ExecuteSqlTranWithIndentity(Hashtable sqlStringList)
        {
            using (var conn = new MySqlConnection(connectionString))
            {
                conn.Open();
                using (var trans = conn.BeginTransaction())
                {
                    var cmd = new MySqlCommand();
                    try
                    {
                        var indentity = 0;
                        //循环
                        foreach (DictionaryEntry myDe in sqlStringList)
                        {
                            string cmdText = myDe.Key.ToString();
                            var cmdParms = (MySqlParameter[])myDe.Value;
                            foreach (MySqlParameter q in cmdParms)
                            {
                                if (q.Direction == ParameterDirection.InputOutput)
                                {
                                    q.Value = indentity;
                                }
                            }
                            PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
                            int val = cmd.ExecuteNonQuery();
                            foreach (MySqlParameter q in cmdParms)
                            {
                                if (q.Direction == ParameterDirection.Output)
                                {
                                    indentity = Convert.ToInt32(q.Value);
                                }
                            }
                            cmd.Parameters.Clear();
                        }
                        trans.Commit();
                    }
                    catch
                    {
                        trans.Rollback();
                        throw;
                    }
                }
            }
        }

        /// <summary>
        /// 执行一条计算查询结果语句，返回查询结果（object）。
        /// </summary>
        /// <param name="sqlString">计算查询结果语句</param>
        /// <param name="cmdParms">参数化</param>
        /// <returns>查询结果（object）</returns>
        public static object GetSingle(string sqlString, params MySqlParameter[] cmdParms)
        {
            using (var connection = new MySqlConnection(connectionString))
            {
                using (var cmd = new MySqlCommand())
                {
                    try
                    {
                        PrepareCommand(cmd, connection, null, sqlString, cmdParms);
                        var obj = cmd.ExecuteScalar();
                        cmd.Parameters.Clear();
                        if ((Equals(obj, null)) || (Equals(obj, DBNull.Value)))
                        {
                            return null;
                        }
                        else
                        {
                            return obj;
                        }
                    }
                    catch (MySqlException e)
                    {
                        throw e;
                    }
                }
            }
        }

        /// <summary>
        /// 执行查询语句，返回MySqlDataReader ( 注意：调用该方法后，一定要对MySqlDataReader进行Close )
        /// </summary>
        /// <param name="sqlString">查询语句</param>
        /// <param name="cmdParms">参数化</param>
        /// <returns>MySqlDataReader</returns>
        public static MySqlDataReader ExecuteReader(string sqlString, params MySqlParameter[] cmdParms)
        {
            var connection = new MySqlConnection(connectionString);
            var cmd = new MySqlCommand();
            try
            {
                PrepareCommand(cmd, connection, null, sqlString, cmdParms);
                var myReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                cmd.Parameters.Clear();
                return myReader;
            }
            catch (MySqlException e)
            {
                throw e;
            }
            //            finally
            //            {
            //                cmd.Dispose();
            //                connection.Close();
            //            }    

        }

        /// <summary>
        /// 执行查询语句，返回DataSet
        /// </summary>
        /// <param name="sqlString">查询语句</param>
        /// <param name="cmdParms">参数化</param>
        /// <returns>DataSet</returns>
        [Obsolete("不再使用该接口，请使用ExecuteReader(string sqlString, params MySqlParameter[] cmdParms)")]
        public static DataSet Query(string sqlString, params MySqlParameter[] cmdParms)
        {
            using (var connection = new MySqlConnection(connectionString))
            {
                var cmd = new MySqlCommand();
                PrepareCommand(cmd, connection, null, sqlString, cmdParms);
                using (var da = new MySqlDataAdapter(cmd))
                {
                    var ds = new DataSet();
                    try
                    {
                        da.Fill(ds, "ds");
                        cmd.Parameters.Clear();
                    }
                    catch (MySqlException ex)
                    {
                        throw new Exception(ex.Message);
                    }
                    return ds;
                }
            }
        }

        private static void PrepareCommand(MySqlCommand cmd, MySqlConnection conn, MySqlTransaction trans, 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 = CommandType.Text;//cmdType;
            if (cmdParms != null)
            {


                foreach (MySqlParameter parameter in cmdParms)
                {
                    if ((parameter.Direction == ParameterDirection.InputOutput || parameter.Direction == ParameterDirection.Input) &&
                        (parameter.Value == null))
                    {
                        parameter.Value = DBNull.Value;
                    }
                    cmd.Parameters.Add(parameter);
                }
            }
        }

        #endregion
    }
}

9、数据库数据转模型：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MvvmFuncationApp.DbHelper
{
        /// <summary>
        /// 案件关联用户自定义数据
        /// </summary>
        [Serializable]
        public partial class ParametersModel
        {
            public ParametersModel()
            { }
            #region Model
            private int _id;
            private string _DataID;
            private int _age;
            private string _name;
            private string _userdata;
            private string _extended1;
            private string _extended2;
            /// <summary>
            /// 
            /// </summary>
            public int ID
            {
                set { _id = value; }
                get { return _id; }
            }
            /// <summary>
            /// 关联数据ID，DataType=1 案件id；DataType=2 图片id
            /// </summary>
            public string DataID
            {
                set { _DataID = value; }
                get { return _DataID; }
            }
            /// <summary>
            /// 数据类型。详见枚举值
            /// </summary>
            public int Age
            {
                set { _age = value; }
                get { return _age; }
            }
            /// <summary>
            /// 数据名称
            /// </summary>
            public string Name
            {
                set { _name = value; }
                get { return _name; }
            }
            /// <summary>
            /// 数据详细内容
            /// </summary>
            public string UserData
            {
                set { _userdata = value; }
                get { return _userdata; }
            }
            /// <summary>
            /// 
            /// </summary>
            public string Extended1
            {
                set { _extended1 = value; }
                get { return _extended1; }
            }
            /// <summary>
            /// 
            /// </summary>
            public string Extended2
            {
                set { _extended2 = value; }
                get { return _extended2; }
            }
            #endregion Model

        }
    
}

 可以直接使用，亲测没问题。