1、C# SqlHelper
1 public static class SqlHelper
2 {
3 private static readonly string conStr = ConfigurationManager.ConnectionStrings["connStr"].ConnectionString;
4
5 ///
6 /// 执行增删改的
7 ///
8 ///
9 ///
10 ///
11 ///
12 public static int ExecuteNonQuery(string sql, CommandType cmdType = CommandType.Text, params SqlParameter[] pms)
13 {
14 using (SqlConnection con = new SqlConnection(conStr))
15 {
16 using (SqlCommand cmd = new SqlCommand(sql, con))
17 {
18 cmd.CommandType = cmdType;
19 if (pms != null)
20 {
21 cmd.Parameters.AddRange(pms);
22 }
23 con.Open();
24 return cmd.ExecuteNonQuery();
25 }
26 }
27 }
28
29 ///
30 /// 封装一个执行返回单个值的方法
31 ///
32 ///
33 ///
34 ///
35 ///
36 public static object ExecuteScalar(string sql, CommandType cmdType = CommandType.Text, params SqlParameter[] pms)
37 {
38 using (SqlConnection con = new SqlConnection(conStr))
39 {
40 using (SqlCommand cmd = new SqlCommand(sql, con))
41 {
42 cmd.CommandType = cmdType;
43 if (pms != null)
44 {
45 cmd.Parameters.AddRange(pms);
46 }
47 con.Open();
48 return cmd.ExecuteScalar();
49 }
50 }
51 }
52
53 ///
54 /// 返回SqlDataReader对象的方法
55 ///
56 ///
57 ///
58 ///
59 ///
60 public static SqlDataReader ExecuteReader(string sql, CommandType cmdType = CommandType.Text, params SqlParameter[] pms)
61 {
62 SqlConnection con = new SqlConnection(conStr);
63 using (SqlCommand cmd = new SqlCommand(sql, con))
64 {
65 cmd.CommandType = cmdType;
66 if (pms != null)
67 {
68 cmd.Parameters.AddRange(pms);
69 }
70 try
71 {
72 con.Open();
73 //这里第二个参数代表在函数外部，如果掉了close()方法，则con会随之一起销毁
74 return cmd.ExecuteReader(CommandBehavior.CloseConnection);
75 }
76 catch (Exception)
77 {
78 con.Close();
79 con.Dispose();
80 throw;
81 }
82 }
83 }
84
85
86 ///
87 /// //执行操作SQL语句,返回DataTable
88 ///
89 ///
90 ///
91 ///
92 ///
93 public static DataTable ExecuteToDataTable(string sql,CommandType cmdType = CommandType.Text,params SqlParameter[] pms)
94 {
95 DataTable dt = new DataTable();
96 using (SqlDataAdapter adapter = new SqlDataAdapter(sql, conStr))
97 {
98 adapter.SelectCommand.CommandType = cmdType;
99 if (pms != null)
100 {
101 adapter.SelectCommand.Parameters.AddRange(pms);
102 }
103 adapter.Fill(dt);
104 }
105
106 return dt;
107 }
108
109 ///
110 /// 执行操作SQL语句,返回DataSet
111 ///
112 ///
113 public static DataSet ExecuteToDataSet(string sql, CommandType cmdType = CommandType.Text, params IDataParameter[] pms)
114 {
115 DataSet ds = new DataSet();
116 using (SqlDataAdapter adapter = new SqlDataAdapter(sql, conStr))
117 {
118 adapter.SelectCommand.CommandType = cmdType;
119 if (pms != null)
120 {
121 adapter.SelectCommand.Parameters.AddRange(pms);
122 }
123 adapter.Fill(ds);
124 }
125 return ds;
126 }
127
128 ///
129 /// DataTable 转换为List 集合
130 ///
131 /// 类型
132 /// DataTable
133 ///
134 public static IList DataTableToList(DataTable dt) where T : class,new()
135 {
136 //创建一个属性的列表
137 List prlist = new List();
138 //获取T的类型实例 反射的入口
139 Type t = typeof(T);
140 //获得T 的所有的Public 属性 并找出T属性和DataTable的列名称相同的属性(PropertyInfo) 并加入到属性列表
141 Array.ForEach(t.GetProperties(), p => { if (dt.Columns.IndexOf(p.Name) != -1) prlist.Add(p); });
142 //创建返回的集合
143 List oblist = new List();
144
145 foreach (DataRow row in dt.Rows)
146 {
147 //创建T的实例
148 T ob = new T();
149 //找到对应的数据 并赋值
150 prlist.ForEach(p => { if (row[p.Name] != DBNull.Value) p.SetValue(ob, row[p.Name], null); });
151 //放入到返回的集合中.
152 oblist.Add(ob);
153 }
154 return oblist;
155 }
156
157 ///
158 /// List集合 转换为一个DataTable
159 ///
160 ///
161 ///
162 ///
163 public static DataTable ListToDataTable(IEnumerable value) where T : class
164 {
165 //创建属性的集合
166 List pList = new List();
167 //获得反射的入口
168 Type type = typeof(T);
169 DataTable dt = new DataTable();
170 //把所有的public属性加入到集合 并添加DataTable的列
171 Array.ForEach(type.GetProperties(), p => { pList.Add(p); dt.Columns.Add(p.Name); });
172 foreach (var item in value)
173 {
174 //创建一个DataRow实例
175 DataRow row = dt.NewRow();
176 //给row 赋值
177 pList.ForEach(p => row[p.Name] = p.GetValue(item, null));
178 //加入到DataTable
179 dt.Rows.Add(row);
180 }
181 return dt;
182 }
183
184 //IDataReder转实体类列表
185 public static List ReaderToList(IDataReader DataReader)
186 {
187 using (DataReader)
188 {
189 List<string> field = new List<string>(DataReader.FieldCount);
190 for (int i = 0; i < DataReader.FieldCount; i++)
191 {
192 field.Add(DataReader.GetName(i).ToLower());
193 }
194 List list = new List();
195 while (DataReader.Read())
196 {
197 T model = Activator.CreateInstance();
198 foreach (PropertyInfo property in model.GetType().GetProperties(BindingFlags.GetProperty | BindingFlags.Public | BindingFlags.Instance))
199 {
200 if (field.Contains(property.Name.ToLower()))
201 {
202 //if (!IsNullOrDBNull(DataReader[property.Name]))
203 if (DataReader[property.Name] != DBNull.Value)
204 {
205 property.SetValue(model, HackType(DataReader[property.Name], property.PropertyType), null);
206 }
207 }
208 }
209 list.Add(model);
210 }
211 return list;
212 }
213 }
214
215 ///
216 /// IDataReder转实体类列表 空字符串和dbnull都返回null
217 ///
218 ///
219 ///
220 ///
221 public static List ReaderToListNull(IDataReader DataReader)
222 {
223 using (DataReader)
224 {
225 List<string> field = new List<string>(DataReader.FieldCount);
226 for (int i = 0; i < DataReader.FieldCount; i++)
227 {
228 field.Add(DataReader.GetName(i).ToLower());
229 }
230 List list = new List();
231 while (DataReader.Read())
232 {
233 T model = Activator.CreateInstance();
234 foreach (PropertyInfo property in model.GetType().GetProperties(BindingFlags.GetProperty | BindingFlags.Public | BindingFlags.Instance))
235 {
236 if (field.Contains(property.Name.ToLower()))
237 {
238 if (!IsNullOrDBNull(DataReader[property.Name]))
239 //if (DataReader[property.Name] != DBNull.Value)
240 {
241 property.SetValue(model, HackType(DataReader[property.Name], property.PropertyType), null);
242 }
243 }
244 }
245 list.Add(model);
246 }
247 return list;
248 }
249 }
250
251 //IDataReder转实体类列表
252 public static List<dynamic> ReaderToDynamicList(IDataReader DataReader)
253 {
254 using (DataReader)
255 {
256 List<dynamic> list = new List<dynamic>();
257 while (DataReader.Read())
258 {
259 dynamic DataObject = new ExpandoObject();
260 var DataRow = DataObject as IDictionary<string, object>;
261
262 for (int i = 0; i < DataReader.FieldCount; i++)
263 {
264 DataRow.Add(DataReader.GetName(i).ToUpper(), DataReader[i]);
265 }
266 list.Add(DataRow);
267 }
268 return list;
269 }
270 }
271
272 //这个类对可空类型进行判断转换，要不然会报错
273 private static object HackType(object value, Type conversionType)
274 {
275 if (conversionType.IsGenericType && conversionType.GetGenericTypeDefinition().Equals(typeof(Nullable<>)))
276 {
277 if (value == null)
278 return null;
279
280 System.ComponentModel.NullableConverter nullableConverter = new System.ComponentModel.NullableConverter(conversionType);
281 conversionType = nullableConverter.UnderlyingType;
282 }
283 return Convert.ChangeType(value, conversionType);
284 }
285
286 private static bool IsNullOrDBNull(object obj)
287 {
288 return ((obj is DBNull) || string.IsNullOrEmpty(obj.ToString())) ? true : false;
289 }
290 }
2、c# SqlHelper微软版本
1 using System;
2 using System.Collections;
3 using System.Collections.Generic;
4 using System.Configuration;
5 using System.Data;
6 using System.Data.SqlClient;
7 using System.Linq;
8 using System.Text;
9 using System.Threading.Tasks;
10 using System.Xml;
11
12 namespace ConsoleApplication1
13 {
14 ///
15 /// SqlServer数据访问帮助类
16 ///
17 public sealed class SqlHelper
18 {
19 #region 私有构造函数和方法
20
21 private SqlHelper() { }
22
23 ///
24 /// 将SqlParameter参数数组(参数值)分配给SqlCommand命令.
25 /// 这个方法将给任何一个参数分配DBNull.Value;
26 /// 该操作将阻止默认值的使用.
27 ///
28 /// 命令名
29 /// SqlParameters数组
30 private static void AttachParameters(SqlCommand command, SqlParameter[] commandParameters)
31 {
32 if (command == null) throw new ArgumentNullException("command");
33 if (commandParameters != null)
34 {
35 foreach (SqlParameter p in commandParameters)
36 {
37 if (p != null)
38 {
39 // 检查未分配值的输出参数,将其分配以DBNull.Value.
40 if ((p.Direction == ParameterDirection.InputOutput || p.Direction == ParameterDirection.Input) &&
41 (p.Value == null))
42 {
43 p.Value = DBNull.Value;
44 }
45 command.Parameters.Add(p);
46 }
47 }
48 }
49 }
50
51 ///
52 /// 将DataRow类型的列值分配到SqlParameter参数数组.
53 ///
54 /// 要分配值的SqlParameter参数数组
55 /// 将要分配给存储过程参数的DataRow
56 private static void AssignParameterValues(SqlParameter[] commandParameters, DataRow dataRow)
57 {
58 if ((commandParameters == null) || (dataRow == null))
59 {
60 return;
61 }
62
63 int i = 0;
64 // 设置参数值
65 foreach (SqlParameter commandParameter in commandParameters)
66 {
67 // 创建参数名称,如果不存在,只抛出一个异常.
68 if (commandParameter.ParameterName == null ||
69 commandParameter.ParameterName.Length <= 1)
70 throw new Exception(
71 string.Format("请提供参数{0}一个有效的名称{1}.", i, commandParameter.ParameterName));
72 // 从dataRow的表中获取为参数数组中数组名称的列的索引.
73 // 如果存在和参数名称相同的列,则将列值赋给当前名称的参数.
74 if (dataRow.Table.Columns.IndexOf(commandParameter.ParameterName.Substring(1)) != -1)
75 commandParameter.Value = dataRow[commandParameter.ParameterName.Substring(1)];
76 i++;
77 }
78 }
79
80 ///
81 /// 将一个对象数组分配给SqlParameter参数数组.
82 ///
83 /// 要分配值的SqlParameter参数数组
84 /// 将要分配给存储过程参数的对象数组
85 private static void AssignParameterValues(SqlParameter[] commandParameters, object[] parameterValues)
86 {
87 if ((commandParameters == null) || (parameterValues == null))
88 {
89 return;
90 }
91
92 // 确保对象数组个数与参数个数匹配,如果不匹配,抛出一个异常.
93 if (commandParameters.Length != parameterValues.Length)
94 {
95 throw new ArgumentException("参数值个数与参数不匹配.");
96 }
97
98 // 给参数赋值
99 for (int i = 0, j = commandParameters.Length; i < j; i++)
100 {
101 // If the current array value derives from IDbDataParameter, then assign its Value property
102 if (parameterValues[i] is IDbDataParameter)
103 {
104 IDbDataParameter paramInstance = (IDbDataParameter)parameterValues[i];
105 if (paramInstance.Value == null)
106 {
107 commandParameters[i].Value = DBNull.Value;
108 }
109 else
110 {
111 commandParameters[i].Value = paramInstance.Value;
112 }
113 }
114 else if (parameterValues[i] == null)
115 {
116 commandParameters[i].Value = DBNull.Value;
117 }
118 else
119 {
120 commandParameters[i].Value = parameterValues[i];
121 }
122 }
123 }
124
125 ///
126 /// 预处理用户提供的命令,数据库连接/事务/命令类型/参数
127 ///
128 /// 要处理的SqlCommand
129 /// 数据库连接
130 /// 一个有效的事务或者是null值
131 /// 命令类型 (存储过程,命令文本, 其它.)
132 /// 存储过程名或都T-SQL命令文本
133 /// 和命令相关联的SqlParameter参数数组,如果没有参数为'null'
134 /// true 如果连接是打开的,则为true,其它情况下为false.
135 private static void PrepareCommand(SqlCommand command, SqlConnection connection, SqlTransaction transaction, CommandType commandType, string commandText, SqlParameter[] commandParameters, out bool mustCloseConnection)
136 {
137 if (command == null) throw new ArgumentNullException("command");
138 if (commandText == null || commandText.Length == 0) throw new ArgumentNullException("commandText");
139
140 // If the provided connection is not open, we will open it
141 if (connection.State != ConnectionState.Open)
142 {
143 mustCloseConnection = true;
144 connection.Open();
145 }
146 else
147 {
148 mustCloseConnection = false;
149 }
150
151 // 给命令分配一个数据库连接.
152 command.Connection = connection;
153
154 // 设置命令文本(存储过程名或SQL语句)
155 command.CommandText = commandText;
156
157 // 分配事务
158 if (transaction != null)
159 {
160 if (transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
161 command.Transaction = transaction;
162 }
163
164 // 设置命令类型.
165 command.CommandType = commandType;
166
167 // 分配命令参数
168 if (commandParameters != null)
169 {
170 AttachParameters(command, commandParameters);
171 }
172 return;
173 }
174
175 #endregion 私有构造函数和方法结束
176
177 #region 数据库连接
178 ///
179 /// 一个有效的数据库连接字符串
180 ///
181 ///
182 public static string GetConnSting()
183 {
184 return ConfigurationManager.ConnectionStrings["ConStr"].ConnectionString;
185 }
186 ///
187 /// 一个有效的数据库连接对象
188 ///
189 ///
190 public static SqlConnection GetConnection()
191 {
192 SqlConnection Connection = new SqlConnection(SqlHelper.GetConnSting());
193 return Connection;
194 }
195 #endregion
196
197 #region ExecuteNonQuery命令
198
199 ///
200 /// 执行指定连接字符串,类型的SqlCommand.
201 ///
202 ///
203 /// 示例:
204 /// int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders");
205 ///
206 /// 一个有效的数据库连接字符串
207 /// 命令类型 (存储过程,命令文本, 其它.)
208 /// 存储过程名称或SQL语句
209 /// 返回命令影响的行数
210 public static int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText)
211 {
212 return ExecuteNonQuery(connectionString, commandType, commandText, (SqlParameter[])null);
213 }
214
215 ///
216 /// 执行指定连接字符串,类型的SqlCommand.如果没有提供参数,不返回结果.
217 ///
218 ///
219 /// 示例:
220 /// int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
221 ///
222 /// 一个有效的数据库连接字符串
223 /// 命令类型 (存储过程,命令文本, 其它.)
224 /// 存储过程名称或SQL语句
225 /// SqlParameter参数数组
226 /// 返回命令影响的行数
227 public static int ExecuteNonQuery(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
228 {
229 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
230
231 using (SqlConnection connection = new SqlConnection(connectionString))
232 {
233 connection.Open();
234
235 return ExecuteNonQuery(connection, commandType, commandText, commandParameters);
236 }
237 }
238
239 ///
240 /// 执行指定连接字符串的存储过程,将对象数组的值赋给存储过程参数,
241 /// 此方法需要在参数缓存方法中探索参数并生成参数.
242 ///
243 ///
244 /// 这个方法没有提供访问输出参数和返回值.
245 /// 示例:
246 /// int result = ExecuteNonQuery(connString, "PublishOrders", 24, 36);
247 ///
248 /// 一个有效的数据库连接字符串/param>
249 /// 存储过程名称
250 /// 分配到存储过程输入参数的对象数组
251 /// 返回受影响的行数
252 public static int ExecuteNonQuery(string connectionString, string spName, params object[] parameterValues)
253 {
254 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
255 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
256
257 // 如果存在参数值
258 if ((parameterValues != null) && (parameterValues.Length > 0))
259 {
260 // 从探索存储过程参数(加载到缓存)并分配给存储过程参数数组.
261 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
262
263 // 给存储过程参数赋值
264 AssignParameterValues(commandParameters, parameterValues);
265
266 return ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName, commandParameters);
267 }
268 else
269 {
270 // 没有参数情况下
271 return ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName);
272 }
273 }
274
275 ///
276 /// 执行指定数据库连接对象的命令
277 ///
278 ///
279 /// 示例:
280 /// int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders");
281 ///
282 /// 一个有效的数据库连接对象
283 /// 命令类型(存储过程,命令文本或其它.)
284 /// 存储过程名称或T-SQL语句
285 /// 返回影响的行数
286 public static int ExecuteNonQuery(SqlConnection connection, CommandType commandType, string commandText)
287 {
288 return ExecuteNonQuery(connection, commandType, commandText, (SqlParameter[])null);
289 }
290
291 ///
292 /// 执行指定数据库连接对象的命令
293 ///
294 ///
295 /// 示例:
296 /// int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
297 ///
298 /// 一个有效的数据库连接对象
299 /// 命令类型(存储过程,命令文本或其它.)
300 /// T存储过程名称或T-SQL语句
301 /// SqlParamter参数数组
302 /// 返回影响的行数
303 public static int ExecuteNonQuery(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
304 {
305 if (connection == null) throw new ArgumentNullException("connection");
306
307 // 创建SqlCommand命令,并进行预处理
308 SqlCommand cmd = new SqlCommand();
309 bool mustCloseConnection = false;
310 PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters, out mustCloseConnection);
311
312 // Finally, execute the command
313 int retval = cmd.ExecuteNonQuery();
314
315 // 清除参数,以便再次使用.
316 cmd.Parameters.Clear();
317 if (mustCloseConnection)
318 connection.Close();
319 return retval;
320 }
321
322 ///
323 /// 执行指定数据库连接对象的命令,将对象数组的值赋给存储过程参数.
324 ///
325 ///
326 /// 此方法不提供访问存储过程输出参数和返回值
327 /// 示例:
328 /// int result = ExecuteNonQuery(conn, "PublishOrders", 24, 36);
329 ///
330 /// 一个有效的数据库连接对象
331 /// 存储过程名
332 /// 分配给存储过程输入参数的对象数组
333 /// 返回影响的行数
334 public static int ExecuteNonQuery(SqlConnection connection, string spName, params object[] parameterValues)
335 {
336 if (connection == null) throw new ArgumentNullException("connection");
337 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
338
339 // 如果有参数值
340 if ((parameterValues != null) && (parameterValues.Length > 0))
341 {
342 // 从缓存中加载存储过程参数
343 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
344
345 // 给存储过程分配参数值
346 AssignParameterValues(commandParameters, parameterValues);
347
348 return ExecuteNonQuery(connection, CommandType.StoredProcedure, spName, commandParameters);
349 }
350 else
351 {
352 return ExecuteNonQuery(connection, CommandType.StoredProcedure, spName);
353 }
354 }
355
356 ///
357 /// 执行带事务的SqlCommand.
358 ///
359 ///
360 /// 示例.:
361 /// int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "PublishOrders");
362 ///
363 /// 一个有效的数据库连接对象
364 /// 命令类型(存储过程,命令文本或其它.)
365 /// 存储过程名称或T-SQL语句
366 /// 返回影响的行数/returns>
367 public static int ExecuteNonQuery(SqlTransaction transaction, CommandType commandType, string commandText)
368 {
369 return ExecuteNonQuery(transaction, commandType, commandText, (SqlParameter[])null);
370 }
371
372 ///
373 /// 执行带事务的SqlCommand(指定参数).
374 ///
375 ///
376 /// 示例:
377 /// int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
378 ///
379 /// 一个有效的数据库连接对象
380 /// 命令类型(存储过程,命令文本或其它.)
381 /// 存储过程名称或T-SQL语句
382 /// SqlParamter参数数组
383 /// 返回影响的行数
384 public static int ExecuteNonQuery(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
385 {
386 if (transaction == null) throw new ArgumentNullException("transaction");
387 if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
388
389 // 预处理
390 SqlCommand cmd = new SqlCommand();
391 bool mustCloseConnection = false;
392 PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
393
394 // 执行
395 int retval = cmd.ExecuteNonQuery();
396
397 // 清除参数集,以便再次使用.
398 cmd.Parameters.Clear();
399 return retval;
400 }
401
402 ///
403 /// 执行带事务的SqlCommand(指定参数值).
404 ///
405 ///
406 /// 此方法不提供访问存储过程输出参数和返回值
407 /// 示例:
408 /// int result = ExecuteNonQuery(conn, trans, "PublishOrders", 24, 36);
409 ///
410 /// 一个有效的数据库连接对象
411 /// 存储过程名
412 /// 分配给存储过程输入参数的对象数组
413 /// 返回受影响的行数
414 public static int ExecuteNonQuery(SqlTransaction transaction, string spName, params object[] parameterValues)
415 {
416 if (transaction == null) throw new ArgumentNullException("transaction");
417 if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
418 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
419
420 // 如果有参数值
421 if ((parameterValues != null) && (parameterValues.Length > 0))
422 {
423 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
424 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
425
426 // 给存储过程参数赋值
427 AssignParameterValues(commandParameters, parameterValues);
428
429 // 调用重载方法
430 return ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName, commandParameters);
431 }
432 else
433 {
434 // 没有参数值
435 return ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName);
436 }
437 }
438
439 #endregion ExecuteNonQuery方法结束
440
441 #region ExecuteDataset方法
442
443 ///
444 /// 执行指定数据库连接字符串的命令,返回DataSet.
445 ///
446 ///
447 /// 示例:
448 /// DataSet ds = ExecuteDataset(connString, CommandType.StoredProcedure, "GetOrders");
449 ///
450 /// 一个有效的数据库连接字符串
451 /// 命令类型 (存储过程,命令文本或其它)
452 /// 存储过程名称或T-SQL语句
453 /// 返回一个包含结果集的DataSet
454 public static DataSet ExecuteDataset(string connectionString, CommandType commandType, string commandText)
455 {
456 return ExecuteDataset(connectionString, commandType, commandText, (SqlParameter[])null);
457 }
458
459 ///
460 /// 执行指定数据库连接字符串的命令,返回DataSet.
461 ///
462 ///
463 /// 示例:
464 /// DataSet ds = ExecuteDataset(connString, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
465 ///
466 /// 一个有效的数据库连接字符串
467 /// 命令类型 (存储过程,命令文本或其它)
468 /// 存储过程名称或T-SQL语句
469 /// SqlParamters参数数组
470 /// 返回一个包含结果集的DataSet
471 public static DataSet ExecuteDataset(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
472 {
473 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
474
475 // 创建并打开数据库连接对象,操作完成释放对象.
476 using (SqlConnection connection = new SqlConnection(connectionString))
477 {
478 connection.Open();
479
480 // 调用指定数据库连接字符串重载方法.
481 return ExecuteDataset(connection, commandType, commandText, commandParameters);
482 }
483 }
484
485 ///
486 /// 执行指定数据库连接字符串的命令,直接提供参数值,返回DataSet.
487 ///
488 ///
489 /// 此方法不提供访问存储过程输出参数和返回值.
490 /// 示例:
491 /// DataSet ds = ExecuteDataset(connString, "GetOrders", 24, 36);
492 ///
493 /// 一个有效的数据库连接字符串
494 /// 存储过程名
495 /// 分配给存储过程输入参数的对象数组
496 /// 返回一个包含结果集的DataSet
497 public static DataSet ExecuteDataset(string connectionString, string spName, params object[] parameterValues)
498 {
499 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
500 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
501
502 if ((parameterValues != null) && (parameterValues.Length > 0))
503 {
504 // 从缓存中检索存储过程参数
505 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
506
507 // 给存储过程参数分配值
508 AssignParameterValues(commandParameters, parameterValues);
509
510 return ExecuteDataset(connectionString, CommandType.StoredProcedure, spName, commandParameters);
511 }
512 else
513 {
514 return ExecuteDataset(connectionString, CommandType.StoredProcedure, spName);
515 }
516 }
517
518 ///
519 /// 执行指定数据库连接对象的命令,返回DataSet.
520 ///
521 ///
522 /// 示例:
523 /// DataSet ds = ExecuteDataset(conn, CommandType.StoredProcedure, "GetOrders");
524 ///
525 /// 一个有效的数据库连接对象
526 /// 命令类型 (存储过程,命令文本或其它)
527 /// 存储过程名或T-SQL语句
528 /// 返回一个包含结果集的DataSet
529 public static DataSet ExecuteDataset(SqlConnection connection, CommandType commandType, string commandText)
530 {
531 return ExecuteDataset(connection, commandType, commandText, (SqlParameter[])null);
532 }
533
534 ///
535 /// 执行指定数据库连接对象的命令,指定存储过程参数,返回DataSet.
536 ///
537 ///
538 /// 示例:
539 /// DataSet ds = ExecuteDataset(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
540 ///
541 /// 一个有效的数据库连接对象
542 /// 命令类型 (存储过程,命令文本或其它)
543 /// 存储过程名或T-SQL语句
544 /// SqlParamter参数数组
545 /// 返回一个包含结果集的DataSet
546 public static DataSet ExecuteDataset(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
547 {
548 if (connection == null) throw new ArgumentNullException("connection");
549
550 // 预处理
551 SqlCommand cmd = new SqlCommand();
552 bool mustCloseConnection = false;
553 PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters, out mustCloseConnection);
554
555 // 创建SqlDataAdapter和DataSet.
556 using (SqlDataAdapter da = new SqlDataAdapter(cmd))
557 {
558 DataSet ds = new DataSet();
559
560 // 填充DataSet.
561 da.Fill(ds);
562
563 cmd.Parameters.Clear();
564
565 if (mustCloseConnection)
566 connection.Close();
567
568 return ds;
569 }
570 }
571
572 ///
573 /// 执行指定数据库连接对象的命令,指定参数值,返回DataSet.
574 ///
575 ///
576 /// 此方法不提供访问存储过程输入参数和返回值.
577 /// 示例.:
578 /// DataSet ds = ExecuteDataset(conn, "GetOrders", 24, 36);
579 ///
580 /// 一个有效的数据库连接对象
581 /// 存储过程名
582 /// 分配给存储过程输入参数的对象数组
583 /// 返回一个包含结果集的DataSet
584 public static DataSet ExecuteDataset(SqlConnection connection, string spName, params object[] parameterValues)
585 {
586 if (connection == null) throw new ArgumentNullException("connection");
587 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
588
589 if ((parameterValues != null) && (parameterValues.Length > 0))
590 {
591 // 比缓存中加载存储过程参数
592 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
593
594 // 给存储过程参数分配值
595 AssignParameterValues(commandParameters, parameterValues);
596
597 return ExecuteDataset(connection, CommandType.StoredProcedure, spName, commandParameters);
598 }
599 else
600 {
601 return ExecuteDataset(connection, CommandType.StoredProcedure, spName);
602 }
603 }
604
605 ///
606 /// 执行指定事务的命令,返回DataSet.
607 ///
608 ///
609 /// 示例:
610 /// DataSet ds = ExecuteDataset(trans, CommandType.StoredProcedure, "GetOrders");
611 ///
612 /// 事务
613 /// 命令类型 (存储过程,命令文本或其它)
614 /// 存储过程名或T-SQL语句
615 /// 返回一个包含结果集的DataSet
616 public static DataSet ExecuteDataset(SqlTransaction transaction, CommandType commandType, string commandText)
617 {
618 return ExecuteDataset(transaction, commandType, commandText, (SqlParameter[])null);
619 }
620
621 ///
622 /// 执行指定事务的命令,指定参数,返回DataSet.
623 ///
624 ///
625 /// 示例:
626 /// DataSet ds = ExecuteDataset(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
627 ///
628 /// 事务
629 /// 命令类型 (存储过程,命令文本或其它)
630 /// 存储过程名或T-SQL语句
631 /// SqlParamter参数数组
632 /// 返回一个包含结果集的DataSet
633 public static DataSet ExecuteDataset(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
634 {
635 if (transaction == null) throw new ArgumentNullException("transaction");
636 if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
637
638 // 预处理
639 SqlCommand cmd = new SqlCommand();
640 bool mustCloseConnection = false;
641 PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
642
643 // 创建 DataAdapter & DataSet
644 using (SqlDataAdapter da = new SqlDataAdapter(cmd))
645 {
646 DataSet ds = new DataSet();
647 da.Fill(ds);
648 cmd.Parameters.Clear();
649 return ds;
650 }
651 }
652
653 ///
654 /// 执行指定事务的命令,指定参数值,返回DataSet.
655 ///
656 ///
657 /// 此方法不提供访问存储过程输入参数和返回值.
658 /// 示例.:
659 /// DataSet ds = ExecuteDataset(trans, "GetOrders", 24, 36);
660 ///
661 /// 事务
662 /// 存储过程名
663 /// 分配给存储过程输入参数的对象数组
664 /// 返回一个包含结果集的DataSet
665 public static DataSet ExecuteDataset(SqlTransaction transaction, string spName, params object[] parameterValues)
666 {
667 if (transaction == null) throw new ArgumentNullException("transaction");
668 if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
669 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
670
671 if ((parameterValues != null) && (parameterValues.Length > 0))
672 {
673 // 从缓存中加载存储过程参数
674 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
675
676 // 给存储过程参数分配值
677 AssignParameterValues(commandParameters, parameterValues);
678
679 return ExecuteDataset(transaction, CommandType.StoredProcedure, spName, commandParameters);
680 }
681 else
682 {
683 return ExecuteDataset(transaction, CommandType.StoredProcedure, spName);
684 }
685 }
686
687 #endregion ExecuteDataset数据集命令结束
688
689 #region ExecuteReader 数据阅读器
690
691 ///
692 /// 枚举,标识数据库连接是由SqlHelper提供还是由调用者提供
693 ///
694 private enum SqlConnectionOwnership
695 {
696 /// 由SqlHelper提供连接
697 Internal,
698 /// 由调用者提供连接
699 External
700 }
701
702 ///
703 /// 执行指定数据库连接对象的数据阅读器.
704 ///
705 ///
706 /// 如果是SqlHelper打开连接,当连接关闭DataReader也将关闭.
707 /// 如果是调用都打开连接,DataReader由调用都管理.
708 ///
709 /// 一个有效的数据库连接对象
710 /// 一个有效的事务,或者为 'null'
711 /// 命令类型 (存储过程,命令文本或其它)
712 /// 存储过程名或T-SQL语句
713 /// SqlParameters参数数组,如果没有参数则为'null'
714 /// 标识数据库连接对象是由调用者提供还是由SqlHelper提供
715 /// 返回包含结果集的SqlDataReader
716 private static SqlDataReader ExecuteReader(SqlConnection connection, SqlTransaction transaction, CommandType commandType, string commandText, SqlParameter[] commandParameters, SqlConnectionOwnership connectionOwnership)
717 {
718 if (connection == null) throw new ArgumentNullException("connection");
719
720 bool mustCloseConnection = false;
721 // 创建命令
722 SqlCommand cmd = new SqlCommand();
723 try
724 {
725 PrepareCommand(cmd, connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
726
727 // 创建数据阅读器
728 SqlDataReader dataReader;
729
730 if (connectionOwnership == SqlConnectionOwnership.External)
731 {
732 dataReader = cmd.ExecuteReader();
733 }
734 else
735 {
736 dataReader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
737 }
738
739 // 清除参数,以便再次使用..
740 // HACK: There is a problem here, the output parameter values are fletched
741 // when the reader is closed, so if the parameters are detached from the command
742 // then the SqlReader can磘 set its values.
743 // When this happen, the parameters can磘 be used again in other command.
744 bool canClear = true;
745 foreach (SqlParameter commandParameter in cmd.Parameters)
746 {
747 if (commandParameter.Direction != ParameterDirection.Input)
748 canClear = false;
749 }
750
751 if (canClear)
752 {
753 cmd.Parameters.Clear();
754 }
755
756 return dataReader;
757 }
758 catch
759 {
760 if (mustCloseConnection)
761 connection.Close();
762 throw;
763 }
764 }
765
766 ///
767 /// 执行指定数据库连接字符串的数据阅读器.
768 ///
769 ///
770 /// 示例:
771 /// SqlDataReader dr = ExecuteReader(connString, CommandType.StoredProcedure, "GetOrders");
772 ///
773 /// 一个有效的数据库连接字符串
774 /// 命令类型 (存储过程,命令文本或其它)
775 /// 存储过程名或T-SQL语句
776 /// 返回包含结果集的SqlDataReader
777 public static SqlDataReader ExecuteReader(string connectionString, CommandType commandType, string commandText)
778 {
779 return ExecuteReader(connectionString, commandType, commandText, (SqlParameter[])null);
780 }
781
782 ///
783 /// 执行指定数据库连接字符串的数据阅读器,指定参数.
784 ///
785 ///
786 /// 示例:
787 /// SqlDataReader dr = ExecuteReader(connString, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
788 ///
789 /// 一个有效的数据库连接字符串
790 /// 命令类型 (存储过程,命令文本或其它)
791 /// 存储过程名或T-SQL语句
792 /// SqlParamter参数数组(new SqlParameter("@prodid", 24))
793 /// 返回包含结果集的SqlDataReader
794 public static SqlDataReader ExecuteReader(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
795 {
796 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
797 SqlConnection connection = null;
798 try
799 {
800 connection = new SqlConnection(connectionString);
801 connection.Open();
802
803 return ExecuteReader(connection, null, commandType, commandText, commandParameters, SqlConnectionOwnership.Internal);
804 }
805 catch
806 {
807 // If we fail to return the SqlDatReader, we need to close the connection ourselves
808 if (connection != null) connection.Close();
809 throw;
810 }
811
812 }
813
814 ///
815 /// 执行指定数据库连接字符串的数据阅读器,指定参数值.
816 ///
817 ///
818 /// 此方法不提供访问存储过程输出参数和返回值参数.
819 /// 示例:
820 /// SqlDataReader dr = ExecuteReader(connString, "GetOrders", 24, 36);
821 ///
822 /// 一个有效的数据库连接字符串
823 /// 存储过程名
824 /// 分配给存储过程输入参数的对象数组
825 /// 返回包含结果集的SqlDataReader
826 public static SqlDataReader ExecuteReader(string connectionString, string spName, params object[] parameterValues)
827 {
828 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
829 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
830
831 if ((parameterValues != null) && (parameterValues.Length > 0))
832 {
833 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
834
835 AssignParameterValues(commandParameters, parameterValues);
836
837 return ExecuteReader(connectionString, CommandType.StoredProcedure, spName, commandParameters);
838 }
839 else
840 {
841 return ExecuteReader(connectionString, CommandType.StoredProcedure, spName);
842 }
843 }
844
845 ///
846 /// 执行指定数据库连接对象的数据阅读器.
847 ///
848 ///
849 /// 示例:
850 /// SqlDataReader dr = ExecuteReader(conn, CommandType.StoredProcedure, "GetOrders");
851 ///
852 /// 一个有效的数据库连接对象
853 /// 命令类型 (存储过程,命令文本或其它)
854 /// 存储过程名或T-SQL语句
855 /// 返回包含结果集的SqlDataReader
856 public static SqlDataReader ExecuteReader(SqlConnection connection, CommandType commandType, string commandText)
857 {
858 return ExecuteReader(connection, commandType, commandText, (SqlParameter[])null);
859 }
860
861 ///
862 /// [调用者方式]执行指定数据库连接对象的数据阅读器,指定参数.
863 ///
864 ///
865 /// 示例:
866 /// SqlDataReader dr = ExecuteReader(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
867 ///
868 /// 一个有效的数据库连接对象
869 /// 命令类型 (存储过程,命令文本或其它)
870 /// 命令类型 (存储过程,命令文本或其它)
871 /// SqlParamter参数数组
872 /// 返回包含结果集的SqlDataReader
873 public static SqlDataReader ExecuteReader(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
874 {
875 return ExecuteReader(connection, (SqlTransaction)null, commandType, commandText, commandParameters, SqlConnectionOwnership.External);
876 }
877
878 ///
879 /// [调用者方式]执行指定数据库连接对象的数据阅读器,指定参数值.
880 ///
881 ///
882 /// 此方法不提供访问存储过程输出参数和返回值参数.
883 /// 示例:
884 /// SqlDataReader dr = ExecuteReader(conn, "GetOrders", 24, 36);
885 ///
886 /// 一个有效的数据库连接对象
887 /// T存储过程名
888 /// 分配给存储过程输入参数的对象数组
889 /// 返回包含结果集的SqlDataReader
890 public static SqlDataReader ExecuteReader(SqlConnection connection, string spName, params object[] parameterValues)
891 {
892 if (connection == null) throw new ArgumentNullException("connection");
893 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
894
895 if ((parameterValues != null) && (parameterValues.Length > 0))
896 {
897 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
898
899 AssignParameterValues(commandParameters, parameterValues);
900
901 return ExecuteReader(connection, CommandType.StoredProcedure, spName, commandParameters);
902 }
903 else
904 {
905 return ExecuteReader(connection, CommandType.StoredProcedure, spName);
906 }
907 }
908
909 ///
910 /// [调用者方式]执行指定数据库事务的数据阅读器,指定参数值.
911 ///
912 ///
913 /// 示例:
914 /// SqlDataReader dr = ExecuteReader(trans, CommandType.StoredProcedure, "GetOrders");
915 ///
916 /// 一个有效的连接事务
917 /// 命令类型 (存储过程,命令文本或其它)
918 /// 存储过程名称或T-SQL语句
919 /// 返回包含结果集的SqlDataReader
920 public static SqlDataReader ExecuteReader(SqlTransaction transaction, CommandType commandType, string commandText)
921 {
922 return ExecuteReader(transaction, commandType, commandText, (SqlParameter[])null);
923 }
924
925 ///
926 /// [调用者方式]执行指定数据库事务的数据阅读器,指定参数.
927 ///
928 ///
929 /// 示例:
930 /// SqlDataReader dr = ExecuteReader(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
931 ///
932 /// 一个有效的连接事务
933 /// 命令类型 (存储过程,命令文本或其它)
934 /// 存储过程名称或T-SQL语句
935 /// 分配给命令的SqlParamter参数数组
936 /// 返回包含结果集的SqlDataReader
937 public static SqlDataReader ExecuteReader(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
938 {
939 if (transaction == null) throw new ArgumentNullException("transaction");
940 if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
941
942 return ExecuteReader(transaction.Connection, transaction, commandType, commandText, commandParameters, SqlConnectionOwnership.External);
943 }
944
945 ///
946 /// [调用者方式]执行指定数据库事务的数据阅读器,指定参数值.
947 ///
948 ///
949 /// 此方法不提供访问存储过程输出参数和返回值参数.
950 ///
951 /// 示例:
952 /// SqlDataReader dr = ExecuteReader(trans, "GetOrders", 24, 36);
953 ///
954 /// 一个有效的连接事务
955 /// 存储过程名称
956 /// 分配给存储过程输入参数的对象数组
957 /// 返回包含结果集的SqlDataReader
958 public static SqlDataReader ExecuteReader(SqlTransaction transaction, string spName, params object[] parameterValues)
959 {
960 if (transaction == null) throw new ArgumentNullException("transaction");
961 if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
962 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
963
964 // 如果有参数值
965 if ((parameterValues != null) && (parameterValues.Length > 0))
966 {
967 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
968
969 AssignParameterValues(commandParameters, parameterValues);
970
971 return ExecuteReader(transaction, CommandType.StoredProcedure, spName, commandParameters);
972 }
973 else
974 {
975 // 没有参数值
976 return ExecuteReader(transaction, CommandType.StoredProcedure, spName);
977 }
978 }
979
980 #endregion ExecuteReader数据阅读器
981
982 #region ExecuteScalar 返回结果集中的第一行第一列
983
984 ///
985 /// 执行指定数据库连接字符串的命令,返回结果集中的第一行第一列.
986 ///
987 ///
988 /// 示例:
989 /// int orderCount = (int)ExecuteScalar(connString, CommandType.StoredProcedure, "GetOrderCount");
990 ///
991 /// 一个有效的数据库连接字符串
992 /// 命令类型 (存储过程,命令文本或其它)
993 /// 存储过程名称或T-SQL语句
994 /// 返回结果集中的第一行第一列
995 public static object ExecuteScalar(string connectionString, CommandType commandType, string commandText)
996 {
997 // 执行参数为空的方法
998 return ExecuteScalar(connectionString, commandType, commandText, (SqlParameter[])null);
999 }
1000
1001 ///
1002 /// 执行指定数据库连接字符串的命令,指定参数,返回结果集中的第一行第一列.
1003 ///
1004 ///
1005 /// 示例:
1006 /// int orderCount = (int)ExecuteScalar(connString, CommandType.StoredProcedure, "GetOrderCount", new SqlParameter("@prodid", 24));
1007 ///
1008 /// 一个有效的数据库连接字符串
1009 /// 命令类型 (存储过程,命令文本或其它)
1010 /// 存储过程名称或T-SQL语句
1011 /// 分配给命令的SqlParamter参数数组
1012 /// 返回结果集中的第一行第一列
1013 public static object ExecuteScalar(string connectionString, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
1014 {
1015 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
1016 // 创建并打开数据库连接对象,操作完成释放对象.
1017 using (SqlConnection connection = new SqlConnection(connectionString))
1018 {
1019 connection.Open();
1020
1021 // 调用指定数据库连接字符串重载方法.
1022 return ExecuteScalar(connection, commandType, commandText, commandParameters);
1023 }
1024 }
1025
1026 ///
1027 /// 执行指定数据库连接字符串的命令,指定参数值,返回结果集中的第一行第一列.
1028 ///
1029 ///
1030 /// 此方法不提供访问存储过程输出参数和返回值参数.
1031 ///
1032 /// 示例:
1033 /// int orderCount = (int)ExecuteScalar(connString, "GetOrderCount", 24, 36);
1034 ///
1035 /// 一个有效的数据库连接字符串
1036 /// 存储过程名称
1037 /// 分配给存储过程输入参数的对象数组
1038 /// 返回结果集中的第一行第一列
1039 public static object ExecuteScalar(string connectionString, string spName, params object[] parameterValues)
1040 {
1041 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
1042 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1043
1044 // 如果有参数值
1045 if ((parameterValues != null) && (parameterValues.Length > 0))
1046 {
1047 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
1048 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
1049
1050 // 给存储过程参数赋值
1051 AssignParameterValues(commandParameters, parameterValues);
1052
1053 // 调用重载方法
1054 return ExecuteScalar(connectionString, CommandType.StoredProcedure, spName, commandParameters);
1055 }
1056 else
1057 {
1058 // 没有参数值
1059 return ExecuteScalar(connectionString, CommandType.StoredProcedure, spName);
1060 }
1061 }
1062
1063 ///
1064 /// 执行指定数据库连接对象的命令,返回结果集中的第一行第一列.
1065 ///
1066 ///
1067 /// 示例:
1068 /// int orderCount = (int)ExecuteScalar(conn, CommandType.StoredProcedure, "GetOrderCount");
1069 ///
1070 /// 一个有效的数据库连接对象
1071 /// 命令类型 (存储过程,命令文本或其它)
1072 /// 存储过程名称或T-SQL语句
1073 /// 返回结果集中的第一行第一列
1074 public static object ExecuteScalar(SqlConnection connection, CommandType commandType, string commandText)
1075 {
1076 // 执行参数为空的方法
1077 return ExecuteScalar(connection, commandType, commandText, (SqlParameter[])null);
1078 }
1079
1080 ///
1081 /// 执行指定数据库连接对象的命令,指定参数,返回结果集中的第一行第一列.
1082 ///
1083 ///
1084 /// 示例:
1085 /// int orderCount = (int)ExecuteScalar(conn, CommandType.StoredProcedure, "GetOrderCount", new SqlParameter("@prodid", 24));
1086 ///
1087 /// 一个有效的数据库连接对象
1088 /// 命令类型 (存储过程,命令文本或其它)
1089 /// 存储过程名称或T-SQL语句
1090 /// 分配给命令的SqlParamter参数数组
1091 /// 返回结果集中的第一行第一列
1092 public static object ExecuteScalar(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
1093 {
1094 if (connection == null) throw new ArgumentNullException("connection");
1095
1096 // 创建SqlCommand命令,并进行预处理
1097 SqlCommand cmd = new SqlCommand();
1098
1099 bool mustCloseConnection = false;
1100 PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters, out mustCloseConnection);
1101
1102 // 执行SqlCommand命令,并返回结果.
1103 object retval = cmd.ExecuteScalar();
1104
1105 // 清除参数,以便再次使用.
1106 cmd.Parameters.Clear();
1107
1108 if (mustCloseConnection)
1109 connection.Close();
1110
1111 return retval;
1112 }
1113
1114 ///
1115 /// 执行指定数据库连接对象的命令,指定参数值,返回结果集中的第一行第一列.
1116 ///
1117 ///
1118 /// 此方法不提供访问存储过程输出参数和返回值参数.
1119 ///
1120 /// 示例:
1121 /// int orderCount = (int)ExecuteScalar(conn, "GetOrderCount", 24, 36);
1122 ///
1123 /// 一个有效的数据库连接对象
1124 /// 存储过程名称
1125 /// 分配给存储过程输入参数的对象数组
1126 /// 返回结果集中的第一行第一列
1127 public static object ExecuteScalar(SqlConnection connection, string spName, params object[] parameterValues)
1128 {
1129 if (connection == null) throw new ArgumentNullException("connection");
1130 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1131
1132 // 如果有参数值
1133 if ((parameterValues != null) && (parameterValues.Length > 0))
1134 {
1135 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
1136 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
1137
1138 // 给存储过程参数赋值
1139 AssignParameterValues(commandParameters, parameterValues);
1140
1141 // 调用重载方法
1142 return ExecuteScalar(connection, CommandType.StoredProcedure, spName, commandParameters);
1143 }
1144 else
1145 {
1146 // 没有参数值
1147 return ExecuteScalar(connection, CommandType.StoredProcedure, spName);
1148 }
1149 }
1150
1151 ///
1152 /// 执行指定数据库事务的命令,返回结果集中的第一行第一列.
1153 ///
1154 ///
1155 /// 示例:
1156 /// int orderCount = (int)ExecuteScalar(trans, CommandType.StoredProcedure, "GetOrderCount");
1157 ///
1158 /// 一个有效的连接事务
1159 /// 命令类型 (存储过程,命令文本或其它)
1160 /// 存储过程名称或T-SQL语句
1161 /// 返回结果集中的第一行第一列
1162 public static object ExecuteScalar(SqlTransaction transaction, CommandType commandType, string commandText)
1163 {
1164 // 执行参数为空的方法
1165 return ExecuteScalar(transaction, commandType, commandText, (SqlParameter[])null);
1166 }
1167
1168 ///
1169 /// 执行指定数据库事务的命令,指定参数,返回结果集中的第一行第一列.
1170 ///
1171 ///
1172 /// 示例:
1173 /// int orderCount = (int)ExecuteScalar(trans, CommandType.StoredProcedure, "GetOrderCount", new SqlParameter("@prodid", 24));
1174 ///
1175 /// 一个有效的连接事务
1176 /// 命令类型 (存储过程,命令文本或其它)
1177 /// 存储过程名称或T-SQL语句
1178 /// 分配给命令的SqlParamter参数数组
1179 /// 返回结果集中的第一行第一列
1180 public static object ExecuteScalar(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
1181 {
1182 if (transaction == null) throw new ArgumentNullException("transaction");
1183 if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
1184
1185 // 创建SqlCommand命令,并进行预处理
1186 SqlCommand cmd = new SqlCommand();
1187 bool mustCloseConnection = false;
1188 PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
1189
1190 // 执行SqlCommand命令,并返回结果.
1191 object retval = cmd.ExecuteScalar();
1192
1193 // 清除参数,以便再次使用.
1194 cmd.Parameters.Clear();
1195 return retval;
1196 }
1197
1198 ///
1199 /// 执行指定数据库事务的命令,指定参数值,返回结果集中的第一行第一列.
1200 ///
1201 ///
1202 /// 此方法不提供访问存储过程输出参数和返回值参数.
1203 ///
1204 /// 示例:
1205 /// int orderCount = (int)ExecuteScalar(trans, "GetOrderCount", 24, 36);
1206 ///
1207 /// 一个有效的连接事务
1208 /// 存储过程名称
1209 /// 分配给存储过程输入参数的对象数组
1210 /// 返回结果集中的第一行第一列
1211 public static object ExecuteScalar(SqlTransaction transaction, string spName, params object[] parameterValues)
1212 {
1213 if (transaction == null) throw new ArgumentNullException("transaction");
1214 if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
1215 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1216
1217 // 如果有参数值
1218 if ((parameterValues != null) && (parameterValues.Length > 0))
1219 {
1220 // PPull the parameters for this stored procedure from the parameter cache ()
1221 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
1222
1223 // 给存储过程参数赋值
1224 AssignParameterValues(commandParameters, parameterValues);
1225
1226 // 调用重载方法
1227 return ExecuteScalar(transaction, CommandType.StoredProcedure, spName, commandParameters);
1228 }
1229 else
1230 {
1231 // 没有参数值
1232 return ExecuteScalar(transaction, CommandType.StoredProcedure, spName);
1233 }
1234 }
1235
1236 #endregion ExecuteScalar
1237
1238 #region ExecuteXmlReader XML阅读器
1239 ///
1240 /// 执行指定数据库连接对象的SqlCommand命令,并产生一个XmlReader对象做为结果集返回.
1241 ///
1242 ///
1243 /// 示例:
1244 /// XmlReader r = ExecuteXmlReader(conn, CommandType.StoredProcedure, "GetOrders");
1245 ///
1246 /// 一个有效的数据库连接对象
1247 /// 命令类型 (存储过程,命令文本或其它)
1248 /// 存储过程名称或T-SQL语句 using "FOR XML AUTO"
1249 /// 返回XmlReader结果集对象.
1250 public static XmlReader ExecuteXmlReader(SqlConnection connection, CommandType commandType, string commandText)
1251 {
1252 // 执行参数为空的方法
1253 return ExecuteXmlReader(connection, commandType, commandText, (SqlParameter[])null);
1254 }
1255
1256 ///
1257 /// 执行指定数据库连接对象的SqlCommand命令,并产生一个XmlReader对象做为结果集返回,指定参数.
1258 ///
1259 ///
1260 /// 示例:
1261 /// XmlReader r = ExecuteXmlReader(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
1262 ///
1263 /// 一个有效的数据库连接对象
1264 /// 命令类型 (存储过程,命令文本或其它)
1265 /// 存储过程名称或T-SQL语句 using "FOR XML AUTO"
1266 /// 分配给命令的SqlParamter参数数组
1267 /// 返回XmlReader结果集对象.
1268 public static XmlReader ExecuteXmlReader(SqlConnection connection, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
1269 {
1270 if (connection == null) throw new ArgumentNullException("connection");
1271
1272 bool mustCloseConnection = false;
1273 // 创建SqlCommand命令,并进行预处理
1274 SqlCommand cmd = new SqlCommand();
1275 try
1276 {
1277 PrepareCommand(cmd, connection, (SqlTransaction)null, commandType, commandText, commandParameters, out mustCloseConnection);
1278
1279 // 执行命令
1280 XmlReader retval = cmd.ExecuteXmlReader();
1281
1282 // 清除参数,以便再次使用.
1283 cmd.Parameters.Clear();
1284
1285 return retval;
1286 }
1287 catch
1288 {
1289 if (mustCloseConnection)
1290 connection.Close();
1291 throw;
1292 }
1293 }
1294
1295 ///
1296 /// 执行指定数据库连接对象的SqlCommand命令,并产生一个XmlReader对象做为结果集返回,指定参数值.
1297 ///
1298 ///
1299 /// 此方法不提供访问存储过程输出参数和返回值参数.
1300 ///
1301 /// 示例:
1302 /// XmlReader r = ExecuteXmlReader(conn, "GetOrders", 24, 36);
1303 ///
1304 /// 一个有效的数据库连接对象
1305 /// 存储过程名称 using "FOR XML AUTO"
1306 /// 分配给存储过程输入参数的对象数组
1307 /// 返回XmlReader结果集对象.
1308 public static XmlReader ExecuteXmlReader(SqlConnection connection, string spName, params object[] parameterValues)
1309 {
1310 if (connection == null) throw new ArgumentNullException("connection");
1311 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1312
1313 // 如果有参数值
1314 if ((parameterValues != null) && (parameterValues.Length > 0))
1315 {
1316 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
1317 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
1318
1319 // 给存储过程参数赋值
1320 AssignParameterValues(commandParameters, parameterValues);
1321
1322 // 调用重载方法
1323 return ExecuteXmlReader(connection, CommandType.StoredProcedure, spName, commandParameters);
1324 }
1325 else
1326 {
1327 // 没有参数值
1328 return ExecuteXmlReader(connection, CommandType.StoredProcedure, spName);
1329 }
1330 }
1331
1332 ///
1333 /// 执行指定数据库事务的SqlCommand命令,并产生一个XmlReader对象做为结果集返回.
1334 ///
1335 ///
1336 /// 示例:
1337 /// XmlReader r = ExecuteXmlReader(trans, CommandType.StoredProcedure, "GetOrders");
1338 ///
1339 /// 一个有效的连接事务
1340 /// 命令类型 (存储过程,命令文本或其它)
1341 /// 存储过程名称或T-SQL语句 using "FOR XML AUTO"
1342 /// 返回XmlReader结果集对象.
1343 public static XmlReader ExecuteXmlReader(SqlTransaction transaction, CommandType commandType, string commandText)
1344 {
1345 // 执行参数为空的方法
1346 return ExecuteXmlReader(transaction, commandType, commandText, (SqlParameter[])null);
1347 }
1348
1349 ///
1350 /// 执行指定数据库事务的SqlCommand命令,并产生一个XmlReader对象做为结果集返回,指定参数.
1351 ///
1352 ///
1353 /// 示例:
1354 /// XmlReader r = ExecuteXmlReader(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
1355 ///
1356 /// 一个有效的连接事务
1357 /// 命令类型 (存储过程,命令文本或其它)
1358 /// 存储过程名称或T-SQL语句 using "FOR XML AUTO"
1359 /// 分配给命令的SqlParamter参数数组
1360 /// 返回XmlReader结果集对象.
1361 public static XmlReader ExecuteXmlReader(SqlTransaction transaction, CommandType commandType, string commandText, params SqlParameter[] commandParameters)
1362 {
1363 if (transaction == null) throw new ArgumentNullException("transaction");
1364 if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
1365
1366 // 创建SqlCommand命令,并进行预处理
1367 SqlCommand cmd = new SqlCommand();
1368 bool mustCloseConnection = false;
1369 PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
1370
1371 // 执行命令
1372 XmlReader retval = cmd.ExecuteXmlReader();
1373
1374 // 清除参数,以便再次使用.
1375 cmd.Parameters.Clear();
1376 return retval;
1377 }
1378
1379 ///
1380 /// 执行指定数据库事务的SqlCommand命令,并产生一个XmlReader对象做为结果集返回,指定参数值.
1381 ///
1382 ///
1383 /// 此方法不提供访问存储过程输出参数和返回值参数.
1384 ///
1385 /// 示例:
1386 /// XmlReader r = ExecuteXmlReader(trans, "GetOrders", 24, 36);
1387 ///
1388 /// 一个有效的连接事务
1389 /// 存储过程名称
1390 /// 分配给存储过程输入参数的对象数组
1391 /// 返回一个包含结果集的DataSet.
1392 public static XmlReader ExecuteXmlReader(SqlTransaction transaction, string spName, params object[] parameterValues)
1393 {
1394 if (transaction == null) throw new ArgumentNullException("transaction");
1395 if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
1396 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1397
1398 // 如果有参数值
1399 if ((parameterValues != null) && (parameterValues.Length > 0))
1400 {
1401 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
1402 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
1403
1404 // 给存储过程参数赋值
1405 AssignParameterValues(commandParameters, parameterValues);
1406
1407 // 调用重载方法
1408 return ExecuteXmlReader(transaction, CommandType.StoredProcedure, spName, commandParameters);
1409 }
1410 else
1411 {
1412 // 没有参数值
1413 return ExecuteXmlReader(transaction, CommandType.StoredProcedure, spName);
1414 }
1415 }
1416
1417 #endregion ExecuteXmlReader 阅读器结束
1418
1419 #region FillDataset 填充数据集
1420 ///
1421 /// 执行指定数据库连接字符串的命令,映射数据表并填充数据集.
1422 ///
1423 ///
1424 /// 示例:
1425 /// FillDataset(connString, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"});
1426 ///
1427 /// 一个有效的数据库连接字符串
1428 /// 命令类型 (存储过程,命令文本或其它)
1429 /// 存储过程名称或T-SQL语句
1430 /// 要填充结果集的DataSet实例
1431 /// 表映射的数据表数组
1432 /// 用户定义的表名 (可有是实际的表名.)
1433 public static void FillDataset(string connectionString, CommandType commandType, string commandText, DataSet dataSet, string[] tableNames)
1434 {
1435 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
1436 if (dataSet == null) throw new ArgumentNullException("dataSet");
1437
1438 // 创建并打开数据库连接对象,操作完成释放对象.
1439 using (SqlConnection connection = new SqlConnection(connectionString))
1440 {
1441 connection.Open();
1442
1443 // 调用指定数据库连接字符串重载方法.
1444 FillDataset(connection, commandType, commandText, dataSet, tableNames);
1445 }
1446 }
1447
1448 ///
1449 /// 执行指定数据库连接字符串的命令,映射数据表并填充数据集.指定命令参数.
1450 ///
1451 ///
1452 /// 示例:
1453 /// FillDataset(connString, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, new SqlParameter("@prodid", 24));
1454 ///
1455 /// 一个有效的数据库连接字符串
1456 /// 命令类型 (存储过程,命令文本或其它)
1457 /// 存储过程名称或T-SQL语句
1458 /// 分配给命令的SqlParamter参数数组
1459 /// 要填充结果集的DataSet实例
1460 /// 表映射的数据表数组
1461 /// 用户定义的表名 (可有是实际的表名.)
1462 ///
1463 public static void FillDataset(string connectionString, CommandType commandType,
1464 string commandText, DataSet dataSet, string[] tableNames,
1465 params SqlParameter[] commandParameters)
1466 {
1467 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
1468 if (dataSet == null) throw new ArgumentNullException("dataSet");
1469 // 创建并打开数据库连接对象,操作完成释放对象.
1470 using (SqlConnection connection = new SqlConnection(connectionString))
1471 {
1472 connection.Open();
1473
1474 // 调用指定数据库连接字符串重载方法.
1475 FillDataset(connection, commandType, commandText, dataSet, tableNames, commandParameters);
1476 }
1477 }
1478
1479 ///
1480 /// 执行指定数据库连接字符串的命令,映射数据表并填充数据集,指定存储过程参数值.
1481 ///
1482 ///
1483 /// 此方法不提供访问存储过程输出参数和返回值参数.
1484 ///
1485 /// 示例:
1486 /// FillDataset(connString, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, 24);
1487 ///
1488 /// 一个有效的数据库连接字符串
1489 /// 存储过程名称
1490 /// 要填充结果集的DataSet实例
1491 /// 表映射的数据表数组
1492 /// 用户定义的表名 (可有是实际的表名.)
1493 ///
1494 /// 分配给存储过程输入参数的对象数组
1495 public static void FillDataset(string connectionString, string spName,
1496 DataSet dataSet, string[] tableNames,
1497 params object[] parameterValues)
1498 {
1499 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
1500 if (dataSet == null) throw new ArgumentNullException("dataSet");
1501 // 创建并打开数据库连接对象,操作完成释放对象.
1502 using (SqlConnection connection = new SqlConnection(connectionString))
1503 {
1504 connection.Open();
1505
1506 // 调用指定数据库连接字符串重载方法.
1507 FillDataset(connection, spName, dataSet, tableNames, parameterValues);
1508 }
1509 }
1510
1511 ///
1512 /// 执行指定数据库连接对象的命令,映射数据表并填充数据集.
1513 ///
1514 ///
1515 /// 示例:
1516 /// FillDataset(conn, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"});
1517 ///
1518 /// 一个有效的数据库连接对象
1519 /// 命令类型 (存储过程,命令文本或其它)
1520 /// 存储过程名称或T-SQL语句
1521 /// 要填充结果集的DataSet实例
1522 /// 表映射的数据表数组
1523 /// 用户定义的表名 (可有是实际的表名.)
1524 ///
1525 public static void FillDataset(SqlConnection connection, CommandType commandType,
1526 string commandText, DataSet dataSet, string[] tableNames)
1527 {
1528 FillDataset(connection, commandType, commandText, dataSet, tableNames, null);
1529 }
1530
1531 ///
1532 /// 执行指定数据库连接对象的命令,映射数据表并填充数据集,指定参数.
1533 ///
1534 ///
1535 /// 示例:
1536 /// FillDataset(conn, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, new SqlParameter("@prodid", 24));
1537 ///
1538 /// 一个有效的数据库连接对象
1539 /// 命令类型 (存储过程,命令文本或其它)
1540 /// 存储过程名称或T-SQL语句
1541 /// 要填充结果集的DataSet实例
1542 /// 表映射的数据表数组
1543 /// 用户定义的表名 (可有是实际的表名.)
1544 ///
1545 /// 分配给命令的SqlParamter参数数组
1546 public static void FillDataset(SqlConnection connection, CommandType commandType,
1547 string commandText, DataSet dataSet, string[] tableNames,
1548 params SqlParameter[] commandParameters)
1549 {
1550 FillDataset(connection, null, commandType, commandText, dataSet, tableNames, commandParameters);
1551 }
1552
1553 ///
1554 /// 执行指定数据库连接对象的命令,映射数据表并填充数据集,指定存储过程参数值.
1555 ///
1556 ///
1557 /// 此方法不提供访问存储过程输出参数和返回值参数.
1558 ///
1559 /// 示例:
1560 /// FillDataset(conn, "GetOrders", ds, new string[] {"orders"}, 24, 36);
1561 ///
1562 /// 一个有效的数据库连接对象
1563 /// 存储过程名称
1564 /// 要填充结果集的DataSet实例
1565 /// 表映射的数据表数组
1566 /// 用户定义的表名 (可有是实际的表名.)
1567 ///
1568 /// 分配给存储过程输入参数的对象数组
1569 public static void FillDataset(SqlConnection connection, string spName,
1570 DataSet dataSet, string[] tableNames,
1571 params object[] parameterValues)
1572 {
1573 if (connection == null) throw new ArgumentNullException("connection");
1574 if (dataSet == null) throw new ArgumentNullException("dataSet");
1575 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1576
1577 // 如果有参数值
1578 if ((parameterValues != null) && (parameterValues.Length > 0))
1579 {
1580 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
1581 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
1582
1583 // 给存储过程参数赋值
1584 AssignParameterValues(commandParameters, parameterValues);
1585
1586 // 调用重载方法
1587 FillDataset(connection, CommandType.StoredProcedure, spName, dataSet, tableNames, commandParameters);
1588 }
1589 else
1590 {
1591 // 没有参数值
1592 FillDataset(connection, CommandType.StoredProcedure, spName, dataSet, tableNames);
1593 }
1594 }
1595
1596 ///
1597 /// 执行指定数据库事务的命令,映射数据表并填充数据集.
1598 ///
1599 ///
1600 /// 示例:
1601 /// FillDataset(trans, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"});
1602 ///
1603 /// 一个有效的连接事务
1604 /// 命令类型 (存储过程,命令文本或其它)
1605 /// 存储过程名称或T-SQL语句
1606 /// 要填充结果集的DataSet实例
1607 /// 表映射的数据表数组
1608 /// 用户定义的表名 (可有是实际的表名.)
1609 ///
1610 public static void FillDataset(SqlTransaction transaction, CommandType commandType,
1611 string commandText,
1612 DataSet dataSet, string[] tableNames)
1613 {
1614 FillDataset(transaction, commandType, commandText, dataSet, tableNames, null);
1615 }
1616
1617 ///
1618 /// 执行指定数据库事务的命令,映射数据表并填充数据集,指定参数.
1619 ///
1620 ///
1621 /// 示例:
1622 /// FillDataset(trans, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, new SqlParameter("@prodid", 24));
1623 ///
1624 /// 一个有效的连接事务
1625 /// 命令类型 (存储过程,命令文本或其它)
1626 /// 存储过程名称或T-SQL语句
1627 /// 要填充结果集的DataSet实例
1628 /// 表映射的数据表数组
1629 /// 用户定义的表名 (可有是实际的表名.)
1630 ///
1631 /// 分配给命令的SqlParamter参数数组
1632 public static void FillDataset(SqlTransaction transaction, CommandType commandType,
1633 string commandText, DataSet dataSet, string[] tableNames,
1634 params SqlParameter[] commandParameters)
1635 {
1636 FillDataset(transaction.Connection, transaction, commandType, commandText, dataSet, tableNames, commandParameters);
1637 }
1638
1639 ///
1640 /// 执行指定数据库事务的命令,映射数据表并填充数据集,指定存储过程参数值.
1641 ///
1642 ///
1643 /// 此方法不提供访问存储过程输出参数和返回值参数.
1644 ///
1645 /// 示例:
1646 /// FillDataset(trans, "GetOrders", ds, new string[]{"orders"}, 24, 36);
1647 ///
1648 /// 一个有效的连接事务
1649 /// 存储过程名称
1650 /// 要填充结果集的DataSet实例
1651 /// 表映射的数据表数组
1652 /// 用户定义的表名 (可有是实际的表名.)
1653 ///
1654 /// 分配给存储过程输入参数的对象数组
1655 public static void FillDataset(SqlTransaction transaction, string spName,
1656 DataSet dataSet, string[] tableNames,
1657 params object[] parameterValues)
1658 {
1659 if (transaction == null) throw new ArgumentNullException("transaction");
1660 if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
1661 if (dataSet == null) throw new ArgumentNullException("dataSet");
1662 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1663
1664 // 如果有参数值
1665 if ((parameterValues != null) && (parameterValues.Length > 0))
1666 {
1667 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
1668 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
1669
1670 // 给存储过程参数赋值
1671 AssignParameterValues(commandParameters, parameterValues);
1672
1673 // 调用重载方法
1674 FillDataset(transaction, CommandType.StoredProcedure, spName, dataSet, tableNames, commandParameters);
1675 }
1676 else
1677 {
1678 // 没有参数值
1679 FillDataset(transaction, CommandType.StoredProcedure, spName, dataSet, tableNames);
1680 }
1681 }
1682
1683 ///
1684 /// [私有方法][内部调用]执行指定数据库连接对象/事务的命令,映射数据表并填充数据集,DataSet/TableNames/SqlParameters.
1685 ///
1686 ///
1687 /// 示例:
1688 /// FillDataset(conn, trans, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, new SqlParameter("@prodid", 24));
1689 ///
1690 /// 一个有效的数据库连接对象
1691 /// 一个有效的连接事务
1692 /// 命令类型 (存储过程,命令文本或其它)
1693 /// 存储过程名称或T-SQL语句
1694 /// 要填充结果集的DataSet实例
1695 /// 表映射的数据表数组
1696 /// 用户定义的表名 (可有是实际的表名.)
1697 ///
1698 /// 分配给命令的SqlParamter参数数组
1699 private static void FillDataset(SqlConnection connection, SqlTransaction transaction, CommandType commandType,
1700 string commandText, DataSet dataSet, string[] tableNames,
1701 params SqlParameter[] commandParameters)
1702 {
1703 if (connection == null) throw new ArgumentNullException("connection");
1704 if (dataSet == null) throw new ArgumentNullException("dataSet");
1705
1706 // 创建SqlCommand命令,并进行预处理
1707 SqlCommand command = new SqlCommand();
1708 bool mustCloseConnection = false;
1709 PrepareCommand(command, connection, transaction, commandType, commandText, commandParameters, out mustCloseConnection);
1710
1711 // 执行命令
1712 using (SqlDataAdapter dataAdapter = new SqlDataAdapter(command))
1713 {
1714
1715 // 追加表映射
1716 if (tableNames != null && tableNames.Length > 0)
1717 {
1718 string tableName = "Table";
1719 for (int index = 0; index < tableNames.Length; index++)
1720 {
1721 if (tableNames[index] == null || tableNames[index].Length == 0) throw new ArgumentException("The tableNames parameter must contain a list of tables, a value was provided as null or empty string.", "tableNames");
1722 dataAdapter.TableMappings.Add(tableName, tableNames[index]);
1723 tableName += (index + 1).ToString();
1724 }
1725 }
1726
1727 // 填充数据集使用默认表名称
1728 dataAdapter.Fill(dataSet);
1729
1730 // 清除参数,以便再次使用.
1731 command.Parameters.Clear();
1732 }
1733
1734 if (mustCloseConnection)
1735 connection.Close();
1736 }
1737 #endregion
1738
1739 #region UpdateDataset 更新数据集
1740 ///
1741 /// 执行数据集更新到数据库,指定inserted, updated, or deleted命令.
1742 ///
1743 ///
1744 /// 示例:
1745 /// UpdateDataset(conn, insertCommand, deleteCommand, updateCommand, dataSet, "Order");
1746 ///
1747 /// [追加记录]一个有效的T-SQL语句或存储过程
1748 /// [删除记录]一个有效的T-SQL语句或存储过程
1749 /// [更新记录]一个有效的T-SQL语句或存储过程
1750 /// 要更新到数据库的DataSet
1751 /// 要更新到数据库的DataTable
1752 public static void UpdateDataset(SqlCommand insertCommand, SqlCommand deleteCommand, SqlCommand updateCommand, DataSet dataSet, string tableName)
1753 {
1754 if (insertCommand == null) throw new ArgumentNullException("insertCommand");
1755 if (deleteCommand == null) throw new ArgumentNullException("deleteCommand");
1756 if (updateCommand == null) throw new ArgumentNullException("updateCommand");
1757 if (tableName == null || tableName.Length == 0) throw new ArgumentNullException("tableName");
1758
1759 // 创建SqlDataAdapter,当操作完成后释放.
1760 using (SqlDataAdapter dataAdapter = new SqlDataAdapter())
1761 {
1762 // 设置数据适配器命令
1763 dataAdapter.UpdateCommand = updateCommand;
1764 dataAdapter.InsertCommand = insertCommand;
1765 dataAdapter.DeleteCommand = deleteCommand;
1766
1767 // 更新数据集改变到数据库
1768 dataAdapter.Update(dataSet, tableName);
1769
1770 // 提交所有改变到数据集.
1771 dataSet.AcceptChanges();
1772 }
1773 }
1774 #endregion
1775
1776 #region CreateCommand 创建一条SqlCommand命令
1777 ///
1778 /// 创建SqlCommand命令,指定数据库连接对象,存储过程名和参数.
1779 ///
1780 ///
1781 /// 示例:
1782 /// SqlCommand command = CreateCommand(conn, "AddCustomer", "CustomerID", "CustomerName");
1783 ///
1784 /// 一个有效的数据库连接对象
1785 /// 存储过程名称
1786 /// 源表的列名称数组
1787 /// 返回SqlCommand命令
1788 public static SqlCommand CreateCommand(SqlConnection connection, string spName, params string[] sourceColumns)
1789 {
1790 if (connection == null) throw new ArgumentNullException("connection");
1791 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1792
1793 // 创建命令
1794 SqlCommand cmd = new SqlCommand(spName, connection);
1795 cmd.CommandType = CommandType.StoredProcedure;
1796
1797 // 如果有参数值
1798 if ((sourceColumns != null) && (sourceColumns.Length > 0))
1799 {
1800 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
1801 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
1802
1803 // 将源表的列到映射到DataSet命令中.
1804 for (int index = 0; index < sourceColumns.Length; index++)
1805 commandParameters[index].SourceColumn = sourceColumns[index];
1806
1807 // Attach the discovered parameters to the SqlCommand object
1808 AttachParameters(cmd, commandParameters);
1809 }
1810
1811 return cmd;
1812 }
1813 #endregion
1814
1815 #region ExecuteNonQueryTypedParams 类型化参数(DataRow)
1816 ///
1817 /// 执行指定连接数据库连接字符串的存储过程,使用DataRow做为参数值,返回受影响的行数.
1818 ///
1819 /// 一个有效的数据库连接字符串
1820 /// 存储过程名称
1821 /// 使用DataRow作为参数值
1822 /// 返回影响的行数
1823 public static int ExecuteNonQueryTypedParams(String connectionString, String spName, DataRow dataRow)
1824 {
1825 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
1826 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1827
1828 // 如果row有值,存储过程必须初始化.
1829 if (dataRow != null && dataRow.ItemArray.Length > 0)
1830 {
1831 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
1832 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
1833
1834 // 分配参数值
1835 AssignParameterValues(commandParameters, dataRow);
1836
1837 return SqlHelper.ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName, commandParameters);
1838 }
1839 else
1840 {
1841 return SqlHelper.ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName);
1842 }
1843 }
1844
1845 ///
1846 /// 执行指定连接数据库连接对象的存储过程,使用DataRow做为参数值,返回受影响的行数.
1847 ///
1848 /// 一个有效的数据库连接对象
1849 /// 存储过程名称
1850 /// 使用DataRow作为参数值
1851 /// 返回影响的行数
1852 public static int ExecuteNonQueryTypedParams(SqlConnection connection, String spName, DataRow dataRow)
1853 {
1854 if (connection == null) throw new ArgumentNullException("connection");
1855 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1856
1857 // 如果row有值,存储过程必须初始化.
1858 if (dataRow != null && dataRow.ItemArray.Length > 0)
1859 {
1860 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
1861 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
1862
1863 // 分配参数值
1864 AssignParameterValues(commandParameters, dataRow);
1865
1866 return SqlHelper.ExecuteNonQuery(connection, CommandType.StoredProcedure, spName, commandParameters);
1867 }
1868 else
1869 {
1870 return SqlHelper.ExecuteNonQuery(connection, CommandType.StoredProcedure, spName);
1871 }
1872 }
1873
1874 ///
1875 /// 执行指定连接数据库事物的存储过程,使用DataRow做为参数值,返回受影响的行数.
1876 ///
1877 /// 一个有效的连接事务 object
1878 /// 存储过程名称
1879 /// 使用DataRow作为参数值
1880 /// 返回影响的行数
1881 public static int ExecuteNonQueryTypedParams(SqlTransaction transaction, String spName, DataRow dataRow)
1882 {
1883 if (transaction == null) throw new ArgumentNullException("transaction");
1884 if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
1885 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1886
1887 // Sf the row has values, the store procedure parameters must be initialized
1888 if (dataRow != null && dataRow.ItemArray.Length > 0)
1889 {
1890 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
1891 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
1892
1893 // 分配参数值
1894 AssignParameterValues(commandParameters, dataRow);
1895
1896 return SqlHelper.ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName, commandParameters);
1897 }
1898 else
1899 {
1900 return SqlHelper.ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName);
1901 }
1902 }
1903 #endregion
1904
1905 #region ExecuteDatasetTypedParams 类型化参数(DataRow)
1906 ///
1907 /// 执行指定连接数据库连接字符串的存储过程,使用DataRow做为参数值,返回DataSet.
1908 ///
1909 /// 一个有效的数据库连接字符串
1910 /// 存储过程名称
1911 /// 使用DataRow作为参数值
1912 /// 返回一个包含结果集的DataSet.
1913 public static DataSet ExecuteDatasetTypedParams(string connectionString, String spName, DataRow dataRow)
1914 {
1915 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
1916 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1917
1918 //如果row有值,存储过程必须初始化.
1919 if (dataRow != null && dataRow.ItemArray.Length > 0)
1920 {
1921 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
1922 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
1923
1924 // 分配参数值
1925 AssignParameterValues(commandParameters, dataRow);
1926
1927 return SqlHelper.ExecuteDataset(connectionString, CommandType.StoredProcedure, spName, commandParameters);
1928 }
1929 else
1930 {
1931 return SqlHelper.ExecuteDataset(connectionString, CommandType.StoredProcedure, spName);
1932 }
1933 }
1934
1935 ///
1936 /// 执行指定连接数据库连接对象的存储过程,使用DataRow做为参数值,返回DataSet.
1937 ///
1938 /// 一个有效的数据库连接对象
1939 /// 存储过程名称
1940 /// 使用DataRow作为参数值
1941 /// 返回一个包含结果集的DataSet.
1942 ///
1943 public static DataSet ExecuteDatasetTypedParams(SqlConnection connection, String spName, DataRow dataRow)
1944 {
1945 if (connection == null) throw new ArgumentNullException("connection");
1946 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1947
1948 // 如果row有值,存储过程必须初始化.
1949 if (dataRow != null && dataRow.ItemArray.Length > 0)
1950 {
1951 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
1952 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
1953
1954 // 分配参数值
1955 AssignParameterValues(commandParameters, dataRow);
1956
1957 return SqlHelper.ExecuteDataset(connection, CommandType.StoredProcedure, spName, commandParameters);
1958 }
1959 else
1960 {
1961 return SqlHelper.ExecuteDataset(connection, CommandType.StoredProcedure, spName);
1962 }
1963 }
1964
1965 ///
1966 /// 执行指定连接数据库事务的存储过程,使用DataRow做为参数值,返回DataSet.
1967 ///
1968 /// 一个有效的连接事务 object
1969 /// 存储过程名称
1970 /// 使用DataRow作为参数值
1971 /// 返回一个包含结果集的DataSet.
1972 public static DataSet ExecuteDatasetTypedParams(SqlTransaction transaction, String spName, DataRow dataRow)
1973 {
1974 if (transaction == null) throw new ArgumentNullException("transaction");
1975 if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
1976 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
1977
1978 // 如果row有值,存储过程必须初始化.
1979 if (dataRow != null && dataRow.ItemArray.Length > 0)
1980 {
1981 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
1982 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
1983
1984 // 分配参数值
1985 AssignParameterValues(commandParameters, dataRow);
1986
1987 return SqlHelper.ExecuteDataset(transaction, CommandType.StoredProcedure, spName, commandParameters);
1988 }
1989 else
1990 {
1991 return SqlHelper.ExecuteDataset(transaction, CommandType.StoredProcedure, spName);
1992 }
1993 }
1994
1995 #endregion
1996
1997 #region ExecuteReaderTypedParams 类型化参数(DataRow)
1998 ///
1999 /// 执行指定连接数据库连接字符串的存储过程,使用DataRow做为参数值,返回DataReader.
2000 ///
2001 /// 一个有效的数据库连接字符串
2002 /// 存储过程名称
2003 /// 使用DataRow作为参数值
2004 /// 返回包含结果集的SqlDataReader
2005 public static SqlDataReader ExecuteReaderTypedParams(String connectionString, String spName, DataRow dataRow)
2006 {
2007 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
2008 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
2009
2010 // 如果row有值,存储过程必须初始化.
2011 if (dataRow != null && dataRow.ItemArray.Length > 0)
2012 {
2013 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
2014 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
2015
2016 // 分配参数值
2017 AssignParameterValues(commandParameters, dataRow);
2018
2019 return SqlHelper.ExecuteReader(connectionString, CommandType.StoredProcedure, spName, commandParameters);
2020 }
2021 else
2022 {
2023 return SqlHelper.ExecuteReader(connectionString, CommandType.StoredProcedure, spName);
2024 }
2025 }
2026
2027
2028 ///
2029 /// 执行指定连接数据库连接对象的存储过程,使用DataRow做为参数值,返回DataReader.
2030 ///
2031 /// 一个有效的数据库连接对象
2032 /// 存储过程名称
2033 /// 使用DataRow作为参数值
2034 /// 返回包含结果集的SqlDataReader
2035 public static SqlDataReader ExecuteReaderTypedParams(SqlConnection connection, String spName, DataRow dataRow)
2036 {
2037 if (connection == null) throw new ArgumentNullException("connection");
2038 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
2039
2040 // 如果row有值,存储过程必须初始化.
2041 if (dataRow != null && dataRow.ItemArray.Length > 0)
2042 {
2043 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
2044 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
2045
2046 // 分配参数值
2047 AssignParameterValues(commandParameters, dataRow);
2048
2049 return SqlHelper.ExecuteReader(connection, CommandType.StoredProcedure, spName, commandParameters);
2050 }
2051 else
2052 {
2053 return SqlHelper.ExecuteReader(connection, CommandType.StoredProcedure, spName);
2054 }
2055 }
2056
2057 ///
2058 /// 执行指定连接数据库事物的存储过程,使用DataRow做为参数值,返回DataReader.
2059 ///
2060 /// 一个有效的连接事务 object
2061 /// 存储过程名称
2062 /// 使用DataRow作为参数值
2063 /// 返回包含结果集的SqlDataReader
2064 public static SqlDataReader ExecuteReaderTypedParams(SqlTransaction transaction, String spName, DataRow dataRow)
2065 {
2066 if (transaction == null) throw new ArgumentNullException("transaction");
2067 if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
2068 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
2069
2070 // 如果row有值,存储过程必须初始化.
2071 if (dataRow != null && dataRow.ItemArray.Length > 0)
2072 {
2073 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
2074 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
2075
2076 // 分配参数值
2077 AssignParameterValues(commandParameters, dataRow);
2078
2079 return SqlHelper.ExecuteReader(transaction, CommandType.StoredProcedure, spName, commandParameters);
2080 }
2081 else
2082 {
2083 return SqlHelper.ExecuteReader(transaction, CommandType.StoredProcedure, spName);
2084 }
2085 }
2086 #endregion
2087
2088 #region ExecuteScalarTypedParams 类型化参数(DataRow)
2089 ///
2090 /// 执行指定连接数据库连接字符串的存储过程,使用DataRow做为参数值,返回结果集中的第一行第一列.
2091 ///
2092 /// 一个有效的数据库连接字符串
2093 /// 存储过程名称
2094 /// 使用DataRow作为参数值
2095 /// 返回结果集中的第一行第一列
2096 public static object ExecuteScalarTypedParams(String connectionString, String spName, DataRow dataRow)
2097 {
2098 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
2099 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
2100
2101 // 如果row有值,存储过程必须初始化.
2102 if (dataRow != null && dataRow.ItemArray.Length > 0)
2103 {
2104 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
2105 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
2106
2107 // 分配参数值
2108 AssignParameterValues(commandParameters, dataRow);
2109
2110 return SqlHelper.ExecuteScalar(connectionString, CommandType.StoredProcedure, spName, commandParameters);
2111 }
2112 else
2113 {
2114 return SqlHelper.ExecuteScalar(connectionString, CommandType.StoredProcedure, spName);
2115 }
2116 }
2117
2118 ///
2119 /// 执行指定连接数据库连接对象的存储过程,使用DataRow做为参数值,返回结果集中的第一行第一列.
2120 ///
2121 /// 一个有效的数据库连接对象
2122 /// 存储过程名称
2123 /// 使用DataRow作为参数值
2124 /// 返回结果集中的第一行第一列
2125 public static object ExecuteScalarTypedParams(SqlConnection connection, String spName, DataRow dataRow)
2126 {
2127 if (connection == null) throw new ArgumentNullException("connection");
2128 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
2129
2130 // 如果row有值,存储过程必须初始化.
2131 if (dataRow != null && dataRow.ItemArray.Length > 0)
2132 {
2133 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
2134 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
2135
2136 // 分配参数值
2137 AssignParameterValues(commandParameters, dataRow);
2138
2139 return SqlHelper.ExecuteScalar(connection, CommandType.StoredProcedure, spName, commandParameters);
2140 }
2141 else
2142 {
2143 return SqlHelper.ExecuteScalar(connection, CommandType.StoredProcedure, spName);
2144 }
2145 }
2146
2147 ///
2148 /// 执行指定连接数据库事务的存储过程,使用DataRow做为参数值,返回结果集中的第一行第一列.
2149 ///
2150 /// 一个有效的连接事务 object
2151 /// 存储过程名称
2152 /// 使用DataRow作为参数值
2153 /// 返回结果集中的第一行第一列
2154 public static object ExecuteScalarTypedParams(SqlTransaction transaction, String spName, DataRow dataRow)
2155 {
2156 if (transaction == null) throw new ArgumentNullException("transaction");
2157 if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
2158 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
2159
2160 // 如果row有值,存储过程必须初始化.
2161 if (dataRow != null && dataRow.ItemArray.Length > 0)
2162 {
2163 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
2164 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
2165
2166 // 分配参数值
2167 AssignParameterValues(commandParameters, dataRow);
2168
2169 return SqlHelper.ExecuteScalar(transaction, CommandType.StoredProcedure, spName, commandParameters);
2170 }
2171 else
2172 {
2173 return SqlHelper.ExecuteScalar(transaction, CommandType.StoredProcedure, spName);
2174 }
2175 }
2176 #endregion
2177
2178 #region ExecuteXmlReaderTypedParams 类型化参数(DataRow)
2179 ///
2180 /// 执行指定连接数据库连接对象的存储过程,使用DataRow做为参数值,返回XmlReader类型的结果集.
2181 ///
2182 /// 一个有效的数据库连接对象
2183 /// 存储过程名称
2184 /// 使用DataRow作为参数值
2185 /// 返回XmlReader结果集对象.
2186 public static XmlReader ExecuteXmlReaderTypedParams(SqlConnection connection, String spName, DataRow dataRow)
2187 {
2188 if (connection == null) throw new ArgumentNullException("connection");
2189 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
2190
2191 // 如果row有值,存储过程必须初始化.
2192 if (dataRow != null && dataRow.ItemArray.Length > 0)
2193 {
2194 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
2195 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(connection, spName);
2196
2197 // 分配参数值
2198 AssignParameterValues(commandParameters, dataRow);
2199
2200 return SqlHelper.ExecuteXmlReader(connection, CommandType.StoredProcedure, spName, commandParameters);
2201 }
2202 else
2203 {
2204 return SqlHelper.ExecuteXmlReader(connection, CommandType.StoredProcedure, spName);
2205 }
2206 }
2207
2208 ///
2209 /// 执行指定连接数据库事务的存储过程,使用DataRow做为参数值,返回XmlReader类型的结果集.
2210 ///
2211 /// 一个有效的连接事务 object
2212 /// 存储过程名称
2213 /// 使用DataRow作为参数值
2214 /// 返回XmlReader结果集对象.
2215 public static XmlReader ExecuteXmlReaderTypedParams(SqlTransaction transaction, String spName, DataRow dataRow)
2216 {
2217 if (transaction == null) throw new ArgumentNullException("transaction");
2218 if (transaction != null && transaction.Connection == null) throw new ArgumentException("The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
2219 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
2220
2221 // 如果row有值,存储过程必须初始化.
2222 if (dataRow != null && dataRow.ItemArray.Length > 0)
2223 {
2224 // 从缓存中加载存储过程参数,如果缓存中不存在则从数据库中检索参数信息并加载到缓存中. ()
2225 SqlParameter[] commandParameters = SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
2226
2227 // 分配参数值
2228 AssignParameterValues(commandParameters, dataRow);
2229
2230 return SqlHelper.ExecuteXmlReader(transaction, CommandType.StoredProcedure, spName, commandParameters);
2231 }
2232 else
2233 {
2234 return SqlHelper.ExecuteXmlReader(transaction, CommandType.StoredProcedure, spName);
2235 }
2236 }
2237 #endregion
2238
2239 }
2240
2241 ///
2242 /// SqlHelperParameterCache提供缓存存储过程参数,并能够在运行时从存储过程中探索参数.
2243 ///
2244 public sealed class SqlHelperParameterCache
2245 {
2246 #region 私有方法,字段,构造函数
2247 // 私有构造函数,妨止类被实例化.
2248 private SqlHelperParameterCache() { }
2249
2250 // 这个方法要注意
2251 private static Hashtable paramCache = Hashtable.Synchronized(new Hashtable());
2252
2253 ///
2254 /// 探索运行时的存储过程,返回SqlParameter参数数组.
2255 /// 初始化参数值为 DBNull.Value.
2256 ///
2257 /// 一个有效的数据库连接
2258 /// 存储过程名称
2259 /// 是否包含返回值参数
2260 /// 返回SqlParameter参数数组
2261 private static SqlParameter[] DiscoverSpParameterSet(SqlConnection connection, string spName, bool includeReturnValueParameter)
2262 {
2263 if (connection == null) throw new ArgumentNullException("connection");
2264 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
2265
2266 SqlCommand cmd = new SqlCommand(spName, connection);
2267 cmd.CommandType = CommandType.StoredProcedure;
2268
2269 connection.Open();
2270 // 检索cmd指定的存储过程的参数信息,并填充到cmd的Parameters参数集中.
2271 SqlCommandBuilder.DeriveParameters(cmd);
2272 connection.Close();
2273 // 如果不包含返回值参数,将参数集中的每一个参数删除.
2274 if (!includeReturnValueParameter)
2275 {
2276 cmd.Parameters.RemoveAt(0);
2277 }
2278
2279 // 创建参数数组
2280 SqlParameter[] discoveredParameters = new SqlParameter[cmd.Parameters.Count];
2281 // 将cmd的Parameters参数集复制到discoveredParameters数组.
2282 cmd.Parameters.CopyTo(discoveredParameters, 0);
2283
2284 // 初始化参数值为 DBNull.Value.
2285 foreach (SqlParameter discoveredParameter in discoveredParameters)
2286 {
2287 discoveredParameter.Value = DBNull.Value;
2288 }
2289 return discoveredParameters;
2290 }
2291
2292 ///
2293 /// SqlParameter参数数组的深层拷贝.
2294 ///
2295 /// 原始参数数组
2296 /// 返回一个同样的参数数组
2297 private static SqlParameter[] CloneParameters(SqlParameter[] originalParameters)
2298 {
2299 SqlParameter[] clonedParameters = new SqlParameter[originalParameters.Length];
2300
2301 for (int i = 0, j = originalParameters.Length; i < j; i++)
2302 {
2303 clonedParameters[i] = (SqlParameter)((ICloneable)originalParameters[i]).Clone();
2304 }
2305
2306 return clonedParameters;
2307 }
2308
2309 #endregion 私有方法,字段,构造函数结束
2310
2311 #region 缓存方法
2312
2313 ///
2314 /// 追加参数数组到缓存.
2315 ///
2316 /// 一个有效的数据库连接字符串
2317 /// 存储过程名或SQL语句
2318 /// 要缓存的参数数组
2319 public static void CacheParameterSet(string connectionString, string commandText, params SqlParameter[] commandParameters)
2320 {
2321 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
2322 if (commandText == null || commandText.Length == 0) throw new ArgumentNullException("commandText");
2323
2324 string hashKey = connectionString + ":" + commandText;
2325
2326 paramCache[hashKey] = commandParameters;
2327 }
2328
2329 ///
2330 /// 从缓存中获取参数数组.
2331 ///
2332 /// 一个有效的数据库连接字符
2333 /// 存储过程名或SQL语句
2334 /// 参数数组
2335 public static SqlParameter[] GetCachedParameterSet(string connectionString, string commandText)
2336 {
2337 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
2338 if (commandText == null || commandText.Length == 0) throw new ArgumentNullException("commandText");
2339
2340 string hashKey = connectionString + ":" + commandText;
2341
2342 SqlParameter[] cachedParameters = paramCache[hashKey] as SqlParameter[];
2343 if (cachedParameters == null)
2344 {
2345 return null;
2346 }
2347 else
2348 {
2349 return CloneParameters(cachedParameters);
2350 }
2351 }
2352
2353 #endregion 缓存方法结束
2354
2355 #region 检索指定的存储过程的参数集
2356
2357 ///
2358 /// 返回指定的存储过程的参数集
2359 ///
2360 ///
2361 /// 这个方法将查询数据库,并将信息存储到缓存.
2362 ///
2363 /// 一个有效的数据库连接字符
2364 /// 存储过程名
2365 /// 返回SqlParameter参数数组
2366 public static SqlParameter[] GetSpParameterSet(string connectionString, string spName)
2367 {
2368 return GetSpParameterSet(connectionString, spName, false);
2369 }
2370
2371 ///
2372 /// 返回指定的存储过程的参数集
2373 ///
2374 ///
2375 /// 这个方法将查询数据库,并将信息存储到缓存.
2376 ///
2377 /// 一个有效的数据库连接字符.
2378 /// 存储过程名
2379 /// 是否包含返回值参数
2380 /// 返回SqlParameter参数数组
2381 public static SqlParameter[] GetSpParameterSet(string connectionString, string spName, bool includeReturnValueParameter)
2382 {
2383 if (connectionString == null || connectionString.Length == 0) throw new ArgumentNullException("connectionString");
2384 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
2385
2386 using (SqlConnection connection = new SqlConnection(connectionString))
2387 {
2388 return GetSpParameterSetInternal(connection, spName, includeReturnValueParameter);
2389 }
2390 }
2391
2392 ///
2393 /// [内部]返回指定的存储过程的参数集(使用连接对象).
2394 ///
2395 ///
2396 /// 这个方法将查询数据库,并将信息存储到缓存.
2397 ///
2398 /// 一个有效的数据库连接字符
2399 /// 存储过程名
2400 /// 返回SqlParameter参数数组
2401 internal static SqlParameter[] GetSpParameterSet(SqlConnection connection, string spName)
2402 {
2403 return GetSpParameterSet(connection, spName, false);
2404 }
2405
2406 ///
2407 /// [内部]返回指定的存储过程的参数集(使用连接对象)
2408 ///
2409 ///
2410 /// 这个方法将查询数据库,并将信息存储到缓存.
2411 ///
2412 /// 一个有效的数据库连接对象
2413 /// 存储过程名
2414 ///
2415 /// 是否包含返回值参数
2416 ///
2417 /// 返回SqlParameter参数数组
2418 internal static SqlParameter[] GetSpParameterSet(SqlConnection connection, string spName, bool includeReturnValueParameter)
2419 {
2420 if (connection == null) throw new ArgumentNullException("connection");
2421 using (SqlConnection clonedConnection = (SqlConnection)((ICloneable)connection).Clone())
2422 {
2423 return GetSpParameterSetInternal(clonedConnection, spName, includeReturnValueParameter);
2424 }
2425 }
2426
2427 ///
2428 /// [私有]返回指定的存储过程的参数集(使用连接对象)
2429 ///
2430 /// 一个有效的数据库连接对象
2431 /// 存储过程名
2432 /// 是否包含返回值参数
2433 /// 返回SqlParameter参数数组
2434 private static SqlParameter[] GetSpParameterSetInternal(SqlConnection connection, string spName, bool includeReturnValueParameter)
2435 {
2436 if (connection == null) throw new ArgumentNullException("connection");
2437 if (spName == null || spName.Length == 0) throw new ArgumentNullException("spName");
2438
2439 string hashKey = connection.ConnectionString + ":" + spName + (includeReturnValueParameter ? ":include ReturnValue Parameter" : "");
2440
2441 SqlParameter[] cachedParameters;
2442
2443 cachedParameters = paramCache[hashKey] as SqlParameter[];
2444 if (cachedParameters == null)
2445 {
2446 SqlParameter[] spParameters = DiscoverSpParameterSet(connection, spName, includeReturnValueParameter);
2447 paramCache[hashKey] = spParameters;
2448 cachedParameters = spParameters;
2449 }
2450
2451 return CloneParameters(cachedParameters);
2452 }
2453
2454 #endregion 参数集检索结束
2455
2456 }
2457 }