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