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