微軟SQLHelper.cs類

   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;才能調用。