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