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