C#写一套最全的MySQL帮助类（包括增删改查）

钟小瑜

介绍说明：
这个帮助类包含了六个主要的方法：
ExecuteNonQuery、ExecuteScalar、ExecuteQuery、ExecuteQuery（泛型）、Insert、Update和Delete。
其中，ExecuteNonQuery用于执行不返回结果集的SQL语句；
ExecuteScalar用于执行一个查询，并返回结果集中第一行的第一列；
ExecuteQuery用于执行一个查询，并返回结果集；
ExecuteQuery（泛型）用于执行一个查询，并将结果集映射到一个对象列表；
Insert用于向数据库中插入数据；
Update用于更新数据库中的数据；
Delete用于删除数据库中的数据。
一、以下是一个基于C#的MySQL帮助类的示例代码，可以用于连接数据库、执行SQL语句、读取数据等操作：

1. using System;
2. using System.Collections.Generic;
3. using System.Data;
4. using MySql.Data.MySqlClient;
6. public class MySQLHelper
7. {
8.     private string connectionString;
10.     public MySQLHelper(string connectionString)
11.     {
12.         this.connectionString = connectionString;
13.     }
15.     // 执行不返回结果集的SQL语句
16.     public int ExecuteNonQuery(string sql, params MySqlParameter[] parameters)
17.     {
18.         using (MySqlConnection connection = new MySqlConnection(connectionString))
19.         {
20.             using (MySqlCommand command = new MySqlCommand(sql, connection))
21.             {
22.                 // 添加参数
23.                 command.Parameters.AddRange(parameters);
24.                 // 打开连接
25.                 connection.Open();
26.                 // 执行SQL语句并返回影响行数
27.                 return command.ExecuteNonQuery();
28.             }
29.         }
30.     }
32.     // 执行一个查询，并返回结果集中第一行的第一列
33.     public object ExecuteScalar(string sql, params MySqlParameter[] parameters)
34.     {
35.         using (MySqlConnection connection = new MySqlConnection(connectionString))
36.         {
37.             using (MySqlCommand command = new MySqlCommand(sql, connection))
38.             {
39.                 // 添加参数
40.                 command.Parameters.AddRange(parameters);
41.                 // 打开连接
42.                 connection.Open();
43.                 // 执行SQL查询并返回第一行第一列的值
44.                 return command.ExecuteScalar();
45.             }
46.         }
47.     }
49.     // 执行一个查询，并返回结果集
50.     public DataTable ExecuteQuery(string sql, params MySqlParameter[] parameters)
51.     {
52.         using (MySqlConnection connection = new MySqlConnection(connectionString))
53.         {
54.             using (MySqlCommand command = new MySqlCommand(sql, connection))
55.             {
56.                 // 添加参数
57.                 command.Parameters.AddRange(parameters);
58.                 // 打开连接
59.                 connection.Open();
60.                 // 创建DataAdapter和DataTable对象，并填充数据
61.                 using (MySqlDataAdapter adapter = new MySqlDataAdapter(command))
62.                 {
63.                     DataTable dataTable = new DataTable();
64.                     adapter.Fill(dataTable);
65.                     return dataTable;
66.                 }
67.             }
68.         }
69.     }
71.     // 执行一个查询，并将结果集映射到一个对象列表
72.     public List<T> ExecuteQuery<T>(string sql, Func<IDataRecord, T> selector, params MySqlParameter[] parameters)
73.     {
74.         using (MySqlConnection connection = new MySqlConnection(connectionString))
75.         {
76.             using (MySqlCommand command = new MySqlCommand(sql, connection))
77.             {
78.                 // 添加参数
79.                 command.Parameters.AddRange(parameters);
80.                 // 打开连接
81.                 connection.Open();
82.                 // 创建DataReader对象并读取数据，将每行数据映射到对象并添加到列表中
83.                 using (MySqlDataReader reader = command.ExecuteReader())
84.                 {
85.                     List<T> list = new List<T>();
86.                     while (reader.Read())
87.                     {
88.                         list.Add(selector(reader));
89.                     }
90.                     return list;
91.                 }
92.             }
93.         }
94.     }
96.     // 向数据库中插入数据
97.     public int Insert(string tableName, Dictionary<string, object> data)
98.     {
99.         string[] columns = new string[data.Count];
100.         object[] values = new object[data.Count];
102.         int i = 0;
103.         foreach (KeyValuePair<string, object> item in data)
104.         {
105.             // 获取列名和值
106.             columns[i] = item.Key;
107.             values[i] = item.Value;
108.             i++;
109.         }
111.         string sql = string.Format("INSERT INTO {0} ({1}) VALUES ({2})", tableName, string.Join(",", columns), "@" + string.Join(",@", columns));
113.         // 将Dictionary转换为MySqlParameter数组，并执行SQL语句
114.         return ExecuteNonQuery(sql, ToMySqlParameters(data));
115.     }
117.     // 更新数据库中的数据
118.     public int Update(string tableName, Dictionary<string, object> data, string whereClause = "")
119.     {
120.         string[] setValues = new string[data.Count];
121.         int i = 0;
122.         foreach (KeyValuePair<string, object> item in data)
123.         {
124.             // 获取列名和值
125.             setValues[i] = string.Format("{0}=@{0}", item.Key);
126.             i++;
127.         }
129.         string sql = string.Format("UPDATE {0} SET {1}", tableName, string.Join(",", setValues));
131.         if (!string.IsNullOrEmpty(whereClause))
132.         {
133.             sql += " WHERE " + whereClause;
134.         }
136.         // 将Dictionary转换为MySqlParameter数组，并执行SQL语句
137.         return ExecuteNonQuery(sql, ToMySqlParameters(data));
138.     }
140.     // 删除数据库中的数据
141.     public int Delete(string tableName, string whereClause = "")
142.     {
143.         string sql = string.Format("DELETE FROM {0}", tableName);
145.         if (!string.IsNullOrEmpty(whereClause))
146.         {
147.             sql += " WHERE " + whereClause;
148.         }
150.         // 执行SQL语句并返回影响
152.         return ExecuteNonQuery(sql);
153.     }
154.     // 将Dictionary转换为MySqlParameter数组
155.     private MySqlParameter[] ToMySqlParameters(Dictionary<string, object> data)
156.     {
157.         List<MySqlParameter> parameters = new List<MySqlParameter>();
159.         foreach (KeyValuePair<string, object> item in data)
160.         {
161.             parameters.Add(new MySqlParameter("@" + item.Key, item.Value));
162.         }
164.         return parameters.ToArray();
165.     }
166. }

复制代码

View Code二、另外，在使用这个帮助类时，需要先创建一个连接字符串，例如

1. string connectionString = "server=localhost;database=myDatabase;uid=myUsername;password=myPassword;";
2. MySQLHelper mySQLHelper = new MySQLHelper(connectionString);

复制代码

View Code三、然后就可以使用这个帮助类来访问MySQL数据库了。下面是一些示例代码：

1. // 查询所有数据
2. DataTable dataTable = mySQLHelper.ExecuteQuery("SELECT * FROM myTable");
3. foreach (DataRow row in dataTable.Rows)
4. {
5.     Console.WriteLine(row["column1"].ToString());
6. }
9. // 查询单个值
10. object value = mySQLHelper.ExecuteScalar("SELECT COUNT(*) FROM myTable");
11. Console.WriteLine(value.ToString());
14. // 查询并映射到对象列表
15. List<MyClass> list = mySQLHelper.ExecuteQuery("SELECT * FROM myTable", r => new MyClass
16. {
17.     Column1 = r["column1"].ToString(),
18.     Column2 = int.Parse(r["column2"].ToString())
19. });
22. // 插入数据
23. Dictionary<string, object> data = new Dictionary<string, object>();
24. data.Add("column1", "value1");
25. data.Add("column2", 123);
26. int result = mySQLHelper.Insert("myTable", data);
29. // 更新数据
30. Dictionary<string, object> data = new Dictionary<string, object>();
31. data.Add("column1", "value2");
32. data.Add("column2", 456);
33. int result = mySQLHelper.Update("myTable", data, "id=1");
36. // 删除数据
37. int result = mySQLHelper.Delete("myTable", "id=1");

复制代码

View Code               注：这些示例代码展示了如何使用这个帮助类来执行常见的MySQL操作，例如查询、插入、更新和删除数据。请注意，在执行SQL语句时，要避免SQL注入攻击，可以使用参数化查询来确保安全。
四、就上述SQL注入攻击，防范例子：

1. //是的，使用参数化查询是避免SQL注入攻击的重要方法之一。C#中可以使用MySqlParameter类来创建参数化查询，下面简单介绍一下如何使用MySqlParameter类。
2. //首先，看一个普通的SQL语句：
3.       string sql = "SELECT * FROM Users WHERE name='" + userName + "' AND password='" + password + "'";
4. //这个SQL语句接收两个字符串类型的参数：userName和password。但是，如果恶意用户在输入用户名或密码时添加了SQL代码，则可能会导致SQL注入攻击。例如，如果用户输入了以下内容作为密码：
5.       a' OR 'a'='a
6. //则生成的SQL语句将变成：
7.       SELECT* FROM Users WHERE name='xxx' AND password = 'a' OR 'a'='a'
8. //这个SQL语句将始终返回true，因为'a'='a'是永远成立的，所以用户可以绕过登录验证并访问数据库。
10. //为了避免这种情况发生，我们可以使用MySqlParameter类来创建参数化查询。以下是一个示例：
11.       string sql = "SELECT * FROM Users WHERE name=@UserName AND password=@Password";
12.       using (MySqlConnection connection = new MySqlConnection(connectionString))
13.       {
14.           using (MySqlCommand command = new MySqlCommand(sql, connection))
15.           {
16.               // 创建参数
17.               command.Parameters.Add(new MySqlParameter("@UserName", userName));
18.               command.Parameters.Add(new MySqlParameter("@Password", password));
19.               
20.               // 打开连接并执行查询
21.               connection.Open();
22.               using (MySqlDataReader reader = command.ExecuteReader())
23.               {
24.                   // 处理结果集
25.               }
26.           }
27.       }
28. //在这个示例中，我们使用了 @符号来标记参数名称，并使用MySqlParameter类为每个参数创建实例。这样，即使用户在输入用户名或密码时添加了SQL代码，它也不会影响生成的SQL语句。
29. //总之，使用参数化查询是一个非常重要的安全措施，可以有效预防SQL注入攻击，C#提供了方便易用的MySqlParameter类来支持参数化查询。

复制代码

View Code 

来源:https://www.cnblogs.com/wxsdyz/archive/2023/04/21/17339519.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！