C# 利用 ADO.NET 操作 MySQL 数据库

最新推荐文章于 2024-08-05 17:34:36 发布
最新推荐文章于 2024-08-05 17:34:36 发布
阅读量2.6k 收藏 9
点赞数 1
分类专栏： 后台开发 C# ADO.NET 文章标签： ADO.NET MySQL
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoYong_520/article/details/94465367
版权

首先给大家看一下这个小项目的结构（一个 WebAPI 的小项目）：

上面红框里的文件是这篇文章所涉及的主要文件。

首先在你的项目中添加 MySQL 的支持，在 NuGet 上搜索 MySql 并安装第三方库（不要选错了哟~），如下图：

创建一个MySQL数据库连接信息实体类，这个类会替代我们常用的连接字符串，而且可以实现对各个参数的配置、热修改。

/// <summary> MySQL数据库连接信息实体类
    /// </summary>
    public class MySqlDBConnectInfo
    {
        /// <summary> 唯一别名（用来区分是哪个链接，推荐策略：服务地址-数据库名）
        /// </summary>
        public string UniqueAlias { get; set; }

        /// <summary> 数据库服务连接地址，例："127.0.0.1"
        /// </summary>
        public string Server { get; set; }

        /// <summary> 数据库服务连接端口号
        /// </summary>
        public uint Port { get; set; }

        /// <summary> 连接的数据库
        /// </summary>
        public string Database { get; set; }

        /// <summary> 连接数据库的用户名
        /// </summary>
        public string UserID { get; set; }

        /// <summary> 用户密码
        /// </summary>
        public string Password { get; set; }

        /// <summary> 设置字符编码，例："utf8"
        /// </summary>
        public string CharacterSet { get; set; }

        /// <summary> 连接超时时间，单位秒
        /// </summary>
        public uint ConnectionTimeout { get; set; }

        /// <summary> 数据库执行超时时间，单位秒
        /// </summary>
        public uint DefaultCommandTimeout { get; set; }

        /// <summary> 是否开启连接池，true
        /// </summary>
        public bool Pooling { get; set; }

        /// <summary> 连接池中最小连接数
        /// </summary>
        public uint MinimumPoolSize { get; set; }

        /// <summary> 连接池中最大连接数
        /// </summary>
        public uint MaximumPoolSize { get; set; }

        /// <summary> 连接池中连接对象存活时间，单位秒
        /// </summary>
        public uint ConnectionLifeTime { get; set; }

        /// <summary> 连接是否使用压缩，true
        /// </summary>
        public bool UseCompression { get; set; }

        /// <summary> 表示连接池程序是否会自动登记创建线程的当前事务语境中的连接，ture
        /// </summary>
        public bool AutoEnlist { get; set; }

    }

 新建一个类 StartupInitMySqlConfig，用来控制程序启动时初始化MySQL数据库配置信息

/// <summary> 启动时初始化MySQL数据库配置信息
    /// </summary>
    public static class StartupInitMySqlConfig
    {

        /// <summary> 数据库连接信息配置文件 的 文件名 （MySqlConnectionConfig.xml）
        /// </summary>
        private const string MySqlDBConnectConfigFilename = "MySqlConnectionConfig.xml";


        /// <summary> 唯一别名 的 存储值
        /// </summary>
        private static string UniqueAliasSV = string.Empty;

        /// <summary>
        /// 唯一别名 锁；避免同时被修改
        /// </summary>
        private static readonly object _uniqueAliasLock = new object();


        /// <summary> 唯一别名（用来区分是哪个链接，推荐策略：服务地址_数据库名）
        /// </summary>
        private static string uniqueAlias = string.Empty;

        /// <summary> 唯一别名（用来区分是哪个链接，推荐策略：服务地址_数据库名）
        /// </summary>
        public static string UniqueAlias
        {
            get { return uniqueAlias; }
            set
            {
                uniqueAlias = value == null ? string.Empty : value;
            }
        }


        /// <summary> 声明一个[MySqlDBConnectInfo]数据库连接信息对象
        /// </summary>
        private static MySqlDBConnectInfo dbConnectInfo;

        /// <summary> 获取[MySqlDBConnectInfo]数据库连接信息对象（默认取配置文件中的第一个连接对象）
        /// </summary>
        public static MySqlDBConnectInfo DbConnectInfo
        {
            get
            {
                try
                {
                    lock (_uniqueAliasLock)
                    {
                        try
                        {
                            if (dbConnectInfo == null || UniqueAlias != UniqueAliasSV)
                            {
                                UniqueAliasSV = UniqueAlias;
                                string path = AppDomain.CurrentDomain.BaseDirectory + MySqlDBConnectConfigFilename;
                                if (!File.Exists(path))
                                {
                                    dbConnectInfo = null;
                                    throw new Exception("系统找不到数据库连接信息配置文件。");
                                }
                                else
                                {
                                    List<MySqlDBConnectInfo> dbConnectInfoList = XmlTool.XmlFlieToTObject<List<MySqlDBConnectInfo>>(path, Encoding.UTF8);
                                    if (string.IsNullOrWhiteSpace(UniqueAliasSV))
                                    {
                                        dbConnectInfo = dbConnectInfoList[0];
                                    }
                                    else
                                    {
                                        foreach (MySqlDBConnectInfo item in dbConnectInfoList)
                                        {
                                            if (item.UniqueAlias == UniqueAliasSV)
                                            {
                                                dbConnectInfo = item;
                                                break;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            dbConnectInfo = null;
                            throw new Exception("数据库连接信息配置文件[MySqlConfig.xml]转数据库连接信息对象[MySqlDBConnectInfo]时失败。\r\n" + ex.ToString());
                        }
                    }
                }
                catch (Exception ex)
                {
                    dbConnectInfo = null;
                    throw new Exception("数据库连接信息配置文件[MySqlConfig.xml]转数据库连接信息对象[MySqlDBConnectInfo]时失败。\r\n" + ex.ToString());
                }
                return dbConnectInfo;
            }
            set { dbConnectInfo = value; }
        }


    }

下面是一个 MySQL数据库操作工具类【核心功能都在这】

/// <summary> MySQL数据库操作工具类
    /// </summary>
    public class MySqlTool
    {

        /// <summary> 声明一个[MySqlDBConnectInfo]数据库连接信息对象
        /// </summary>
        private MySqlDBConnectInfo mysqlDbConnectInfo;

        /// <summary> 无参构造函数（获取 MySqlConfig.xml 配置文件中的第一个连接对象）
        /// </summary>
        public MySqlTool()
        {
            StartupInitMySqlConfig.UniqueAlias = string.Empty;
            mysqlDbConnectInfo = StartupInitMySqlConfig.DbConnectInfo;
        }

        /// <summary> 有参构造函数（获取 MySqlConfig.xml 配置文件中 UniqueAlias 参数所匹配的唯一别名的连接对象）
        /// </summary>
        /// <param name="uniqueAlias">连接对象的唯一别名，用来区分是哪个链接对象</param>
        public MySqlTool(string uniqueAlias)
        {
            StartupInitMySqlConfig.UniqueAlias = uniqueAlias;
            mysqlDbConnectInfo = StartupInitMySqlConfig.DbConnectInfo;
        }


        /// <summary> 声明一个[MySqlConnection]连接对象
        /// </summary>
        private MySqlConnection mysqlConnection;

        /// <summary> 获取[MySqlConnection]连接对象
        /// </summary>
        private MySqlConnection MysqlConnection
        {
            get
            {
                if (mysqlDbConnectInfo == null)
                {
                    mysqlDbConnectInfo = StartupInitMySqlConfig.DbConnectInfo;
                }
                if (mysqlConnection == null)
                {
                    try
                    {
                        MySqlConnectionStringBuilder connectStr = new MySqlConnectionStringBuilder();

                        connectStr.Server = mysqlDbConnectInfo.Server;
                        connectStr.Port = mysqlDbConnectInfo.Port;
                        connectStr.Database = mysqlDbConnectInfo.Database;
                        connectStr.UserID = mysqlDbConnectInfo.UserID;
                        connectStr.Password = mysqlDbConnectInfo.Password;
                        connectStr.CharacterSet = mysqlDbConnectInfo.CharacterSet;
                        connectStr.ConnectionTimeout = mysqlDbConnectInfo.ConnectionTimeout;
                        connectStr.DefaultCommandTimeout = mysqlDbConnectInfo.DefaultCommandTimeout;
                        connectStr.Pooling = mysqlDbConnectInfo.Pooling;
                        connectStr.MinimumPoolSize = mysqlDbConnectInfo.MinimumPoolSize;
                        connectStr.MaximumPoolSize = mysqlDbConnectInfo.MaximumPoolSize;
                        connectStr.ConnectionLifeTime = mysqlDbConnectInfo.ConnectionLifeTime;
                        connectStr.UseCompression = mysqlDbConnectInfo.UseCompression;
                        connectStr.AutoEnlist = mysqlDbConnectInfo.AutoEnlist;

                        mysqlConnection = new MySqlConnection(connectStr.GetConnectionString(true));
                    }
                    catch (Exception ex)
                    {
                        mysqlConnection = null;
                        throw new Exception("创建数据库连接时发生异常。\r\n" + ex.ToString());
                    }
                }
                return mysqlConnection;
            }
        }

        /// <summary> 获取当前对象已存在的连接信息[MySqlDBConnectInfo]
        /// </summary>
        /// <returns></returns>
        public MySqlDBConnectInfo GetMySqlConnectInfo()
        {
            return mysqlDbConnectInfo;
        }


        /// <summary> 打开数据库连接
        /// </summary>
        public void OpenConnect()
        {
            if (MysqlConnection.State == ConnectionState.Closed)
            {
                try
                {
                    MysqlConnection.Open();
                }
                catch (Exception ex)
                {
                    StartupInitMySqlConfig.DbConnectInfo = null;
                    throw new Exception("打开数据库连接时发生异常。\r\n" + ex.ToString());
                }
            }
            else if (MysqlConnection.State == ConnectionState.Broken)
            {
                try
                {
                    MysqlConnection.Close();
                    MysqlConnection.Open();
                }
                catch (Exception ex)
                {
                    StartupInitMySqlConfig.DbConnectInfo = null;
                    throw new Exception("打开数据库连接时发生异常。\r\n" + ex.ToString());
                }
            }
        }

        /// <summary> 关闭数据库连接
        /// </summary>
        public void CloseConnect()
        {
            if (MysqlConnection.State != ConnectionState.Closed)
            {
                try
                {
                    MysqlConnection.Close();
                }
                catch (Exception ex)
                {
                    throw new Exception("关闭数据库连接时发生异常。\r\n" + ex.ToString());
                }
            }
        }


        /// <summary> 声明一个[MySqlTransaction]事务处理对象
        /// </summary>
        private MySqlTransaction mysqlTransaction;

        /// <summary> 开启事务处理
        /// </summary>
        public void BeginTransaction()
        {
            try
            {
                mysqlTransaction = MysqlConnection.BeginTransaction();
            }
            catch (Exception ex)
            {
                throw new Exception("开始事务处理时发生异常。\r\n" + ex.ToString());
            }
        }

        /// <summary> 提交事务
        /// </summary>
        public void Commit()
        {
            try
            {
                if (mysqlTransaction != null)
                {
                    mysqlTransaction.Commit();
                    mysqlTransaction.Dispose();
                    mysqlTransaction = null;
                }
            }
            catch (Exception ex)
            {
                throw new Exception("提交事务时发生异常。\r\n" + ex.ToString());
            }
        }

        /// <summary> 回滚事务
        /// </summary>
        public void Rollback()
        {
            try
            {
                if (mysqlTransaction != null)
                {
                    mysqlTransaction.Rollback();
                    mysqlTransaction.Dispose();
                    mysqlTransaction = null;
                }
            }
            catch (Exception ex)
            {
                throw new Exception("回滚事务时发生异常。\r\n" + ex.ToString());
            }
        }


        /// <summary> 执行SQL语句，返回受影响行数
        /// </summary>
        /// <param name="sql">string：SQL语句</param>
        /// <param name="dicParam">Dictionary：SQL参数化</param>
        /// <returns>int</returns>
        public int ExecuteNonQuery(string sql, Dictionary<string, object> dicParam = null)
        {
            int row = -1;
            try
            {
                using (MySqlCommand command = MysqlConnection.CreateCommand())
                {
                    try
                    {
                        command.CommandText = sql;
                        if (dicParam != null && dicParam.Count > 0)
                        {
                            foreach (KeyValuePair<string, object> kvp in dicParam)
                            {
                                command.Parameters.AddWithValue(kvp.Key, kvp.Value);
                            }
                        }
                        row = command.ExecuteNonQuery();
                    }
                    catch (Exception ex)
                    {
                        row = -1;
                        throw new Exception("执行SQL语句时发生异常[ExecuteNonQuery()]。\r\n" + ex.ToString());
                    }
                }
            }
            catch (Exception ex)
            {
                row = -1;
                throw new Exception("执行SQL语句时发生异常[ExecuteNonQuery()]。\r\n" + ex.ToString());
            }
            return row;
        }

        /// <summary> 执行SQL查询，返回第一行第一列的值（object对象）。【例如：count()函数】
        /// </summary>
        /// <param name="sql">string：SQL语句</param>
        /// <param name="dicParam">Dictionary：SQL参数化</param>
        /// <returns>object</returns>
        public object ExecuteScalar(string sql, Dictionary<string, object> dicParam = null)
        {
            object obj = null;
            try
            {
                using (MySqlCommand command = MysqlConnection.CreateCommand())
                {
                    try
                    {
                        command.CommandText = sql;
                        if (dicParam != null && dicParam.Count > 0)
                        {
                            foreach (KeyValuePair<string, object> kvp in dicParam)
                            {
                                command.Parameters.AddWithValue(kvp.Key, kvp.Value);
                            }
                        }
                        obj = command.ExecuteScalar();
                    }
                    catch (Exception ex)
                    {
                        obj = null;
                        throw new Exception("执行SQL语句查询时发生异常[ExecuteScalar()]。\r\n" + ex.ToString());
                    }
                }
            }
            catch (Exception ex)
            {
                obj = null;
                throw new Exception("执行SQL语句查询时发生异常[ExecuteScalar()]。\r\n" + ex.ToString());
            }
            return obj;
        }

        /// <summary> 执行SQL查询，返回一个[ MySqlDataReader ]只进只读对象
        /// </summary>
        /// <param name="sql">string：SQL语句</param>
        /// <param name="dicParam">Dictionary：SQL参数化</param>
        /// <returns>(object)MySqlDataReader</returns>
        public object ExecuteReader(string sql, Dictionary<string, object> dicParam = null)
        {
            MySqlDataReader reader = null;
            try
            {
                using (MySqlCommand command = MysqlConnection.CreateCommand())
                {
                    try
                    {
                        command.CommandText = sql;
                        if (dicParam != null && dicParam.Count > 0)
                        {
                            foreach (KeyValuePair<string, object> kvp in dicParam)
                            {
                                command.Parameters.AddWithValue(kvp.Key, kvp.Value);
                            }
                        }
                        reader = command.ExecuteReader();
                    }
                    catch (Exception ex)
                    {
                        reader = null;
                        throw new Exception("执行SQL语句查询时发生异常[ExecuteReader()]。\r\n" + ex.ToString());
                    }
                }
            }
            catch (Exception ex)
            {
                reader = null;
                throw new Exception("执行SQL语句查询时发生异常[ExecuteReader()]。\r\n" + ex.ToString());
            }
            return reader;
        }

        /// <summary> 执行查询，返回一个DataTable对象
        /// </summary>
        /// <param name="sql">string：SQL语句</param>
        /// <param name="dicParam">Dictionary：SQL参数化</param>
        /// <returns>DataTable</returns>
        public DataTable QueryData_DataTable(string sql, Dictionary<string, object> dicParam = null)
        {
            DataTable dt = new DataTable();
            try
            {
                using (MySqlDataAdapter da = new MySqlDataAdapter())
                {
                    using (MySqlCommand command = MysqlConnection.CreateCommand())
                    {
                        try
                        {
                            command.CommandText = sql;
                            if (dicParam != null && dicParam.Count > 0)
                            {
                                foreach (KeyValuePair<string, object> kvp in dicParam)
                                {
                                    command.Parameters.AddWithValue(kvp.Key, kvp.Value);
                                }
                            }
                            da.SelectCommand = command;
                            da.Fill(dt);
                        }
                        catch (Exception ex)
                        {
                            dt = null;
                            throw new Exception("执行SQL语句查询时发生异常[QueryData_DataTable()]。\r\n" + ex.ToString());
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                dt = null;
                throw new Exception("执行SQL语句查询时发生异常[QueryData_DataTable()]。\r\n" + ex.ToString());
            }
            return dt;
        }

        /// <summary> 执行查询，返回一个DataSet对象
        /// </summary>
        /// <param name="sql">string：SQL语句</param>
        /// <param name="dicParam">Dictionary：SQL参数化</param>
        /// <param name="srcTable">string：映射表名称</param>
        /// <returns>DataSet</returns>
        public DataSet QueryData_DataSet(string sql, Dictionary<string, object> dicParam = null, string srcTable = null)
        {
            DataSet ds = new DataSet();
            try
            {
                using (MySqlDataAdapter da = new MySqlDataAdapter())
                {
                    using (MySqlCommand command = MysqlConnection.CreateCommand())
                    {
                        try
                        {
                            command.CommandText = sql;
                            if (dicParam != null && dicParam.Count > 0)
                            {
                                foreach (KeyValuePair<string, object> kvp in dicParam)
                                {
                                    command.Parameters.AddWithValue(kvp.Key, kvp.Value);
                                }
                            }
                            da.SelectCommand = command;
                            if (string.IsNullOrWhiteSpace(srcTable))
                            {
                                da.Fill(ds);
                            }
                            else
                            {
                                da.Fill(ds, srcTable);
                            }
                        }
                        catch (Exception ex)
                        {
                            ds = null;
                            throw new Exception("执行SQL语句查询时发生异常[QueryData_DataSet()]。\r\n" + ex.ToString());
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                ds = null;
                throw new Exception("执行SQL语句查询时发生异常[QueryData_DataSet()]。\r\n" + ex.ToString());
            }
            return ds;
        }


        /// <summary> 新增数据通用方法（字段名数组与字段值数组必须一一对应）
        /// </summary>
        /// <param name="tableName">数据库表名称</param>
        /// <param name="fieldArray">数据库字段名数组</param>
        /// <param name="valueArray">数据库字段值数组</param>
        /// <returns></returns>
        public int InsertSqlExe(string tableName, string[] fieldArray, object[] valueArray)
        {
            int row = -1;

            if (string.IsNullOrWhiteSpace(tableName))
            {
                throw new Exception("表名 参数错误。");
            }

            if ((fieldArray == null) || (valueArray == null) || (fieldArray.Length < 1) || (valueArray.Length < 1) || (fieldArray.Length != valueArray.Length))
            {
                throw new Exception("字段/值 参数错误。");
            }

            StringBuilder sqlStr = new StringBuilder();
            Dictionary<string, object> dicParam = new Dictionary<string, object>();

            try
            {
                #region 动态产生SQL语句

                sqlStr.AppendLine("INSERT INTO " + tableName);
                sqlStr.AppendLine("(");
                for (int f = 0; f < fieldArray.Length; f++)
                {
                    if (f == fieldArray.Length - 1)
                    {
                        sqlStr.AppendLine(fieldArray[f]);
                    }
                    else
                    {
                        sqlStr.AppendLine(fieldArray[f] + ",");
                    }
                }
                sqlStr.AppendLine(")");
                sqlStr.AppendLine("VALUES");
                sqlStr.AppendLine("(");
                for (int f = 0; f < fieldArray.Length; f++)
                {
                    if (f == fieldArray.Length - 1)
                    {
                        sqlStr.AppendLine("?" + fieldArray[f]);
                    }
                    else
                    {
                        sqlStr.AppendLine("?" + fieldArray[f] + ",");
                    }
                }
                sqlStr.AppendLine(")");

                #endregion

                #region 动态参数赋值

                for (int v = 0; v < valueArray.Length; v++)
                {
                    dicParam.Add("?" + fieldArray[v], valueArray[v]);
                }

                #endregion

                #region 执行SQL

                row = ExecuteNonQuery(sqlStr.ToString(), dicParam);

                #endregion
            }
            catch (Exception ex)
            {
                throw new Exception("执行新增通用方法时发生异常[InsertSqlExe()]。\r\n" + ex.ToString());
            }

            return row;
        }

        /// <summary> 新增数据通用方法（字段名集合与字段值集合必须一一对应）
        /// </summary>
        /// <param name="tableName">数据库表名称</param>
        /// <param name="fieldList">数据库字段名集合</param>
        /// <param name="valueList">数据库字段值集合</param>
        /// <returns></returns>
        public int InsertSqlExe(string tableName, List<string> fieldList, List<object> valueList)
        {
            int row = -1;

            if (string.IsNullOrWhiteSpace(tableName))
            {
                throw new Exception("表名 参数错误。");
            }

            if ((fieldList == null) || (valueList == null) || (fieldList.Count < 1) || (valueList.Count < 1) || (fieldList.Count != valueList.Count))
            {
                throw new Exception("字段/值 参数错误。");
            }

            StringBuilder sqlStr = new StringBuilder();
            Dictionary<string, object> dicParam = new Dictionary<string, object>();

            try
            {
                #region 动态产生SQL语句

                sqlStr.AppendLine("INSERT INTO " + tableName);
                sqlStr.AppendLine("(");
                for (int f = 0; f < fieldList.Count; f++)
                {
                    if (f == fieldList.Count - 1)
                    {
                        sqlStr.AppendLine(fieldList[f]);
                    }
                    else
                    {
                        sqlStr.AppendLine(fieldList[f] + ",");
                    }
                }
                sqlStr.AppendLine(")");
                sqlStr.AppendLine("VALUES");
                sqlStr.AppendLine("(");
                for (int f = 0; f < fieldList.Count; f++)
                {
                    if (f == fieldList.Count - 1)
                    {
                        sqlStr.AppendLine("?" + fieldList[f]);
                    }
                    else
                    {
                        sqlStr.AppendLine("?" + fieldList[f] + ",");
                    }
                }
                sqlStr.AppendLine(")");

                #endregion

                #region 动态参数赋值

                for (int v = 0; v < valueList.Count; v++)
                {
                    dicParam.Add("?" + fieldList[v], valueList[v]);
                }

                #endregion

                #region 执行SQL

                row = ExecuteNonQuery(sqlStr.ToString(), dicParam);

                #endregion
            }
            catch (Exception ex)
            {
                throw new Exception("执行新增通用方法时发生异常[InsertSqlExe()]。\r\n" + ex.ToString());
            }

            return row;
        }


        /// <summary> 修改数据通用方法（修改字段名数组与修改字段值数组必须一一对应；须显式指定主键列/唯一列）
        /// </summary>
        /// <param name="tableName">数据库表名称</param>
        /// <param name="pkField">主键列/唯一列字段名</param>
        /// <param name="pkValue">主键列/唯一列字段值</param>
        /// <param name="fieldArray">修改字段名数组</param>
        /// <param name="valueArray">修改字段值数组</param>
        /// <param name="nullIsJoin">空值是否参与数据修改，默认true，false忽略空值进行数据修改</param>
        /// <returns></returns>
        public int UpdateSqlExe(string tableName, string pkField, object pkValue, string[] fieldArray, object[] valueArray, bool nullIsJoin = true)
        {
            int row = -1;

            if (string.IsNullOrWhiteSpace(tableName))
            {
                throw new Exception("表名 参数错误。");
            }

            if ((string.IsNullOrWhiteSpace(pkField)) || pkValue == null)
            {
                throw new Exception("主键列/唯一列 参数错误。");
            }

            if ((fieldArray == null) || (valueArray == null) || (fieldArray.Length < 1) || (valueArray.Length < 1) || (fieldArray.Length != valueArray.Length))
            {
                throw new Exception("字段/值 参数错误。");
            }

            StringBuilder sqlStr = new StringBuilder();
            Dictionary<string, object> dicParam = new Dictionary<string, object>();

            List<string> fieldList = null;
            List<object> valueList = null;

            try
            {
                #region 忽略空参数处理

                if (!nullIsJoin)
                {
                    fieldList = new List<string>();
                    valueList = new List<object>();

                    List<string> fieldListNew = new List<string>(fieldArray);
                    List<object> valueListNew = new List<object>(valueArray);

                    for (int i = 0; i < valueListNew.Count; i++)
                    {
                        if ((valueListNew[i] != null) && (!string.IsNullOrWhiteSpace(Convert.ToString(valueListNew[i]))))
                        {
                            fieldList.Add(fieldListNew[i]);
                            valueList.Add(valueListNew[i]);
                        }
                    }

                    if ((fieldList == null) || (valueList == null) || (fieldList.Count < 1) || (valueList.Count < 1) || (fieldList.Count != valueList.Count))
                    {
                        throw new Exception("字段/值 参数错误。");
                    }
                }
                else
                {
                    fieldList = new List<string>(fieldArray);
                    valueList = new List<object>(valueArray);
                }

                #endregion

                #region 动态产生SQL语句

                sqlStr.AppendLine("UPDATE " + tableName);
                sqlStr.AppendLine("SET");
                for (int f = 0; f < fieldList.Count; f++)
                {
                    if (f == fieldList.Count - 1)
                    {
                        sqlStr.AppendLine(fieldList[f] + " = ?" + fieldList[f]);
                    }
                    else
                    {
                        sqlStr.AppendLine(fieldList[f] + " = ?" + fieldList[f] + ",");
                    }
                }
                sqlStr.AppendLine("WHERE 1 = 1");
                sqlStr.AppendLine("AND " + pkField + " = ?" + pkField);

                #endregion

                #region 动态参数赋值

                for (int v = 0; v < valueArray.Length; v++)
                {
                    dicParam.Add("?" + fieldArray[v], valueArray[v]);
                }
                dicParam.Add("?" + pkField, pkValue);

                #endregion

                #region 执行SQL

                row = ExecuteNonQuery(sqlStr.ToString(), dicParam);

                #endregion
            }
            catch (Exception ex)
            {
                throw new Exception("执行修改通用方法时发生异常[UpdateSqlExe()]。\r\n" + ex.ToString());
            }

            return row;
        }

        /// <summary> 修改数据通用方法（修改字段名集合与修改字段值集合必须一一对应；须显式指定主键列/唯一列）
        /// </summary>
        /// <param name="tableName">数据库表名称</param>
        /// <param name="conditionFieldList">条件字段名集合</param>
        /// <param name="conditionValueList">条件字段值集合</param>
        /// <param name="fieldList">修改字段名集合</param>
        /// <param name="valueList">修改字段值集合</param>
        /// <param name="nullIsJoin">空值是否参与数据修改。默认 true，空值参与数据修改；false，忽略空值进行数据修改</param>
        /// <returns></returns>
        public int UpdateSqlExe(string tableName, string pkField, object pkValue, List<string> fieldList, List<object> valueList, bool nullIsJoin = true)
        {
            int row = -1;

            if (string.IsNullOrWhiteSpace(tableName))
            {
                throw new Exception("表名 参数错误。");
            }

            if ((string.IsNullOrWhiteSpace(pkField)) || pkValue == null)
            {
                throw new Exception("主键列/唯一列 参数错误。");
            }

            if ((fieldList == null) || (valueList == null) || (fieldList.Count < 1) || (valueList.Count < 1) || (fieldList.Count != valueList.Count))
            {
                throw new Exception("字段/值 参数错误。");
            }

            StringBuilder sqlStr = new StringBuilder();
            Dictionary<string, object> dicParam = new Dictionary<string, object>();

            try
            {
                #region 忽略空参数处理

                if (!nullIsJoin)
                {
                    List<string> fieldListNew = new List<string>();
                    List<object> valueListNew = new List<object>();

                    fieldListNew = fieldList;
                    valueListNew = valueList;

                    fieldList.Clear();
                    valueList.Clear();

                    for (int i = 0; i < valueListNew.Count; i++)
                    {
                        if ((valueListNew[i] != null) && (!string.IsNullOrWhiteSpace(Convert.ToString(valueListNew[i]))))
                        {
                            fieldList.Add(fieldListNew[i]);
                            valueList.Add(valueListNew[i]);
                        }
                    }

                    if ((fieldList == null) || (valueList == null) || (fieldList.Count < 1) || (valueList.Count < 1) || (fieldList.Count != valueList.Count))
                    {
                        throw new Exception("字段/值 参数错误。");
                    }
                }

                #endregion

                #region 动态产生SQL语句

                sqlStr.AppendLine("UPDATE " + tableName);
                sqlStr.AppendLine("SET");
                for (int f = 0; f < fieldList.Count; f++)
                {
                    if (f == fieldList.Count - 1)
                    {
                        sqlStr.AppendLine(fieldList[f] + " = ?" + fieldList[f]);
                    }
                    else
                    {
                        sqlStr.AppendLine(fieldList[f] + " = ?" + fieldList[f] + ",");
                    }
                }
                sqlStr.AppendLine("WHERE 1 = 1");
                sqlStr.AppendLine("AND " + pkField + " = ?" + pkField);

                #endregion

                #region 动态参数赋值

                for (int v = 0; v < valueList.Count; v++)
                {
                    dicParam.Add("?" + fieldList[v], valueList[v]);
                }
                dicParam.Add("?" + pkField, pkValue);

                #endregion

                #region 执行SQL

                row = ExecuteNonQuery(sqlStr.ToString(), dicParam);

                #endregion
            }
            catch (Exception ex)
            {
                throw new Exception("执行修改通用方法时发生异常[UpdateSqlExe()]。\r\n" + ex.ToString());
            }

            return row;
        }

        /// <summary> 修改数据通用方法（条件字段名数组与条件字段值数组必须一一对应；修改字段名数组与修改字段值数组必须一一对应）
        /// <para>注：条件字段与条件值目前只支持“=”等号运算符（其他暂不考虑，自行写SQL语句）</para>
        /// </summary>
        /// <param name="tableName">数据库表名称</param>
        /// <param name="conditionField">条件字段名数组</param>
        /// <param name="conditionValue">条件字段值数组</param>
        /// <param name="fieldArray">修改字段名数组</param>
        /// <param name="valueArray">修改字段值数组</param>
        /// <param name="nullIsJoin">空值是否参与数据修改，默认true，false忽略空值进行数据修改</param>
        /// <returns></returns>
        public int UpdateSqlExe(string tableName, string[] conditionField, object[] conditionValue, string[] fieldArray, object[] valueArray, bool nullIsJoin = true)
        {
            int row = -1;

            if (string.IsNullOrWhiteSpace(tableName))
            {
                throw new Exception("表名 参数错误。");
            }

            if ((conditionField == null) || (conditionValue == null) || (conditionField.Length < 1) || (conditionValue.Length < 1) || (conditionField.Length != conditionValue.Length))
            {
                throw new Exception("条件 的 字段/值 参数错误。");
            }

            if ((fieldArray == null) || (valueArray == null) || (fieldArray.Length < 1) || (valueArray.Length < 1) || (fieldArray.Length != valueArray.Length))
            {
                throw new Exception("字段/值 参数错误。");
            }

            StringBuilder sqlStr = new StringBuilder();
            Dictionary<string, object> dicParam = new Dictionary<string, object>();

            List<string> fieldList = null;
            List<object> valueList = null;

            try
            {
                #region 忽略空参数处理

                if (!nullIsJoin)
                {
                    fieldList = new List<string>();
                    valueList = new List<object>();

                    List<string> fieldListNew = new List<string>(fieldArray);
                    List<object> valueListNew = new List<object>(valueArray);

                    for (int i = 0; i < valueListNew.Count; i++)
                    {
                        if ((valueListNew[i] != null) && (!string.IsNullOrWhiteSpace(Convert.ToString(valueListNew[i]))))
                        {
                            fieldList.Add(fieldListNew[i]);
                            valueList.Add(valueListNew[i]);
                        }
                    }

                    if ((fieldList == null) || (valueList == null) || (fieldList.Count < 1) || (valueList.Count < 1) || (fieldList.Count != valueList.Count))
                    {
                        throw new Exception("字段/值 参数错误。");
                    }
                }
                else
                {
                    fieldList = new List<string>(fieldArray);
                    valueList = new List<object>(valueArray);
                }

                #endregion

                #region 动态产生SQL语句

                sqlStr.AppendLine("UPDATE " + tableName);
                sqlStr.AppendLine("SET");
                for (int f = 0; f < fieldList.Count; f++)
                {
                    if (f == fieldList.Count - 1)
                    {
                        sqlStr.AppendLine(fieldList[f] + " = ?" + fieldList[f]);
                    }
                    else
                    {
                        sqlStr.AppendLine(fieldList[f] + " = ?" + fieldList[f] + ",");
                    }
                }
                sqlStr.AppendLine("WHERE 1 = 1");
                for (int c = 0; c < conditionField.Length; c++)
                {
                    sqlStr.AppendLine("AND " + conditionField[c] + " = ?" + conditionField[c]);
                }

                #endregion

                #region 动态参数赋值

                for (int v = 0; v < valueList.Count; v++)
                {
                    dicParam.Add("?" + fieldList[v], valueList[v]);
                }
                for (int cv = 0; cv < conditionValue.Length; cv++)
                {
                    dicParam.Add("?" + conditionField[cv], conditionValue[cv]);
                }

                #endregion

                #region 执行SQL

                row = ExecuteNonQuery(sqlStr.ToString(), dicParam);

                #endregion
            }
            catch (Exception ex)
            {
                throw new Exception("执行修改通用方法时发生异常[UpdateSqlExe()]。\r\n" + ex.ToString());
            }

            return row;
        }

        /// <summary> 修改数据通用方法（条件字段名集合与条件字段值集合必须一一对应，修改字段名集合与修改字段值集合必须一一对应）
        /// <para>注：条件字段与条件值目前只支持“=”等号运算符（其他暂不考虑，自行写SQL语句）</para>
        /// </summary>
        /// <param name="tableName">数据库表名称</param>
        /// <param name="conditionFieldList">条件字段名集合</param>
        /// <param name="conditionValueList">条件字段值集合</param>
        /// <param name="fieldList">修改字段名集合</param>
        /// <param name="valueList">修改字段值集合</param>
        /// <param name="nullIsJoin">空值是否参与数据修改。默认 true，空值参与数据修改；false，忽略空值进行数据修改</param>
        /// <returns></returns>
        public int UpdateSqlExe(string tableName, List<string> conditionFieldList, List<object> conditionValueList, List<string> fieldList, List<object> valueList, bool nullIsJoin = true)
        {
            int row = -1;

            if (string.IsNullOrWhiteSpace(tableName))
            {
                throw new Exception("表名 参数错误。");
            }

            if ((conditionFieldList == null) || (conditionValueList == null) || (conditionFieldList.Count < 1) || (conditionValueList.Count < 1) || (conditionFieldList.Count != conditionValueList.Count))
            {
                throw new Exception("条件 字段/值 参数错误。");
            }

            if ((fieldList == null) || (valueList == null) || (fieldList.Count < 1) || (valueList.Count < 1) || (fieldList.Count != valueList.Count))
            {
                throw new Exception("字段/值 参数错误。");
            }

            StringBuilder sqlStr = new StringBuilder();
            Dictionary<string, object> dicParam = new Dictionary<string, object>();

            try
            {
                #region 忽略空参数处理

                if (!nullIsJoin)
                {
                    List<string> fieldListNew = new List<string>();
                    List<object> valueListNew = new List<object>();

                    fieldListNew = fieldList;
                    valueListNew = valueList;

                    fieldList.Clear();
                    valueList.Clear();

                    for (int i = 0; i < valueListNew.Count; i++)
                    {
                        if ((valueListNew[i] != null) && (!string.IsNullOrWhiteSpace(Convert.ToString(valueListNew[i]))))
                        {
                            fieldList.Add(fieldListNew[i]);
                            valueList.Add(valueListNew[i]);
                        }
                    }

                    if ((fieldList == null) || (valueList == null) || (fieldList.Count < 1) || (valueList.Count < 1) || (fieldList.Count != valueList.Count))
                    {
                        throw new Exception("字段/值 参数错误。");
                    }
                }

                #endregion

                #region 动态产生SQL语句

                sqlStr.AppendLine("UPDATE " + tableName);
                sqlStr.AppendLine("SET");
                for (int f = 0; f < fieldList.Count; f++)
                {
                    if (f == fieldList.Count - 1)
                    {
                        sqlStr.AppendLine(fieldList[f] + " = ?" + fieldList[f]);
                    }
                    else
                    {
                        sqlStr.AppendLine(fieldList[f] + " = ?" + fieldList[f] + ",");
                    }
                }
                sqlStr.AppendLine("WHERE 1 = 1");
                for (int c = 0; c < conditionFieldList.Count; c++)
                {
                    sqlStr.AppendLine("AND " + conditionFieldList[c] + " = ?" + conditionFieldList[c]);
                }

                #endregion

                #region 动态参数赋值

                for (int v = 0; v < valueList.Count; v++)
                {
                    dicParam.Add("?" + fieldList[v], valueList[v]);
                }
                for (int cv = 0; cv < conditionValueList.Count; cv++)
                {
                    dicParam.Add("?" + conditionFieldList[cv], conditionValueList[cv]);
                }

                #endregion

                #region 执行SQL

                row = ExecuteNonQuery(sqlStr.ToString(), dicParam);

                #endregion
            }
            catch (Exception ex)
            {
                throw new Exception("执行修改通用方法时发生异常[UpdateSqlExe()]。\r\n" + ex.ToString());
            }

            return row;
        }


        /// <summary> 删除数据通用方法（须显式指定主键列/唯一列）
        /// </summary>
        /// <param name="tableName">数据库表名称</param>
        /// <param name="pkField">主键列字段名</param>
        /// <param name="pkValue">主键列字段值</param>
        /// <returns></returns>
        public int DeleteSqlExe(string tableName, string pkField, object pkValue)
        {
            int row = -1;

            if (string.IsNullOrWhiteSpace(tableName))
            {
                throw new Exception("表名 参数错误。");
            }

            if ((string.IsNullOrWhiteSpace(pkField)) || pkValue == null)
            {
                throw new Exception("主键列 参数错误。");
            }

            StringBuilder sqlStr = new StringBuilder();
            Dictionary<string, object> dicParam = new Dictionary<string, object>();

            try
            {
                #region 动态产生SQL语句

                sqlStr.AppendLine("DELETE FROM " + tableName);
                sqlStr.AppendLine("WHERE " + pkField + " = ?" + pkField);

                #endregion

                #region 动态参数赋值

                dicParam.Add("?" + pkField, pkValue);

                #endregion

                #region 执行SQL

                row = ExecuteNonQuery(sqlStr.ToString(), dicParam);

                #endregion
            }
            catch (Exception ex)
            {
                throw new Exception("执行删除通用方法时发生异常[DeleteSqlExe()]。\r\n" + ex.ToString());
            }

            return row;
        }

        /// <summary> 删除数据通用方法（条件字段名数组与条件字段值数组必须一一对应）
        /// </summary>
        /// <param name="tableName">数据库表名称</param>
        /// <param name="conditionFieldList">条件字段名数组</param>
        /// <param name="conditionValueList">条件字段值数组</param>
        /// <returns></returns>
        public int DeleteSqlExe(string tableName, string[] conditionField, object[] conditionValue)
        {
            int row = -1;

            if (string.IsNullOrWhiteSpace(tableName))
            {
                throw new Exception("表名 参数错误。");
            }

            if ((conditionField == null) || (conditionValue == null) || (conditionField.Length < 1) || (conditionValue.Length < 1) || (conditionField.Length != conditionValue.Length))
            {
                throw new Exception("条件 字段/值 参数错误。");
            }

            StringBuilder sqlStr = new StringBuilder();
            Dictionary<string, object> dicParam = new Dictionary<string, object>();

            try
            {
                #region 动态产生SQL语句

                sqlStr.AppendLine("DELETE FROM " + tableName);
                sqlStr.AppendLine("WHERE 1 = 1");
                for (int cf = 0; cf < conditionField.Length; cf++)
                {
                    sqlStr.AppendLine("AND " + conditionField[cf] + " = ?" + conditionField[cf]);
                }

                #endregion

                #region 动态参数赋值

                for (int vf = 0; vf < conditionValue.Length; vf++)
                {
                    dicParam.Add("?" + conditionValue[vf], conditionValue[vf]);
                }

                #endregion

                #region 执行SQL

                row = ExecuteNonQuery(sqlStr.ToString(), dicParam);

                #endregion
            }
            catch (Exception ex)
            {
                throw new Exception("执行删除通用方法时发生异常[DeleteSqlExe()]。\r\n" + ex.ToString());
            }

            return row;
        }

        /// <summary> 删除数据通用方法（条件字段名集合与条件字段值集合必须一一对应）
        /// </summary>
        /// <param name="tableName">数据库表名称</param>
        /// <param name="conditionFieldList">条件字段名集合</param>
        /// <param name="conditionValueList">条件字段值集合</param>
        /// <returns></returns>
        public int DeleteSqlExe(string tableName, List<string> conditionFieldList, List<object> conditionValueList)
        {
            int row = -1;

            if (string.IsNullOrWhiteSpace(tableName))
            {
                throw new Exception("表名 参数错误。");
            }

            if ((conditionFieldList == null) || (conditionValueList == null) || (conditionFieldList.Count < 1) || (conditionValueList.Count < 1) || (conditionFieldList.Count != conditionValueList.Count))
            {
                throw new Exception("条件 字段/值 参数错误。");
            }

            StringBuilder sqlStr = new StringBuilder();
            Dictionary<string, object> dicParam = new Dictionary<string, object>();

            try
            {
                #region 动态产生SQL语句

                sqlStr.AppendLine("DELETE FROM " + tableName);
                sqlStr.AppendLine("WHERE 1 = 1");
                for (int cf = 0; cf < conditionFieldList.Count; cf++)
                {
                    sqlStr.AppendLine("AND " + conditionFieldList[cf] + " = ?" + conditionFieldList[cf]);
                }

                #endregion

                #region 动态参数赋值

                for (int vf = 0; vf < conditionValueList.Count; vf++)
                {
                    dicParam.Add("?" + conditionFieldList[vf], conditionValueList[vf]);
                }

                #endregion

                #region 执行SQL

                row = ExecuteNonQuery(sqlStr.ToString(), dicParam);

                #endregion
            }
            catch (Exception ex)
            {
                throw new Exception("执行删除通用方法时发生异常[DeleteSqlExe()]。\r\n" + ex.ToString());
            }

            return row;
        }


    }

 接下来我们配置启动时代码 Global.asax ：

public class WebApiApplication : HttpApplication
    {
        protected void Application_Start()
        {
            GlobalConfiguration.Configure(WebApiConfig.Register);


            //启动时读取数据库连接信息配置文件（MySqlConnectionConfig.xml）
            try
            {
                MySqlDBConnectInfo dbConnectInfo = StartupInitMySqlConfig.DbConnectInfo;
                if (dbConnectInfo == null)
                {
                    throw new Exception("系统获取不到数据库连接信息。");
                }
            }
            catch (Exception ex)
            {
                LogTool.WriteErrorLog("【启动异常】从配置文件中获取 MySql 连接信息，发生异常", ex.ToString());
            }
        }
    }

MySqlConnectionConfig.xml 配置文件：

<?xml version="1.0" encoding="utf-8"?>
<ArrayOfMySqlDBConnectInfo xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <!-- 一般把程序默认的连接对象放在第一位 -->
  <MySqlDBConnectInfo>
    <!-- #唯一别名（用来区分是哪个链接，推荐策略：服务地址_数据库名） -->
    <UniqueAlias>185.**.36.12-DBName</UniqueAlias>
    <!-- ############################################################################################################ -->
    <!-- #数据库服务连接地址，例："127.0.0.1" -->
    <Server>185.**.36.12</Server>
    <!-- #数据库服务连接端口号 -->
    <Port>3306</Port>
    <!-- #连接的数据库 -->
    <Database>DBName</Database>
    <!-- #连接数据库的用户名 -->
    <UserID>UserName</UserID>
    <!-- #用户密码 -->
    <Password>UserPwd</Password>
    <!-- ############################################################################################################ -->
    <!-- #设置字符编码，例："utf8" -->
    <CharacterSet>utf8</CharacterSet>
    <!-- #连接超时时间，单位秒 -->
    <ConnectionTimeout>60</ConnectionTimeout>
    <!-- #数据库执行超时时间，单位秒 -->
    <DefaultCommandTimeout>60</DefaultCommandTimeout>
    <!-- #是否开启连接池，true -->
    <Pooling>true</Pooling>
    <!-- #连接池中最小连接数 -->
    <MinimumPoolSize>20</MinimumPoolSize>
    <!-- #连接池中最大连接数 -->
    <MaximumPoolSize>50</MaximumPoolSize>
    <!-- #连接池中连接对象存活时间，单位秒 -->
    <ConnectionLifeTime>1200</ConnectionLifeTime>
    <!-- #连接是否使用压缩，true -->
    <UseCompression>true</UseCompression>
    <!-- #表示连接池程序是否会自动登记创建线程的当前事务语境中的连接，ture -->
    <AutoEnlist>true</AutoEnlist>
  </MySqlDBConnectInfo>
</ArrayOfMySqlDBConnectInfo>

上面代码中用到的 JsonTool 和 XmlTool 都在我之前的博文中。

下面给一个 MySqlTool 的使用例子：

希望给你带来参考和帮助。

人称少侠
关注
专栏目录
c# ado.net mysql_c#利用ado.net进行数据库开发的基本步骤
weixin_28998775的博客
01-31 448
c#利用ado.net进行数据库开发的基本步骤：1。创建和数据库连接的connection 对象。2。配置DataAdapter对象并创建和操作数据集DataSet。3。将数据库中的表添加到DataSet中。4。把数据集DataSet帮定到DataGrid上。利用DataAdapter 的Fill方法把数据填充到DataSet，最终的数据库中的数据显示在用户界面的DataGrid中。c#中浮点数无...
C#使用ADO.NET访问数据库
weixin_42828074的博客
07-16 8350
文章目录C#使用ADO.NET访问数据库1.常用的数据库访问技术2.认识ADO.NET技术1.ADO.NET的命名空间及导入2.ADO.NET的工作原理及访问架构1.各种数据库/数据源2..NET数据提供程序3.数据集DataSet3.客户端应用程序基于ADO.NET的两种数据访问模式1.通过DataSet访问数据（数据集断开式数据访问模式）2.通过DataReader对象访问数据（连接式数据访问模式）3.ADO.NET访问sql的步骤1.使用连接对象SqlConnection连接数据源2.打开连接3.操作
C# 连接Mysql 有关于ADo.net的操作
08-01
C# 连接Mysql 有关于ADo.net的操作 截图在文档中
mysql增删改查_C# ADO.NET 实现对MySql数据库的增删改查
weixin_39883440的博客
11-16 391
1、创建数据库和表创建数据库：CREATE DATABASE `AuthorizationData`创建表：CREATE TABLE `AuthorizationData`.`InstrumentNewTable` ( `ID` int(10) unsigned NOT NULL AUTO_INCREMENT, `Name` varchar(100) DEFAULT '""', `MachineI...
C#进阶-了解ORM框架SqlSugar并巧妙使用（附相关数据库工具）
最新发布
rwo_bear的博客
08-05 4973
通过NuGet包管理器搜索SqlSugar、MySql.Data、Newtonsoft.Json三个包并安装。
c# ado.net mysql_C#工具:Ado.Net SqlServer数据库 MySql数据库
weixin_27676369的博客
01-27 129
usingSystem;usingSystem.Collections;usingSystem.Collections.Specialized;usingSystem.Data;usingMySql.Data.MySqlClient;usingSystem.Configuration;usingSystem.Data.Common;usingSystem.Collections.Generic;n...
张赐荣: C#ADO.NET 操作Mysql 详细教程
张赐荣的技术博客
12-21 4143
在本教程中，我们介绍了使用ADO.NET连接到MySQL数据库的基本方法。讲解了ADO.NET的各个组件，并提供了代码示例，详细讲解了如何使用这些组件来连接、查询、更新操作数据库。 还介绍了使用事务保证数据库操作的原子性的方法，并演示了如何使用数据读取器读取数据库中的数据。 还介绍了使用异步数据操作来提升应用程序性能的方法，并提供了使用数据集构造器创建数据集的代码示例。
c#利用ado.net进行数据库开发
11-18
根据提供的文件信息，以下是对C#利用ADO.NET进行数据库开发的相关知识点的详细解析： ### C#与ADO.NET #### 1. Connection（连接） 在ADO.NET中，`Connection`对象用于建立应用程序与数据库之间的连接。在C#中，...
C# ADO.NET数据库作及常用类概述
weixin_47257626的博客
02-24 1743
C# ADO.NET数据库作及常用类概述 在 C# 语言中 ADO.NET 是在 ADO 的基础上发展起来的，ADO (Active Data Object) 是一个 COM 组件类库，用于访问数据库，而 ADO.NET 是在 .NET 平台上访问数据库的组件。 ADO.NET 是以 ODBC (Open Database Connectivity) 技术的方式来访问数据库的一种技术。 ADO.NET 中的常用命名空间如下表所示。 在使用 ADO.NET 进行数据库操作时通常会用到 5 个类，分别是 Co
ADO.NET C# 连接MySQL数据库的类库 非常好用的哦！
09-22
以上就是使用ADO.NET和MySQLDriverCS驱动在C#中连接MySQL数据库的基本操作。请确保正确引用了MySQLDriverCS的DLL，并根据实际情况调整连接字符串和其他配置。同时，记得遵循最佳实践，如使用using语句来自动管理...
ado 操作mysql例子_一个简单的ADO.NET C# 数据库操作实例
weixin_39887961的博客
01-26 209
以 ADO.NET 访问SQL SERVER 数据库为例，连接其他数据库时，可能语法上稍微有一点点差别，步骤与SQL SERVER 相同。ADO.NET 访问数据库步骤建立数据库连接创建SQL 命令执行SQL命令处理SQL命令结果创建数据库连接在ADO.NET 中，通过创建Connection对象连接到特定的数据库。创建Connection对象时，必须提供相应的连接字符串。string connS...
C#ADO.Net连接数据库
08-01
C#ADO.Net连接数据库
C#和数据库连接中 ADO.NET的使用
03-23
主要关于SQLserver数据库与C#的连接，显示，控制等功能
使用ADO.net连接msql数据库
qq_25956141的博客
01-03 202
使用ADO.NET连接mysql，思路上和操作上和java连接mysql差不多，其实就是换了一批名字 static void Main(string[] args) { string ip = "127.0.0.1"; string username = "root"; string passwo
ADO.Net连接Mysql
weixin_30721077的博客
07-24 359
首先下载一个mysql.data.dll拷贝到bin下面并引用一下 using MySql.Data.MySqlClient; class Program { static void Main(string[] args) { string connStr = ConfigurationManager.Connect...
ado mysql 读写_C#使用Ado.Net读写数据库
weixin_36278982的博客
01-26 189
1.使用DataReader方式读取资料[csharp]viewplaincopyStringconnString=ConfigurationManager.ConnectionStrings["astt"].ConnectionString;//如果数据库连接字符串有加密,可以经过解密后重新获得连接字符串DbConnectionStringBuilderconnBuilder=newDbConn...
ADO.NET操作MySQL数据库
热门推荐
至尊宝
12-12 3万+
强烈推荐一个大神的人工智能的教程：http://www.captainbed.net/zhanghan 前言 ADO.NET包括5大对象，分别是Connection、Command、DataReader、DataSet、DataAdapter，使用ADO.NET访问数据库有两个步骤：建立数据库连接、读取或更新数据。读取数据主要有两种方法：Command与DataReader、Da...
.net 连mysql代码_C#使用ADO.NET连接数据库简单代码实例
weixin_33787865的博客
02-22 142
public static void ConnDb(){string strConn = "Data Source=localhost;DataBase=mytest;User ID=sa;Password=sa";string strSql = "select * from stu";//create conntion objectSqlConnection dbConn = new SqlCo...
ado.net mysql类_C#ADO.NET帮助类
weixin_35781693的博客
01-26 127
using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Data;using System.Data.SqlClient;namespace DBComm{ static class DBCommand { public class DBParameters { p...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值