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