微软原版SQLHelper类

SQLHelper类：

 

代码

   1  //  ===============================================================================
   2  //  Microsoft Data Access Application Block for .NET
   3  //   http://msdn.microsoft.com/library/en-us/dnbda/html/daab-rm.asp
   4  //
   5  //  SQLHelper.cs
   6  //
   7  //  This file contains the implementations of the SqlHelper and SqlHelperParameterCache
   8  //  classes.
   9  //
  10  //  For more information see the Data Access Application Block Implementation Overview. 
  11  //  ===============================================================================
  12  //  Release history
  13  //  VERSION    DESCRIPTION
  14  //    2.0    Added support for FillDataset, UpdateDataset and "Param" helper methods
  15  //
  16  //  ===============================================================================
  17  //  Copyright (C) 2000-2001 Microsoft Corporation
  18  //  All rights reserved.
  19  //  THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY
  20  //  OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT
  21  //  LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR
  22  //  FITNESS FOR A PARTICULAR PURPOSE.
  23  //  ==============================================================================
  24 
  25  using  System;
  26  using  System.Data;
  27  using  System.Xml;
  28  using  System.Data.SqlClient;
  29  using  System.Collections;
  30 
  31  namespace  Microsoft.ApplicationBlocks.Data
  32  {
  33       ///   <summary>
  34       ///  The SqlHelper class is intended to encapsulate high performance, scalable best practices for 
  35       ///  common uses of SqlClient
  36       ///   </summary>
  37       public   sealed   class  SqlHelper
  38      {
  39           #region  private utility methods & constructors
  40 
  41           //  Since this class provides only static methods, make the default constructor private to prevent 
  42           //  instances from being created with "new SqlHelper()"
  43           private  SqlHelper() {}
  44 
  45           ///   <summary>
  46           ///  This method is used to attach array of SqlParameters to a SqlCommand.
  47           ///  
  48           ///  This method will assign a value of DbNull to any parameter with a direction of
  49           ///  InputOutput and a value of null.  
  50           ///  
  51           ///  This behavior will prevent default values from being used, but
  52           ///  this will be the less common case than an intended pure output parameter (derived as InputOutput)
  53           ///  where the user provided no input value.
  54           ///   </summary>
  55           ///   <param name="command"> The command to which the parameters will be added </param>
  56           ///   <param name="commandParameters"> An array of SqlParameters to be added to command </param>
  57           private   static   void  AttachParameters(SqlCommand command, SqlParameter[] commandParameters)
  58          {
  59               if ( command  ==   null  )  throw   new  ArgumentNullException(  " command "  );
  60               if ( commandParameters  !=   null  )
  61              {
  62                   foreach  (SqlParameter p  in  commandParameters)
  63                  {
  64                       if ( p  !=   null  )
  65                      {
  66                           //  Check for derived output value with no value assigned
  67                           if  ( ( p.Direction  ==  ParameterDirection.InputOutput  ||  
  68                              p.Direction  ==  ParameterDirection.Input )  &&  
  69                              (p.Value  ==   null ))
  70                          {
  71                              p.Value  =  DBNull.Value;
  72                          }
  73                          command.Parameters.Add(p);
  74                      }
  75                  }
  76              }
  77          }
  78 
  79           ///   <summary>
  80           ///  This method assigns dataRow column values to an array of SqlParameters
  81           ///   </summary>
  82           ///   <param name="commandParameters"> Array of SqlParameters to be assigned values </param>
  83           ///   <param name="dataRow"> The dataRow used to hold the stored procedure's parameter values </param>
  84           private   static   void  AssignParameterValues(SqlParameter[] commandParameters, DataRow dataRow)
  85          {
  86               if  ((commandParameters  ==   null )  ||  (dataRow  ==   null )) 
  87              {
  88                   //  Do nothing if we get no data
  89                   return ;
  90              }
  91 
  92               int  i  =   0 ;
  93               //  Set the parameters values
  94               foreach (SqlParameter commandParameter  in  commandParameters)
  95              {
  96                   //  Check the parameter name
  97                   if ( commandParameter.ParameterName  ==   null   ||  
  98                      commandParameter.ParameterName.Length  <=   1  )
  99                       throw   new  Exception( 
 100                           string .Format( 
 101                               " Please provide a valid parameter name on the parameter #{0}, the ParameterName property has the following value: '{1}'. " , 
 102                              i, commandParameter.ParameterName ) );
 103                   if  (dataRow.Table.Columns.IndexOf(commandParameter.ParameterName.Substring( 1 ))  !=   - 1 )
 104                      commandParameter.Value  =  dataRow[commandParameter.ParameterName.Substring( 1 )];
 105                  i ++ ;
 106              }
 107          }
 108 
 109           ///   <summary>
 110           ///  This method assigns an array of values to an array of SqlParameters
 111           ///   </summary>
 112           ///   <param name="commandParameters"> Array of SqlParameters to be assigned values </param>
 113           ///   <param name="parameterValues"> Array of objects holding the values to be assigned </param>
 114           private   static   void  AssignParameterValues(SqlParameter[] commandParameters,  object [] parameterValues)
 115          {
 116               if  ((commandParameters  ==   null )  ||  (parameterValues  ==   null )) 
 117              {
 118                   //  Do nothing if we get no data
 119                   return ;
 120              }
 121 
 122               //  We must have the same number of values as we pave parameters to put them in
 123               if  (commandParameters.Length  !=  parameterValues.Length)
 124              {
 125                   throw   new  ArgumentException( " Parameter count does not match Parameter Value count. " );
 126              }
 127 
 128               //  Iterate through the SqlParameters, assigning the values from the corresponding position in the 
 129               //  value array
 130               for  ( int  i  =   0 , j  =  commandParameters.Length; i  <  j; i ++ )
 131              {
 132                   //  If the current array value derives from IDbDataParameter, then assign its Value property
 133                   if  (parameterValues[i]  is  IDbDataParameter)
 134                  {
 135                      IDbDataParameter paramInstance  =  (IDbDataParameter)parameterValues[i];
 136                       if ( paramInstance.Value  ==   null  )
 137                      {
 138                          commandParameters[i].Value  =  DBNull.Value; 
 139                      }
 140                       else
 141                      {
 142                          commandParameters[i].Value  =  paramInstance.Value;
 143                      }
 144                  }
 145                   else   if  (parameterValues[i]  ==   null )
 146                  {
 147                      commandParameters[i].Value  =  DBNull.Value;
 148                  }
 149                   else
 150                  {
 151                      commandParameters[i].Value  =  parameterValues[i];
 152                  }
 153              }
 154          }
 155 
 156           ///   <summary>
 157           ///  This method opens (if necessary) and assigns a connection, transaction, command type and parameters 
 158           ///  to the provided command
 159           ///   </summary>
 160           ///   <param name="command"> The SqlCommand to be prepared </param>
 161           ///   <param name="connection"> A valid SqlConnection, on which to execute this command </param>
 162           ///   <param name="transaction"> A valid SqlTransaction, or 'null' </param>
 163           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
 164           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
 165           ///   <param name="commandParameters"> An array of SqlParameters to be associated with the command or 'null' if no parameters are required </param>
 166           ///   <param name="mustCloseConnection"><c> true </c>  if the connection was opened by the method, otherwose is false. </param>
 167           private   static   void  PrepareCommand(SqlCommand command, SqlConnection connection, SqlTransaction transaction, CommandType commandType,  string  commandText, SqlParameter[] commandParameters,  out   bool  mustCloseConnection )
 168          {
 169               if ( command  ==   null  )  throw   new  ArgumentNullException(  " command "  );
 170               if ( commandText  ==   null   ||  commandText.Length  ==   0  )  throw   new  ArgumentNullException(  " commandText "  );
 171 
 172               //  If the provided connection is not open, we will open it
 173               if  (connection.State  !=  ConnectionState.Open)
 174              {
 175                  mustCloseConnection  =   true ;
 176                  connection.Open();
 177              }
 178               else
 179              {
 180                  mustCloseConnection  =   false ;
 181              }
 182 
 183               //  Associate the connection with the command
 184              command.Connection  =  connection;
 185 
 186               //  Set the command text (stored procedure name or SQL statement)
 187              command.CommandText  =  commandText;
 188 
 189               //  If we were provided a transaction, assign it
 190               if  (transaction  !=   null )
 191              {
 192                   if ( transaction.Connection  ==   null  )  throw   new  ArgumentException(  " The transaction was rollbacked or commited, please provide an open transaction. " ,  " transaction "  );
 193                  command.Transaction  =  transaction;
 194              }
 195 
 196               //  Set the command type
 197              command.CommandType  =  commandType;
 198 
 199               //  Attach the command parameters if they are provided
 200               if  (commandParameters  !=   null )
 201              {
 202                  AttachParameters(command, commandParameters);
 203              }
 204               return ;
 205          }
 206 
 207           #endregion  private utility methods & constructors
 208 
 209           #region  ExecuteNonQuery
 210 
 211           ///   <summary>
 212           ///  Execute a SqlCommand (that returns no resultset and takes no parameters) against the database specified in 
 213           ///  the connection string
 214           ///   </summary>
 215           ///   <remarks>
 216           ///  e.g.:  
 217           ///   int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders");
 218           ///   </remarks>
 219           ///   <param name="connectionString"> A valid connection string for a SqlConnection </param>
 220           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
 221           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
 222           ///   <returns> An int representing the number of rows affected by the command </returns>
 223           public   static   int  ExecuteNonQuery( string  connectionString, CommandType commandType,  string  commandText)
 224          {
 225               //  Pass through the call providing null for the set of SqlParameters
 226               return  ExecuteNonQuery(connectionString, commandType, commandText, (SqlParameter[]) null );
 227          }
 228 
 229           ///   <summary>
 230           ///  Execute a SqlCommand (that returns no resultset) against the database specified in the connection string 
 231           ///  using the provided parameters
 232           ///   </summary>
 233           ///   <remarks>
 234           ///  e.g.:  
 235           ///   int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
 236           ///   </remarks>
 237           ///   <param name="connectionString"> A valid connection string for a SqlConnection </param>
 238           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
 239           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
 240           ///   <param name="commandParameters"> An array of SqlParamters used to execute the command </param>
 241           ///   <returns> An int representing the number of rows affected by the command </returns>
 242           public   static   int  ExecuteNonQuery( string  connectionString, CommandType commandType,  string  commandText,  params  SqlParameter[] commandParameters)
 243          {
 244               if ( connectionString  ==   null   ||  connectionString.Length  ==   0  )  throw   new  ArgumentNullException(  " connectionString "  );
 245 
 246               //  Create & open a SqlConnection, and dispose of it after we are done
 247               using  (SqlConnection connection  =   new  SqlConnection(connectionString))
 248              {
 249                  connection.Open();
 250 
 251                   //  Call the overload that takes a connection in place of the connection string
 252                   return  ExecuteNonQuery(connection, commandType, commandText, commandParameters);
 253              }
 254          }
 255 
 256           ///   <summary>
 257           ///  Execute a stored procedure via a SqlCommand (that returns no resultset) against the database specified in 
 258           ///  the connection string using the provided parameter values.  This method will query the database to discover the parameters for the 
 259           ///  stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
 260           ///   </summary>
 261           ///   <remarks>
 262           ///  This method provides no access to output parameters or the stored procedure's return value parameter.
 263           ///  
 264           ///  e.g.:  
 265           ///   int result = ExecuteNonQuery(connString, "PublishOrders", 24, 36);
 266           ///   </remarks>
 267           ///   <param name="connectionString"> A valid connection string for a SqlConnection </param>
 268           ///   <param name="spName"> The name of the stored prcedure </param>
 269           ///   <param name="parameterValues"> An array of objects to be assigned as the input values of the stored procedure </param>
 270           ///   <returns> An int representing the number of rows affected by the command </returns>
 271           public   static   int  ExecuteNonQuery( string  connectionString,  string  spName,  params   object [] parameterValues)
 272          {
 273               if ( connectionString  ==   null   ||  connectionString.Length  ==   0  )  throw   new  ArgumentNullException(  " connectionString "  );
 274               if ( spName  ==   null   ||  spName.Length  ==   0  )  throw   new  ArgumentNullException(  " spName "  );
 275 
 276               //  If we receive parameter values, we need to figure out where they go
 277               if  ((parameterValues  !=   null )  &&  (parameterValues.Length  >   0 )) 
 278              {
 279                   //  Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
 280                  SqlParameter[] commandParameters  =  SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
 281 
 282                   //  Assign the provided values to these parameters based on parameter order
 283                  AssignParameterValues(commandParameters, parameterValues);
 284 
 285                   //  Call the overload that takes an array of SqlParameters
 286                   return  ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName, commandParameters);
 287              }
 288               else  
 289              {
 290                   //  Otherwise we can just call the SP without params
 291                   return  ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName);
 292              }
 293          }
 294 
 295           ///   <summary>
 296           ///  Execute a SqlCommand (that returns no resultset and takes no parameters) against the provided SqlConnection. 
 297           ///   </summary>
 298           ///   <remarks>
 299           ///  e.g.:  
 300           ///   int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders");
 301           ///   </remarks>
 302           ///   <param name="connection"> A valid SqlConnection </param>
 303           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
 304           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
 305           ///   <returns> An int representing the number of rows affected by the command </returns>
 306           public   static   int  ExecuteNonQuery(SqlConnection connection, CommandType commandType,  string  commandText)
 307          {
 308               //  Pass through the call providing null for the set of SqlParameters
 309               return  ExecuteNonQuery(connection, commandType, commandText, (SqlParameter[]) null );
 310          }
 311 
 312           ///   <summary>
 313           ///  Execute a SqlCommand (that returns no resultset) against the specified SqlConnection 
 314           ///  using the provided parameters.
 315           ///   </summary>
 316           ///   <remarks>
 317           ///  e.g.:  
 318           ///   int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
 319           ///   </remarks>
 320           ///   <param name="connection"> A valid SqlConnection </param>
 321           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
 322           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
 323           ///   <param name="commandParameters"> An array of SqlParamters used to execute the command </param>
 324           ///   <returns> An int representing the number of rows affected by the command </returns>
 325           public   static   int  ExecuteNonQuery(SqlConnection connection, CommandType commandType,  string  commandText,  params  SqlParameter[] commandParameters)
 326          {    
 327               if ( connection  ==   null  )  throw   new  ArgumentNullException(  " connection "  );
 328 
 329               //  Create a command and prepare it for execution
 330              SqlCommand cmd  =   new  SqlCommand();
 331               bool  mustCloseConnection  =   false ;
 332              PrepareCommand(cmd, connection, (SqlTransaction) null , commandType, commandText, commandParameters,  out  mustCloseConnection );
 333              
 334               //  Finally, execute the command
 335               int  retval  =  cmd.ExecuteNonQuery();
 336              
 337               //  Detach the SqlParameters from the command object, so they can be used again
 338              cmd.Parameters.Clear();
 339               if ( mustCloseConnection )
 340                  connection.Close();
 341               return  retval;
 342          }
 343 
 344           ///   <summary>
 345           ///  Execute a stored procedure via a SqlCommand (that returns no resultset) against the specified SqlConnection 
 346           ///  using the provided parameter values.  This method will query the database to discover the parameters for the 
 347           ///  stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
 348           ///   </summary>
 349           ///   <remarks>
 350           ///  This method provides no access to output parameters or the stored procedure's return value parameter.
 351           ///  
 352           ///  e.g.:  
 353           ///   int result = ExecuteNonQuery(conn, "PublishOrders", 24, 36);
 354           ///   </remarks>
 355           ///   <param name="connection"> A valid SqlConnection </param>
 356           ///   <param name="spName"> The name of the stored procedure </param>
 357           ///   <param name="parameterValues"> An array of objects to be assigned as the input values of the stored procedure </param>
 358           ///   <returns> An int representing the number of rows affected by the command </returns>
 359           public   static   int  ExecuteNonQuery(SqlConnection connection,  string  spName,  params   object [] parameterValues)
 360          {
 361               if ( connection  ==   null  )  throw   new  ArgumentNullException(  " connection "  );
 362               if ( spName  ==   null   ||  spName.Length  ==   0  )  throw   new  ArgumentNullException(  " spName "  );
 363 
 364               //  If we receive parameter values, we need to figure out where they go
 365               if  ((parameterValues  !=   null )  &&  (parameterValues.Length  >   0 )) 
 366              {
 367                   //  Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
 368                  SqlParameter[] commandParameters  =  SqlHelperParameterCache.GetSpParameterSet(connection, spName);
 369 
 370                   //  Assign the provided values to these parameters based on parameter order
 371                  AssignParameterValues(commandParameters, parameterValues);
 372 
 373                   //  Call the overload that takes an array of SqlParameters
 374                   return  ExecuteNonQuery(connection, CommandType.StoredProcedure, spName, commandParameters);
 375              }
 376               else  
 377              {
 378                   //  Otherwise we can just call the SP without params
 379                   return  ExecuteNonQuery(connection, CommandType.StoredProcedure, spName);
 380              }
 381          }
 382 
 383           ///   <summary>
 384           ///  Execute a SqlCommand (that returns no resultset and takes no parameters) against the provided SqlTransaction. 
 385           ///   </summary>
 386           ///   <remarks>
 387           ///  e.g.:  
 388           ///   int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "PublishOrders");
 389           ///   </remarks>
 390           ///   <param name="transaction"> A valid SqlTransaction </param>
 391           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
 392           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
 393           ///   <returns> An int representing the number of rows affected by the command </returns>
 394           public   static   int  ExecuteNonQuery(SqlTransaction transaction, CommandType commandType,  string  commandText)
 395          {
 396               //  Pass through the call providing null for the set of SqlParameters
 397               return  ExecuteNonQuery(transaction, commandType, commandText, (SqlParameter[]) null );
 398          }
 399 
 400           ///   <summary>
 401           ///  Execute a SqlCommand (that returns no resultset) against the specified SqlTransaction
 402           ///  using the provided parameters.
 403           ///   </summary>
 404           ///   <remarks>
 405           ///  e.g.:  
 406           ///   int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
 407           ///   </remarks>
 408           ///   <param name="transaction"> A valid SqlTransaction </param>
 409           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
 410           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
 411           ///   <param name="commandParameters"> An array of SqlParamters used to execute the command </param>
 412           ///   <returns> An int representing the number of rows affected by the command </returns>
 413           public   static   int  ExecuteNonQuery(SqlTransaction transaction, CommandType commandType,  string  commandText,  params  SqlParameter[] commandParameters)
 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 
 418               //  Create a command and prepare it for execution
 419              SqlCommand cmd  =   new  SqlCommand();
 420               bool  mustCloseConnection  =   false ;
 421              PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters,  out  mustCloseConnection );
 422                  
 423               //  Finally, execute the command
 424               int  retval  =  cmd.ExecuteNonQuery();
 425                  
 426               //  Detach the SqlParameters from the command object, so they can be used again
 427              cmd.Parameters.Clear();
 428               return  retval;
 429          }
 430 
 431           ///   <summary>
 432           ///  Execute a stored procedure via a SqlCommand (that returns no resultset) against the specified 
 433           ///  SqlTransaction using the provided parameter values.  This method will query the database to discover the parameters for the 
 434           ///  stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
 435           ///   </summary>
 436           ///   <remarks>
 437           ///  This method provides no access to output parameters or the stored procedure's return value parameter.
 438           ///  
 439           ///  e.g.:  
 440           ///   int result = ExecuteNonQuery(conn, trans, "PublishOrders", 24, 36);
 441           ///   </remarks>
 442           ///   <param name="transaction"> A valid SqlTransaction </param>
 443           ///   <param name="spName"> The name of the stored procedure </param>
 444           ///   <param name="parameterValues"> An array of objects to be assigned as the input values of the stored procedure </param>
 445           ///   <returns> An int representing the number of rows affected by the command </returns>
 446           public   static   int  ExecuteNonQuery(SqlTransaction transaction,  string  spName,  params   object [] parameterValues)
 447          {
 448               if ( transaction  ==   null  )  throw   new  ArgumentNullException(  " transaction "  );
 449               if ( transaction  !=   null   &&  transaction.Connection  ==   null  )  throw   new  ArgumentException(  " The transaction was rollbacked or commited, please provide an open transaction. " ,  " transaction "  );
 450               if ( spName  ==   null   ||  spName.Length  ==   0  )  throw   new  ArgumentNullException(  " spName "  );
 451 
 452               //  If we receive parameter values, we need to figure out where they go
 453               if  ((parameterValues  !=   null )  &&  (parameterValues.Length  >   0 )) 
 454              {
 455                   //  Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
 456                  SqlParameter[] commandParameters  =  SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
 457 
 458                   //  Assign the provided values to these parameters based on parameter order
 459                  AssignParameterValues(commandParameters, parameterValues);
 460 
 461                   //  Call the overload that takes an array of SqlParameters
 462                   return  ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName, commandParameters);
 463              }
 464               else  
 465              {
 466                   //  Otherwise we can just call the SP without params
 467                   return  ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName);
 468              }
 469          }
 470 
 471           #endregion  ExecuteNonQuery
 472 
 473           #region  ExecuteDataset
 474 
 475           ///   <summary>
 476           ///  Execute a SqlCommand (that returns a resultset and takes no parameters) against the database specified in 
 477           ///  the connection string. 
 478           ///   </summary>
 479           ///   <remarks>
 480           ///  e.g.:  
 481           ///   DataSet ds = ExecuteDataset(connString, CommandType.StoredProcedure, "GetOrders");
 482           ///   </remarks>
 483           ///   <param name="connectionString"> A valid connection string for a SqlConnection </param>
 484           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
 485           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
 486           ///   <returns> A dataset containing the resultset generated by the command </returns>
 487           public   static  DataSet ExecuteDataset( string  connectionString, CommandType commandType,  string  commandText)
 488          {
 489               //  Pass through the call providing null for the set of SqlParameters
 490               return  ExecuteDataset(connectionString, commandType, commandText, (SqlParameter[]) null );
 491          }
 492 
 493           ///   <summary>
 494           ///  Execute a SqlCommand (that returns a resultset) against the database specified in the connection string 
 495           ///  using the provided parameters.
 496           ///   </summary>
 497           ///   <remarks>
 498           ///  e.g.:  
 499           ///   DataSet ds = ExecuteDataset(connString, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
 500           ///   </remarks>
 501           ///   <param name="connectionString"> A valid connection string for a SqlConnection </param>
 502           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
 503           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
 504           ///   <param name="commandParameters"> An array of SqlParamters used to execute the command </param>
 505           ///   <returns> A dataset containing the resultset generated by the command </returns>
 506           public   static  DataSet ExecuteDataset( string  connectionString, CommandType commandType,  string  commandText,  params  SqlParameter[] commandParameters)
 507          {
 508               if ( connectionString  ==   null   ||  connectionString.Length  ==   0  )  throw   new  ArgumentNullException(  " connectionString "  );
 509 
 510               //  Create & open a SqlConnection, and dispose of it after we are done
 511               using  (SqlConnection connection  =   new  SqlConnection(connectionString))
 512              {
 513                  connection.Open();
 514 
 515                   //  Call the overload that takes a connection in place of the connection string
 516                   return  ExecuteDataset(connection, commandType, commandText, commandParameters);
 517              }
 518          }
 519 
 520           ///   <summary>
 521           ///  Execute a stored procedure via a SqlCommand (that returns a resultset) against the database specified in 
 522           ///  the connection string using the provided parameter values.  This method will query the database to discover the parameters for the 
 523           ///  stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
 524           ///   </summary>
 525           ///   <remarks>
 526           ///  This method provides no access to output parameters or the stored procedure's return value parameter.
 527           ///  
 528           ///  e.g.:  
 529           ///   DataSet ds = ExecuteDataset(connString, "GetOrders", 24, 36);
 530           ///   </remarks>
 531           ///   <param name="connectionString"> A valid connection string for a SqlConnection </param>
 532           ///   <param name="spName"> The name of the stored procedure </param>
 533           ///   <param name="parameterValues"> An array of objects to be assigned as the input values of the stored procedure </param>
 534           ///   <returns> A dataset containing the resultset generated by the command </returns>
 535           public   static  DataSet ExecuteDataset( string  connectionString,  string  spName,  params   object [] parameterValues)
 536          {
 537               if ( connectionString  ==   null   ||  connectionString.Length  ==   0  )  throw   new  ArgumentNullException(  " connectionString "  );
 538               if ( spName  ==   null   ||  spName.Length  ==   0  )  throw   new  ArgumentNullException(  " spName "  );
 539              
 540               //  If we receive parameter values, we need to figure out where they go
 541               if  ((parameterValues  !=   null )  &&  (parameterValues.Length  >   0 )) 
 542              {
 543                   //  Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
 544                  SqlParameter[] commandParameters  =  SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
 545 
 546                   //  Assign the provided values to these parameters based on parameter order
 547                  AssignParameterValues(commandParameters, parameterValues);
 548 
 549                   //  Call the overload that takes an array of SqlParameters
 550                   return  ExecuteDataset(connectionString, CommandType.StoredProcedure, spName, commandParameters);
 551              }
 552               else  
 553              {
 554                   //  Otherwise we can just call the SP without params
 555                   return  ExecuteDataset(connectionString, CommandType.StoredProcedure, spName);
 556              }
 557          }
 558 
 559           ///   <summary>
 560           ///  Execute a SqlCommand (that returns a resultset and takes no parameters) against the provided SqlConnection. 
 561           ///   </summary>
 562           ///   <remarks>
 563           ///  e.g.:  
 564           ///   DataSet ds = ExecuteDataset(conn, CommandType.StoredProcedure, "GetOrders");
 565           ///   </remarks>
 566           ///   <param name="connection"> A valid SqlConnection </param>
 567           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
 568           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
 569           ///   <returns> A dataset containing the resultset generated by the command </returns>
 570           public   static  DataSet ExecuteDataset(SqlConnection connection, CommandType commandType,  string  commandText)
 571          {
 572               //  Pass through the call providing null for the set of SqlParameters
 573               return  ExecuteDataset(connection, commandType, commandText, (SqlParameter[]) null );
 574          }
 575          
 576           ///   <summary>
 577           ///  Execute a SqlCommand (that returns a resultset) against the specified SqlConnection 
 578           ///  using the provided parameters.
 579           ///   </summary>
 580           ///   <remarks>
 581           ///  e.g.:  
 582           ///   DataSet ds = ExecuteDataset(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
 583           ///   </remarks>
 584           ///   <param name="connection"> A valid SqlConnection </param>
 585           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
 586           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
 587           ///   <param name="commandParameters"> An array of SqlParamters used to execute the command </param>
 588           ///   <returns> A dataset containing the resultset generated by the command </returns>
 589           public   static  DataSet ExecuteDataset(SqlConnection connection, CommandType commandType,  string  commandText,  params  SqlParameter[] commandParameters)
 590          {
 591               if ( connection  ==   null  )  throw   new  ArgumentNullException(  " connection "  );
 592 
 593               //  Create a command and prepare it for execution
 594              SqlCommand cmd  =   new  SqlCommand();
 595               bool  mustCloseConnection  =   false ;
 596              PrepareCommand(cmd, connection, (SqlTransaction) null , commandType, commandText, commandParameters,  out  mustCloseConnection );
 597                  
 598               //  Create the DataAdapter & DataSet
 599               using ( SqlDataAdapter da  =   new  SqlDataAdapter(cmd) )
 600              {
 601                  DataSet ds  =   new  DataSet();
 602 
 603                   //  Fill the DataSet using default values for DataTable names, etc
 604                  da.Fill(ds);
 605                  
 606                   //  Detach the SqlParameters from the command object, so they can be used again
 607                  cmd.Parameters.Clear();
 608 
 609                   if ( mustCloseConnection )
 610                      connection.Close();
 611 
 612                   //  Return the dataset
 613                   return  ds;
 614              }    
 615          }
 616          
 617           ///   <summary>
 618           ///  Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlConnection 
 619           ///  using the provided parameter values.  This method will query the database to discover the parameters for the 
 620           ///  stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
 621           ///   </summary>
 622           ///   <remarks>
 623           ///  This method provides no access to output parameters or the stored procedure's return value parameter.
 624           ///  
 625           ///  e.g.:  
 626           ///   DataSet ds = ExecuteDataset(conn, "GetOrders", 24, 36);
 627           ///   </remarks>
 628           ///   <param name="connection"> A valid SqlConnection </param>
 629           ///   <param name="spName"> The name of the stored procedure </param>
 630           ///   <param name="parameterValues"> An array of objects to be assigned as the input values of the stored procedure </param>
 631           ///   <returns> A dataset containing the resultset generated by the command </returns>
 632           public   static  DataSet ExecuteDataset(SqlConnection connection,  string  spName,  params   object [] parameterValues)
 633          {
 634               if ( connection  ==   null  )  throw   new  ArgumentNullException(  " connection "  );
 635               if ( spName  ==   null   ||  spName.Length  ==   0  )  throw   new  ArgumentNullException(  " spName "  );
 636 
 637               //  If we receive parameter values, we need to figure out where they go
 638               if  ((parameterValues  !=   null )  &&  (parameterValues.Length  >   0 )) 
 639              {
 640                   //  Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
 641                  SqlParameter[] commandParameters  =  SqlHelperParameterCache.GetSpParameterSet(connection, spName);
 642 
 643                   //  Assign the provided values to these parameters based on parameter order
 644                  AssignParameterValues(commandParameters, parameterValues);
 645 
 646                   //  Call the overload that takes an array of SqlParameters
 647                   return  ExecuteDataset(connection, CommandType.StoredProcedure, spName, commandParameters);
 648              }
 649               else  
 650              {
 651                   //  Otherwise we can just call the SP without params
 652                   return  ExecuteDataset(connection, CommandType.StoredProcedure, spName);
 653              }
 654          }
 655 
 656           ///   <summary>
 657           ///  Execute a SqlCommand (that returns a resultset and takes no parameters) against the provided SqlTransaction. 
 658           ///   </summary>
 659           ///   <remarks>
 660           ///  e.g.:  
 661           ///   DataSet ds = ExecuteDataset(trans, CommandType.StoredProcedure, "GetOrders");
 662           ///   </remarks>
 663           ///   <param name="transaction"> A valid SqlTransaction </param>
 664           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
 665           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
 666           ///   <returns> A dataset containing the resultset generated by the command </returns>
 667           public   static  DataSet ExecuteDataset(SqlTransaction transaction, CommandType commandType,  string  commandText)
 668          {
 669               //  Pass through the call providing null for the set of SqlParameters
 670               return  ExecuteDataset(transaction, commandType, commandText, (SqlParameter[]) null );
 671          }
 672          
 673           ///   <summary>
 674           ///  Execute a SqlCommand (that returns a resultset) against the specified SqlTransaction
 675           ///  using the provided parameters.
 676           ///   </summary>
 677           ///   <remarks>
 678           ///  e.g.:  
 679           ///   DataSet ds = ExecuteDataset(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
 680           ///   </remarks>
 681           ///   <param name="transaction"> A valid SqlTransaction </param>
 682           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
 683           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
 684           ///   <param name="commandParameters"> An array of SqlParamters used to execute the command </param>
 685           ///   <returns> A dataset containing the resultset generated by the command </returns>
 686           public   static  DataSet ExecuteDataset(SqlTransaction transaction, CommandType commandType,  string  commandText,  params  SqlParameter[] commandParameters)
 687          {
 688               if ( transaction  ==   null  )  throw   new  ArgumentNullException(  " transaction "  );
 689               if ( transaction  !=   null   &&  transaction.Connection  ==   null  )  throw   new  ArgumentException(  " The transaction was rollbacked or commited, please provide an open transaction. " ,  " transaction "  );
 690 
 691               //  Create a command and prepare it for execution
 692              SqlCommand cmd  =   new  SqlCommand();
 693               bool  mustCloseConnection  =   false ;
 694              PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters,  out  mustCloseConnection );
 695                  
 696               //  Create the DataAdapter & DataSet
 697               using ( SqlDataAdapter da  =   new  SqlDataAdapter(cmd) )
 698              {
 699                  DataSet ds  =   new  DataSet();
 700 
 701                   //  Fill the DataSet using default values for DataTable names, etc
 702                  da.Fill(ds);
 703                  
 704                   //  Detach the SqlParameters from the command object, so they can be used again
 705                  cmd.Parameters.Clear();
 706 
 707                   //  Return the dataset
 708                   return  ds;
 709              }    
 710          }
 711          
 712           ///   <summary>
 713           ///  Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified 
 714           ///  SqlTransaction using the provided parameter values.  This method will query the database to discover the parameters for the 
 715           ///  stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
 716           ///   </summary>
 717           ///   <remarks>
 718           ///  This method provides no access to output parameters or the stored procedure's return value parameter.
 719           ///  
 720           ///  e.g.:  
 721           ///   DataSet ds = ExecuteDataset(trans, "GetOrders", 24, 36);
 722           ///   </remarks>
 723           ///   <param name="transaction"> A valid SqlTransaction </param>
 724           ///   <param name="spName"> The name of the stored procedure </param>
 725           ///   <param name="parameterValues"> An array of objects to be assigned as the input values of the stored procedure </param>
 726           ///   <returns> A dataset containing the resultset generated by the command </returns>
 727           public   static  DataSet ExecuteDataset(SqlTransaction transaction,  string  spName,  params   object [] parameterValues)
 728          {
 729               if ( transaction  ==   null  )  throw   new  ArgumentNullException(  " transaction "  );
 730               if ( transaction  !=   null   &&  transaction.Connection  ==   null  )  throw   new  ArgumentException(  " The transaction was rollbacked or commited, please provide an open transaction. " ,  " transaction "  );
 731               if ( spName  ==   null   ||  spName.Length  ==   0  )  throw   new  ArgumentNullException(  " spName "  );
 732              
 733               //  If we receive parameter values, we need to figure out where they go
 734               if  ((parameterValues  !=   null )  &&  (parameterValues.Length  >   0 )) 
 735              {
 736                   //  Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
 737                  SqlParameter[] commandParameters  =  SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
 738 
 739                   //  Assign the provided values to these parameters based on parameter order
 740                  AssignParameterValues(commandParameters, parameterValues);
 741 
 742                   //  Call the overload that takes an array of SqlParameters
 743                   return  ExecuteDataset(transaction, CommandType.StoredProcedure, spName, commandParameters);
 744              }
 745               else  
 746              {
 747                   //  Otherwise we can just call the SP without params
 748                   return  ExecuteDataset(transaction, CommandType.StoredProcedure, spName);
 749              }
 750          }
 751 
 752           #endregion  ExecuteDataset
 753          
 754           #region  ExecuteReader
 755 
 756           ///   <summary>
 757           ///  This enum is used to indicate whether the connection was provided by the caller, or created by SqlHelper, so that
 758           ///  we can set the appropriate CommandBehavior when calling ExecuteReader()
 759           ///   </summary>
 760           private   enum  SqlConnectionOwnership    
 761          {
 762               ///   <summary> Connection is owned and managed by SqlHelper </summary>
 763              Internal, 
 764               ///   <summary> Connection is owned and managed by the caller </summary>
 765              External
 766          }
 767 
 768           ///   <summary>
 769           ///  Create and prepare a SqlCommand, and call ExecuteReader with the appropriate CommandBehavior.
 770           ///   </summary>
 771           ///   <remarks>
 772           ///  If we created and opened the connection, we want the connection to be closed when the DataReader is closed.
 773           ///  
 774           ///  If the caller provided the connection, we want to leave it to them to manage.
 775           ///   </remarks>
 776           ///   <param name="connection"> A valid SqlConnection, on which to execute this command </param>
 777           ///   <param name="transaction"> A valid SqlTransaction, or 'null' </param>
 778           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
 779           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
 780           ///   <param name="commandParameters"> An array of SqlParameters to be associated with the command or 'null' if no parameters are required </param>
 781           ///   <param name="connectionOwnership"> Indicates whether the connection parameter was provided by the caller, or created by SqlHelper </param>
 782           ///   <returns> SqlDataReader containing the results of the command </returns>
 783           private   static  SqlDataReader ExecuteReader(SqlConnection connection, SqlTransaction transaction, CommandType commandType,  string  commandText, SqlParameter[] commandParameters, SqlConnectionOwnership connectionOwnership)
 784          {    
 785               if ( connection  ==   null  )  throw   new  ArgumentNullException(  " connection "  );
 786 
 787               bool  mustCloseConnection  =   false ;
 788               //  Create a command and prepare it for execution
 789              SqlCommand cmd  =   new  SqlCommand();
 790               try
 791              {
 792                  PrepareCommand(cmd, connection, transaction, commandType, commandText, commandParameters,  out  mustCloseConnection );
 793              
 794                   //  Create a reader
 795                  SqlDataReader dataReader;
 796 
 797                   //  Call ExecuteReader with the appropriate CommandBehavior
 798                   if  (connectionOwnership  ==  SqlConnectionOwnership.External)
 799                  {
 800                      dataReader  =  cmd.ExecuteReader();
 801                  }
 802                   else
 803                  {
 804                      dataReader  =  cmd.ExecuteReader(CommandBehavior.CloseConnection);
 805                  }
 806              
 807                   //  Detach the SqlParameters from the command object, so they can be used again.
 808                   //  HACK: There is a problem here, the output parameter values are fletched 
 809                   //  when the reader is closed, so if the parameters are detached from the command
 810                   //  then the SqlReader can磘 set its values. 
 811                   //  When this happen, the parameters can磘 be used again in other command.
 812                   bool  canClear  =   true ;
 813                   foreach (SqlParameter commandParameter  in  cmd.Parameters)
 814                  {
 815                       if  (commandParameter.Direction  !=  ParameterDirection.Input)
 816                          canClear  =   false ;
 817                  }
 818              
 819                   if  (canClear)
 820                  {
 821                      cmd.Parameters.Clear();
 822                  }
 823 
 824                   return  dataReader;
 825              }
 826               catch
 827              {
 828                   if ( mustCloseConnection )
 829                      connection.Close();
 830                   throw ;
 831              }
 832          }
 833 
 834           ///   <summary>
 835           ///  Execute a SqlCommand (that returns a resultset and takes no parameters) against the database specified in 
 836           ///  the connection string. 
 837           ///   </summary>
 838           ///   <remarks>
 839           ///  e.g.:  
 840           ///   SqlDataReader dr = ExecuteReader(connString, CommandType.StoredProcedure, "GetOrders");
 841           ///   </remarks>
 842           ///   <param name="connectionString"> A valid connection string for a SqlConnection </param>
 843           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
 844           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
 845           ///   <returns> A SqlDataReader containing the resultset generated by the command </returns>
 846           public   static  SqlDataReader ExecuteReader( string  connectionString, CommandType commandType,  string  commandText)
 847          {
 848               //  Pass through the call providing null for the set of SqlParameters
 849               return  ExecuteReader(connectionString, commandType, commandText, (SqlParameter[]) null );
 850          }
 851 
 852           ///   <summary>
 853           ///  Execute a SqlCommand (that returns a resultset) against the database specified in the connection string 
 854           ///  using the provided parameters.
 855           ///   </summary>
 856           ///   <remarks>
 857           ///  e.g.:  
 858           ///   SqlDataReader dr = ExecuteReader(connString, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
 859           ///   </remarks>
 860           ///   <param name="connectionString"> A valid connection string for a SqlConnection </param>
 861           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
 862           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
 863           ///   <param name="commandParameters"> An array of SqlParamters used to execute the command </param>
 864           ///   <returns> A SqlDataReader containing the resultset generated by the command </returns>
 865           public   static  SqlDataReader ExecuteReader( string  connectionString, CommandType commandType,  string  commandText,  params  SqlParameter[] commandParameters)
 866          {
 867               if ( connectionString  ==   null   ||  connectionString.Length  ==   0  )  throw   new  ArgumentNullException(  " connectionString "  );
 868              SqlConnection connection  =   null ;
 869               try
 870              {
 871                  connection  =   new  SqlConnection(connectionString);
 872                  connection.Open();
 873 
 874                   //  Call the private overload that takes an internally owned connection in place of the connection string
 875                   return  ExecuteReader(connection,  null , commandType, commandText, commandParameters,SqlConnectionOwnership.Internal);
 876              }
 877               catch
 878              {
 879                   //  If we fail to return the SqlDatReader, we need to close the connection ourselves
 880                   if ( connection  !=   null  ) connection.Close();
 881                   throw ;
 882              }
 883              
 884          }
 885 
 886           ///   <summary>
 887           ///  Execute a stored procedure via a SqlCommand (that returns a resultset) against the database specified in 
 888           ///  the connection string using the provided parameter values.  This method will query the database to discover the parameters for the 
 889           ///  stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
 890           ///   </summary>
 891           ///   <remarks>
 892           ///  This method provides no access to output parameters or the stored procedure's return value parameter.
 893           ///  
 894           ///  e.g.:  
 895           ///   SqlDataReader dr = ExecuteReader(connString, "GetOrders", 24, 36);
 896           ///   </remarks>
 897           ///   <param name="connectionString"> A valid connection string for a SqlConnection </param>
 898           ///   <param name="spName"> The name of the stored procedure </param>
 899           ///   <param name="parameterValues"> An array of objects to be assigned as the input values of the stored procedure </param>
 900           ///   <returns> A SqlDataReader containing the resultset generated by the command </returns>
 901           public   static  SqlDataReader ExecuteReader( string  connectionString,  string  spName,  params   object [] parameterValues)
 902          {
 903               if ( connectionString  ==   null   ||  connectionString.Length  ==   0  )  throw   new  ArgumentNullException(  " connectionString "  );
 904               if ( spName  ==   null   ||  spName.Length  ==   0  )  throw   new  ArgumentNullException(  " spName "  );
 905              
 906               //  If we receive parameter values, we need to figure out where they go
 907               if  ((parameterValues  !=   null )  &&  (parameterValues.Length  >   0 )) 
 908              {
 909                  SqlParameter[] commandParameters  =  SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
 910 
 911                  AssignParameterValues(commandParameters, parameterValues);
 912 
 913                   return  ExecuteReader(connectionString, CommandType.StoredProcedure, spName, commandParameters);
 914              }
 915               else  
 916              {
 917                   //  Otherwise we can just call the SP without params
 918                   return  ExecuteReader(connectionString, CommandType.StoredProcedure, spName);
 919              }
 920          }
 921 
 922           ///   <summary>
 923           ///  Execute a SqlCommand (that returns a resultset and takes no parameters) against the provided SqlConnection. 
 924           ///   </summary>
 925           ///   <remarks>
 926           ///  e.g.:  
 927           ///   SqlDataReader dr = ExecuteReader(conn, CommandType.StoredProcedure, "GetOrders");
 928           ///   </remarks>
 929           ///   <param name="connection"> A valid SqlConnection </param>
 930           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
 931           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
 932           ///   <returns> A SqlDataReader containing the resultset generated by the command </returns>
 933           public   static  SqlDataReader ExecuteReader(SqlConnection connection, CommandType commandType,  string  commandText)
 934          {
 935               //  Pass through the call providing null for the set of SqlParameters
 936               return  ExecuteReader(connection, commandType, commandText, (SqlParameter[]) null );
 937          }
 938 
 939           ///   <summary>
 940           ///  Execute a SqlCommand (that returns a resultset) against the specified SqlConnection 
 941           ///  using the provided parameters.
 942           ///   </summary>
 943           ///   <remarks>
 944           ///  e.g.:  
 945           ///   SqlDataReader dr = ExecuteReader(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
 946           ///   </remarks>
 947           ///   <param name="connection"> A valid SqlConnection </param>
 948           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
 949           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
 950           ///   <param name="commandParameters"> An array of SqlParamters used to execute the command </param>
 951           ///   <returns> A SqlDataReader containing the resultset generated by the command </returns>
 952           public   static  SqlDataReader ExecuteReader(SqlConnection connection, CommandType commandType,  string  commandText,  params  SqlParameter[] commandParameters)
 953          {
 954               //  Pass through the call to the private overload using a null transaction value and an externally owned connection
 955               return  ExecuteReader(connection, (SqlTransaction) null , commandType, commandText, commandParameters, SqlConnectionOwnership.External);
 956          }
 957 
 958           ///   <summary>
 959           ///  Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlConnection 
 960           ///  using the provided parameter values.  This method will query the database to discover the parameters for the 
 961           ///  stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
 962           ///   </summary>
 963           ///   <remarks>
 964           ///  This method provides no access to output parameters or the stored procedure's return value parameter.
 965           ///  
 966           ///  e.g.:  
 967           ///   SqlDataReader dr = ExecuteReader(conn, "GetOrders", 24, 36);
 968           ///   </remarks>
 969           ///   <param name="connection"> A valid SqlConnection </param>
 970           ///   <param name="spName"> The name of the stored procedure </param>
 971           ///   <param name="parameterValues"> An array of objects to be assigned as the input values of the stored procedure </param>
 972           ///   <returns> A SqlDataReader containing the resultset generated by the command </returns>
 973           public   static  SqlDataReader ExecuteReader(SqlConnection connection,  string  spName,  params   object [] parameterValues)
 974          {
 975               if ( connection  ==   null  )  throw   new  ArgumentNullException(  " connection "  );
 976               if ( spName  ==   null   ||  spName.Length  ==   0  )  throw   new  ArgumentNullException(  " spName "  );
 977 
 978               //  If we receive parameter values, we need to figure out where they go
 979               if  ((parameterValues  !=   null )  &&  (parameterValues.Length  >   0 )) 
 980              {
 981                  SqlParameter[] commandParameters  =  SqlHelperParameterCache.GetSpParameterSet(connection, spName);
 982 
 983                  AssignParameterValues(commandParameters, parameterValues);
 984 
 985                   return  ExecuteReader(connection, CommandType.StoredProcedure, spName, commandParameters);
 986              }
 987               else  
 988              {
 989                   //  Otherwise we can just call the SP without params
 990                   return  ExecuteReader(connection, CommandType.StoredProcedure, spName);
 991              }
 992          }
 993 
 994           ///   <summary>
 995           ///  Execute a SqlCommand (that returns a resultset and takes no parameters) against the provided SqlTransaction. 
 996           ///   </summary>
 997           ///   <remarks>
 998           ///  e.g.:  
 999           ///   SqlDataReader dr = ExecuteReader(trans, CommandType.StoredProcedure, "GetOrders");
1000           ///   </remarks>
1001           ///   <param name="transaction"> A valid SqlTransaction </param>
1002           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
1003           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
1004           ///   <returns> A SqlDataReader containing the resultset generated by the command </returns>
1005           public   static  SqlDataReader ExecuteReader(SqlTransaction transaction, CommandType commandType,  string  commandText)
1006          {
1007               //  Pass through the call providing null for the set of SqlParameters
1008               return  ExecuteReader(transaction, commandType, commandText, (SqlParameter[]) null );
1009          }
1010 
1011           ///   <summary>
1012           ///  Execute a SqlCommand (that returns a resultset) against the specified SqlTransaction
1013           ///  using the provided parameters.
1014           ///   </summary>
1015           ///   <remarks>
1016           ///  e.g.:  
1017           ///    SqlDataReader dr = ExecuteReader(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
1018           ///   </remarks>
1019           ///   <param name="transaction"> A valid SqlTransaction </param>
1020           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
1021           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
1022           ///   <param name="commandParameters"> An array of SqlParamters used to execute the command </param>
1023           ///   <returns> A SqlDataReader containing the resultset generated by the command </returns>
1024           public   static  SqlDataReader ExecuteReader(SqlTransaction transaction, CommandType commandType,  string  commandText,  params  SqlParameter[] commandParameters)
1025          {
1026               if ( transaction  ==   null  )  throw   new  ArgumentNullException(  " transaction "  );
1027               if ( transaction  !=   null   &&  transaction.Connection  ==   null  )  throw   new  ArgumentException(  " The transaction was rollbacked or commited, please provide an open transaction. " ,  " transaction "  );
1028 
1029               //  Pass through to private overload, indicating that the connection is owned by the caller
1030               return  ExecuteReader(transaction.Connection, transaction, commandType, commandText, commandParameters, SqlConnectionOwnership.External);
1031          }
1032 
1033           ///   <summary>
1034           ///  Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified
1035           ///  SqlTransaction using the provided parameter values.  This method will query the database to discover the parameters for the 
1036           ///  stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
1037           ///   </summary>
1038           ///   <remarks>
1039           ///  This method provides no access to output parameters or the stored procedure's return value parameter.
1040           ///  
1041           ///  e.g.:  
1042           ///   SqlDataReader dr = ExecuteReader(trans, "GetOrders", 24, 36);
1043           ///   </remarks>
1044           ///   <param name="transaction"> A valid SqlTransaction </param>
1045           ///   <param name="spName"> The name of the stored procedure </param>
1046           ///   <param name="parameterValues"> An array of objects to be assigned as the input values of the stored procedure </param>
1047           ///   <returns> A SqlDataReader containing the resultset generated by the command </returns>
1048           public   static  SqlDataReader ExecuteReader(SqlTransaction transaction,  string  spName,  params   object [] parameterValues)
1049          {
1050               if ( transaction  ==   null  )  throw   new  ArgumentNullException(  " transaction "  );
1051               if ( transaction  !=   null   &&  transaction.Connection  ==   null  )  throw   new  ArgumentException(  " The transaction was rollbacked or commited, please provide an open transaction. " ,  " transaction "  );
1052               if ( spName  ==   null   ||  spName.Length  ==   0  )  throw   new  ArgumentNullException(  " spName "  );
1053 
1054               //  If we receive parameter values, we need to figure out where they go
1055               if  ((parameterValues  !=   null )  &&  (parameterValues.Length  >   0 )) 
1056              {
1057                  SqlParameter[] commandParameters  =  SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
1058 
1059                  AssignParameterValues(commandParameters, parameterValues);
1060 
1061                   return  ExecuteReader(transaction, CommandType.StoredProcedure, spName, commandParameters);
1062              }
1063               else  
1064              {
1065                   //  Otherwise we can just call the SP without params
1066                   return  ExecuteReader(transaction, CommandType.StoredProcedure, spName);
1067              }
1068          }
1069 
1070           #endregion  ExecuteReader
1071 
1072           #region  ExecuteScalar
1073          
1074           ///   <summary>
1075           ///  Execute a SqlCommand (that returns a 1x1 resultset and takes no parameters) against the database specified in 
1076           ///  the connection string. 
1077           ///   </summary>
1078           ///   <remarks>
1079           ///  e.g.:  
1080           ///   int orderCount = (int)ExecuteScalar(connString, CommandType.StoredProcedure, "GetOrderCount");
1081           ///   </remarks>
1082           ///   <param name="connectionString"> A valid connection string for a SqlConnection </param>
1083           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
1084           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
1085           ///   <returns> An object containing the value in the 1x1 resultset generated by the command </returns>
1086           public   static   object  ExecuteScalar( string  connectionString, CommandType commandType,  string  commandText)
1087          {
1088               //  Pass through the call providing null for the set of SqlParameters
1089               return  ExecuteScalar(connectionString, commandType, commandText, (SqlParameter[]) null );
1090          }
1091 
1092           ///   <summary>
1093           ///  Execute a SqlCommand (that returns a 1x1 resultset) against the database specified in the connection string 
1094           ///  using the provided parameters.
1095           ///   </summary>
1096           ///   <remarks>
1097           ///  e.g.:  
1098           ///   int orderCount = (int)ExecuteScalar(connString, CommandType.StoredProcedure, "GetOrderCount", new SqlParameter("@prodid", 24));
1099           ///   </remarks>
1100           ///   <param name="connectionString"> A valid connection string for a SqlConnection </param>
1101           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
1102           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
1103           ///   <param name="commandParameters"> An array of SqlParamters used to execute the command </param>
1104           ///   <returns> An object containing the value in the 1x1 resultset generated by the command </returns>
1105           public   static   object  ExecuteScalar( string  connectionString, CommandType commandType,  string  commandText,  params  SqlParameter[] commandParameters)
1106          {
1107               if ( connectionString  ==   null   ||  connectionString.Length  ==   0  )  throw   new  ArgumentNullException(  " connectionString "  );
1108               //  Create & open a SqlConnection, and dispose of it after we are done
1109               using  (SqlConnection connection  =   new  SqlConnection(connectionString))
1110              {
1111                  connection.Open();
1112 
1113                   //  Call the overload that takes a connection in place of the connection string
1114                   return  ExecuteScalar(connection, commandType, commandText, commandParameters);
1115              }
1116          }
1117 
1118           ///   <summary>
1119           ///  Execute a stored procedure via a SqlCommand (that returns a 1x1 resultset) against the database specified in 
1120           ///  the connection string using the provided parameter values.  This method will query the database to discover the parameters for the 
1121           ///  stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
1122           ///   </summary>
1123           ///   <remarks>
1124           ///  This method provides no access to output parameters or the stored procedure's return value parameter.
1125           ///  
1126           ///  e.g.:  
1127           ///   int orderCount = (int)ExecuteScalar(connString, "GetOrderCount", 24, 36);
1128           ///   </remarks>
1129           ///   <param name="connectionString"> A valid connection string for a SqlConnection </param>
1130           ///   <param name="spName"> The name of the stored procedure </param>
1131           ///   <param name="parameterValues"> An array of objects to be assigned as the input values of the stored procedure </param>
1132           ///   <returns> An object containing the value in the 1x1 resultset generated by the command </returns>
1133           public   static   object  ExecuteScalar( string  connectionString,  string  spName,  params   object [] parameterValues)
1134          {
1135               if ( connectionString  ==   null   ||  connectionString.Length  ==   0  )  throw   new  ArgumentNullException(  " connectionString "  );
1136               if ( spName  ==   null   ||  spName.Length  ==   0  )  throw   new  ArgumentNullException(  " spName "  );
1137              
1138               //  If we receive parameter values, we need to figure out where they go
1139               if  ((parameterValues  !=   null )  &&  (parameterValues.Length  >   0 )) 
1140              {
1141                   //  Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
1142                  SqlParameter[] commandParameters  =  SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
1143 
1144                   //  Assign the provided values to these parameters based on parameter order
1145                  AssignParameterValues(commandParameters, parameterValues);
1146 
1147                   //  Call the overload that takes an array of SqlParameters
1148                   return  ExecuteScalar(connectionString, CommandType.StoredProcedure, spName, commandParameters);
1149              }
1150               else  
1151              {
1152                   //  Otherwise we can just call the SP without params
1153                   return  ExecuteScalar(connectionString, CommandType.StoredProcedure, spName);
1154              }
1155          }
1156 
1157           ///   <summary>
1158           ///  Execute a SqlCommand (that returns a 1x1 resultset and takes no parameters) against the provided SqlConnection. 
1159           ///   </summary>
1160           ///   <remarks>
1161           ///  e.g.:  
1162           ///   int orderCount = (int)ExecuteScalar(conn, CommandType.StoredProcedure, "GetOrderCount");
1163           ///   </remarks>
1164           ///   <param name="connection"> A valid SqlConnection </param>
1165           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
1166           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
1167           ///   <returns> An object containing the value in the 1x1 resultset generated by the command </returns>
1168           public   static   object  ExecuteScalar(SqlConnection connection, CommandType commandType,  string  commandText)
1169          {
1170               //  Pass through the call providing null for the set of SqlParameters
1171               return  ExecuteScalar(connection, commandType, commandText, (SqlParameter[]) null );
1172          }
1173 
1174           ///   <summary>
1175           ///  Execute a SqlCommand (that returns a 1x1 resultset) against the specified SqlConnection 
1176           ///  using the provided parameters.
1177           ///   </summary>
1178           ///   <remarks>
1179           ///  e.g.:  
1180           ///   int orderCount = (int)ExecuteScalar(conn, CommandType.StoredProcedure, "GetOrderCount", new SqlParameter("@prodid", 24));
1181           ///   </remarks>
1182           ///   <param name="connection"> A valid SqlConnection </param>
1183           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
1184           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
1185           ///   <param name="commandParameters"> An array of SqlParamters used to execute the command </param>
1186           ///   <returns> An object containing the value in the 1x1 resultset generated by the command </returns>
1187           public   static   object  ExecuteScalar(SqlConnection connection, CommandType commandType,  string  commandText,  params  SqlParameter[] commandParameters)
1188          {
1189               if ( connection  ==   null  )  throw   new  ArgumentNullException(  " connection "  );
1190 
1191               //  Create a command and prepare it for execution
1192              SqlCommand cmd  =   new  SqlCommand();
1193 
1194               bool  mustCloseConnection  =   false ;
1195              PrepareCommand(cmd, connection, (SqlTransaction) null , commandType, commandText, commandParameters,  out  mustCloseConnection );
1196                  
1197               //  Execute the command & return the results
1198               object  retval  =  cmd.ExecuteScalar();
1199                  
1200               //  Detach the SqlParameters from the command object, so they can be used again
1201              cmd.Parameters.Clear();
1202 
1203               if ( mustCloseConnection )
1204                  connection.Close();
1205 
1206               return  retval;
1207          }
1208 
1209           ///   <summary>
1210           ///  Execute a stored procedure via a SqlCommand (that returns a 1x1 resultset) against the specified SqlConnection 
1211           ///  using the provided parameter values.  This method will query the database to discover the parameters for the 
1212           ///  stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
1213           ///   </summary>
1214           ///   <remarks>
1215           ///  This method provides no access to output parameters or the stored procedure's return value parameter.
1216           ///  
1217           ///  e.g.:  
1218           ///   int orderCount = (int)ExecuteScalar(conn, "GetOrderCount", 24, 36);
1219           ///   </remarks>
1220           ///   <param name="connection"> A valid SqlConnection </param>
1221           ///   <param name="spName"> The name of the stored procedure </param>
1222           ///   <param name="parameterValues"> An array of objects to be assigned as the input values of the stored procedure </param>
1223           ///   <returns> An object containing the value in the 1x1 resultset generated by the command </returns>
1224           public   static   object  ExecuteScalar(SqlConnection connection,  string  spName,  params   object [] parameterValues)
1225          {
1226               if ( connection  ==   null  )  throw   new  ArgumentNullException(  " connection "  );
1227               if ( spName  ==   null   ||  spName.Length  ==   0  )  throw   new  ArgumentNullException(  " spName "  );
1228 
1229               //  If we receive parameter values, we need to figure out where they go
1230               if  ((parameterValues  !=   null )  &&  (parameterValues.Length  >   0 )) 
1231              {
1232                   //  Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
1233                  SqlParameter[] commandParameters  =  SqlHelperParameterCache.GetSpParameterSet(connection, spName);
1234 
1235                   //  Assign the provided values to these parameters based on parameter order
1236                  AssignParameterValues(commandParameters, parameterValues);
1237 
1238                   //  Call the overload that takes an array of SqlParameters
1239                   return  ExecuteScalar(connection, CommandType.StoredProcedure, spName, commandParameters);
1240              }
1241               else  
1242              {
1243                   //  Otherwise we can just call the SP without params
1244                   return  ExecuteScalar(connection, CommandType.StoredProcedure, spName);
1245              }
1246          }
1247 
1248           ///   <summary>
1249           ///  Execute a SqlCommand (that returns a 1x1 resultset and takes no parameters) against the provided SqlTransaction. 
1250           ///   </summary>
1251           ///   <remarks>
1252           ///  e.g.:  
1253           ///   int orderCount = (int)ExecuteScalar(trans, CommandType.StoredProcedure, "GetOrderCount");
1254           ///   </remarks>
1255           ///   <param name="transaction"> A valid SqlTransaction </param>
1256           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
1257           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
1258           ///   <returns> An object containing the value in the 1x1 resultset generated by the command </returns>
1259           public   static   object  ExecuteScalar(SqlTransaction transaction, CommandType commandType,  string  commandText)
1260          {
1261               //  Pass through the call providing null for the set of SqlParameters
1262               return  ExecuteScalar(transaction, commandType, commandText, (SqlParameter[]) null );
1263          }
1264 
1265           ///   <summary>
1266           ///  Execute a SqlCommand (that returns a 1x1 resultset) against the specified SqlTransaction
1267           ///  using the provided parameters.
1268           ///   </summary>
1269           ///   <remarks>
1270           ///  e.g.:  
1271           ///   int orderCount = (int)ExecuteScalar(trans, CommandType.StoredProcedure, "GetOrderCount", new SqlParameter("@prodid", 24));
1272           ///   </remarks>
1273           ///   <param name="transaction"> A valid SqlTransaction </param>
1274           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
1275           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
1276           ///   <param name="commandParameters"> An array of SqlParamters used to execute the command </param>
1277           ///   <returns> An object containing the value in the 1x1 resultset generated by the command </returns>
1278           public   static   object  ExecuteScalar(SqlTransaction transaction, CommandType commandType,  string  commandText,  params  SqlParameter[] commandParameters)
1279          {
1280               if ( transaction  ==   null  )  throw   new  ArgumentNullException(  " transaction "  );
1281               if ( transaction  !=   null   &&  transaction.Connection  ==   null  )  throw   new  ArgumentException(  " The transaction was rollbacked or commited, please provide an open transaction. " ,  " transaction "  );
1282 
1283               //  Create a command and prepare it for execution
1284              SqlCommand cmd  =   new  SqlCommand();
1285               bool  mustCloseConnection  =   false ;
1286              PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters,  out  mustCloseConnection );
1287                  
1288               //  Execute the command & return the results
1289               object  retval  =  cmd.ExecuteScalar();
1290                  
1291               //  Detach the SqlParameters from the command object, so they can be used again
1292              cmd.Parameters.Clear();
1293               return  retval;
1294          }
1295 
1296           ///   <summary>
1297           ///  Execute a stored procedure via a SqlCommand (that returns a 1x1 resultset) against the specified
1298           ///  SqlTransaction using the provided parameter values.  This method will query the database to discover the parameters for the 
1299           ///  stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
1300           ///   </summary>
1301           ///   <remarks>
1302           ///  This method provides no access to output parameters or the stored procedure's return value parameter.
1303           ///  
1304           ///  e.g.:  
1305           ///   int orderCount = (int)ExecuteScalar(trans, "GetOrderCount", 24, 36);
1306           ///   </remarks>
1307           ///   <param name="transaction"> A valid SqlTransaction </param>
1308           ///   <param name="spName"> The name of the stored procedure </param>
1309           ///   <param name="parameterValues"> An array of objects to be assigned as the input values of the stored procedure </param>
1310           ///   <returns> An object containing the value in the 1x1 resultset generated by the command </returns>
1311           public   static   object  ExecuteScalar(SqlTransaction transaction,  string  spName,  params   object [] parameterValues)
1312          {
1313               if ( transaction  ==   null  )  throw   new  ArgumentNullException(  " transaction "  );
1314               if ( transaction  !=   null   &&  transaction.Connection  ==   null  )  throw   new  ArgumentException(  " The transaction was rollbacked or commited, please provide an open transaction. " ,  " transaction "  );
1315               if ( spName  ==   null   ||  spName.Length  ==   0  )  throw   new  ArgumentNullException(  " spName "  );
1316 
1317               //  If we receive parameter values, we need to figure out where they go
1318               if  ((parameterValues  !=   null )  &&  (parameterValues.Length  >   0 )) 
1319              {
1320                   //  PPull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
1321                  SqlParameter[] commandParameters  =  SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
1322 
1323                   //  Assign the provided values to these parameters based on parameter order
1324                  AssignParameterValues(commandParameters, parameterValues);
1325 
1326                   //  Call the overload that takes an array of SqlParameters
1327                   return  ExecuteScalar(transaction, CommandType.StoredProcedure, spName, commandParameters);
1328              }
1329               else  
1330              {
1331                   //  Otherwise we can just call the SP without params
1332                   return  ExecuteScalar(transaction, CommandType.StoredProcedure, spName);
1333              }
1334          }
1335 
1336           #endregion  ExecuteScalar    
1337 
1338           #region  ExecuteXmlReader
1339           ///   <summary>
1340           ///  Execute a SqlCommand (that returns a resultset and takes no parameters) against the provided SqlConnection. 
1341           ///   </summary>
1342           ///   <remarks>
1343           ///  e.g.:  
1344           ///   XmlReader r = ExecuteXmlReader(conn, CommandType.StoredProcedure, "GetOrders");
1345           ///   </remarks>
1346           ///   <param name="connection"> A valid SqlConnection </param>
1347           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
1348           ///   <param name="commandText"> The stored procedure name or T-SQL command using "FOR XML AUTO" </param>
1349           ///   <returns> An XmlReader containing the resultset generated by the command </returns>
1350           public   static  XmlReader ExecuteXmlReader(SqlConnection connection, CommandType commandType,  string  commandText)
1351          {
1352               //  Pass through the call providing null for the set of SqlParameters
1353               return  ExecuteXmlReader(connection, commandType, commandText, (SqlParameter[]) null );
1354          }
1355 
1356           ///   <summary>
1357           ///  Execute a SqlCommand (that returns a resultset) against the specified SqlConnection 
1358           ///  using the provided parameters.
1359           ///   </summary>
1360           ///   <remarks>
1361           ///  e.g.:  
1362           ///   XmlReader r = ExecuteXmlReader(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
1363           ///   </remarks>
1364           ///   <param name="connection"> A valid SqlConnection </param>
1365           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
1366           ///   <param name="commandText"> The stored procedure name or T-SQL command using "FOR XML AUTO" </param>
1367           ///   <param name="commandParameters"> An array of SqlParamters used to execute the command </param>
1368           ///   <returns> An XmlReader containing the resultset generated by the command </returns>
1369           public   static  XmlReader ExecuteXmlReader(SqlConnection connection, CommandType commandType,  string  commandText,  params  SqlParameter[] commandParameters)
1370          {
1371               if ( connection  ==   null  )  throw   new  ArgumentNullException(  " connection "  );
1372 
1373               bool  mustCloseConnection  =   false ;
1374               //  Create a command and prepare it for execution
1375              SqlCommand cmd  =   new  SqlCommand();
1376               try
1377              {
1378                  PrepareCommand(cmd, connection, (SqlTransaction) null , commandType, commandText, commandParameters,  out  mustCloseConnection );
1379              
1380                   //  Create the DataAdapter & DataSet
1381                  XmlReader retval  =  cmd.ExecuteXmlReader();
1382              
1383                   //  Detach the SqlParameters from the command object, so they can be used again
1384                  cmd.Parameters.Clear();
1385 
1386                   return  retval;
1387              }
1388               catch
1389              {    
1390                   if ( mustCloseConnection )
1391                      connection.Close();
1392                   throw ;
1393              }
1394          }
1395 
1396           ///   <summary>
1397           ///  Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlConnection 
1398           ///  using the provided parameter values.  This method will query the database to discover the parameters for the 
1399           ///  stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
1400           ///   </summary>
1401           ///   <remarks>
1402           ///  This method provides no access to output parameters or the stored procedure's return value parameter.
1403           ///  
1404           ///  e.g.:  
1405           ///   XmlReader r = ExecuteXmlReader(conn, "GetOrders", 24, 36);
1406           ///   </remarks>
1407           ///   <param name="connection"> A valid SqlConnection </param>
1408           ///   <param name="spName"> The name of the stored procedure using "FOR XML AUTO" </param>
1409           ///   <param name="parameterValues"> An array of objects to be assigned as the input values of the stored procedure </param>
1410           ///   <returns> An XmlReader containing the resultset generated by the command </returns>
1411           public   static  XmlReader ExecuteXmlReader(SqlConnection connection,  string  spName,  params   object [] parameterValues)
1412          {
1413               if ( connection  ==   null  )  throw   new  ArgumentNullException(  " connection "  );
1414               if ( spName  ==   null   ||  spName.Length  ==   0  )  throw   new  ArgumentNullException(  " spName "  );
1415 
1416               //  If we receive parameter values, we need to figure out where they go
1417               if  ((parameterValues  !=   null )  &&  (parameterValues.Length  >   0 )) 
1418              {
1419                   //  Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
1420                  SqlParameter[] commandParameters  =  SqlHelperParameterCache.GetSpParameterSet(connection, spName);
1421 
1422                   //  Assign the provided values to these parameters based on parameter order
1423                  AssignParameterValues(commandParameters, parameterValues);
1424 
1425                   //  Call the overload that takes an array of SqlParameters
1426                   return  ExecuteXmlReader(connection, CommandType.StoredProcedure, spName, commandParameters);
1427              }
1428               else  
1429              {
1430                   //  Otherwise we can just call the SP without params
1431                   return  ExecuteXmlReader(connection, CommandType.StoredProcedure, spName);
1432              }
1433          }
1434 
1435           ///   <summary>
1436           ///  Execute a SqlCommand (that returns a resultset and takes no parameters) against the provided SqlTransaction. 
1437           ///   </summary>
1438           ///   <remarks>
1439           ///  e.g.:  
1440           ///   XmlReader r = ExecuteXmlReader(trans, CommandType.StoredProcedure, "GetOrders");
1441           ///   </remarks>
1442           ///   <param name="transaction"> A valid SqlTransaction </param>
1443           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
1444           ///   <param name="commandText"> The stored procedure name or T-SQL command using "FOR XML AUTO" </param>
1445           ///   <returns> An XmlReader containing the resultset generated by the command </returns>
1446           public   static  XmlReader ExecuteXmlReader(SqlTransaction transaction, CommandType commandType,  string  commandText)
1447          {
1448               //  Pass through the call providing null for the set of SqlParameters
1449               return  ExecuteXmlReader(transaction, commandType, commandText, (SqlParameter[]) null );
1450          }
1451 
1452           ///   <summary>
1453           ///  Execute a SqlCommand (that returns a resultset) against the specified SqlTransaction
1454           ///  using the provided parameters.
1455           ///   </summary>
1456           ///   <remarks>
1457           ///  e.g.:  
1458           ///   XmlReader r = ExecuteXmlReader(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
1459           ///   </remarks>
1460           ///   <param name="transaction"> A valid SqlTransaction </param>
1461           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
1462           ///   <param name="commandText"> The stored procedure name or T-SQL command using "FOR XML AUTO" </param>
1463           ///   <param name="commandParameters"> An array of SqlParamters used to execute the command </param>
1464           ///   <returns> An XmlReader containing the resultset generated by the command </returns>
1465           public   static  XmlReader ExecuteXmlReader(SqlTransaction transaction, CommandType commandType,  string  commandText,  params  SqlParameter[] commandParameters)
1466          {
1467               if ( transaction  ==   null  )  throw   new  ArgumentNullException(  " transaction "  );
1468               if ( transaction  !=   null   &&  transaction.Connection  ==   null  )  throw   new  ArgumentException(  " The transaction was rollbacked or commited, please provide an open transaction. " ,  " transaction "  );
1469 
1470               //  Create a command and prepare it for execution
1471              SqlCommand cmd  =   new  SqlCommand();
1472               bool  mustCloseConnection  =   false ;
1473              PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters,  out  mustCloseConnection );
1474              
1475               //  Create the DataAdapter & DataSet
1476              XmlReader retval  =  cmd.ExecuteXmlReader();
1477              
1478               //  Detach the SqlParameters from the command object, so they can be used again
1479              cmd.Parameters.Clear();
1480               return  retval;            
1481          }
1482 
1483           ///   <summary>
1484           ///  Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified 
1485           ///  SqlTransaction using the provided parameter values.  This method will query the database to discover the parameters for the 
1486           ///  stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
1487           ///   </summary>
1488           ///   <remarks>
1489           ///  This method provides no access to output parameters or the stored procedure's return value parameter.
1490           ///  
1491           ///  e.g.:  
1492           ///   XmlReader r = ExecuteXmlReader(trans, "GetOrders", 24, 36);
1493           ///   </remarks>
1494           ///   <param name="transaction"> A valid SqlTransaction </param>
1495           ///   <param name="spName"> The name of the stored procedure </param>
1496           ///   <param name="parameterValues"> An array of objects to be assigned as the input values of the stored procedure </param>
1497           ///   <returns> A dataset containing the resultset generated by the command </returns>
1498           public   static  XmlReader ExecuteXmlReader(SqlTransaction transaction,  string  spName,  params   object [] parameterValues)
1499          {
1500               if ( transaction  ==   null  )  throw   new  ArgumentNullException(  " transaction "  );
1501               if ( transaction  !=   null   &&  transaction.Connection  ==   null  )  throw   new  ArgumentException(  " The transaction was rollbacked or commited, please provide an open transaction. " ,  " transaction "  );
1502               if ( spName  ==   null   ||  spName.Length  ==   0  )  throw   new  ArgumentNullException(  " spName "  );
1503 
1504               //  If we receive parameter values, we need to figure out where they go
1505               if  ((parameterValues  !=   null )  &&  (parameterValues.Length  >   0 )) 
1506              {
1507                   //  Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
1508                  SqlParameter[] commandParameters  =  SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
1509 
1510                   //  Assign the provided values to these parameters based on parameter order
1511                  AssignParameterValues(commandParameters, parameterValues);
1512 
1513                   //  Call the overload that takes an array of SqlParameters
1514                   return  ExecuteXmlReader(transaction, CommandType.StoredProcedure, spName, commandParameters);
1515              }
1516               else  
1517              {
1518                   //  Otherwise we can just call the SP without params
1519                   return  ExecuteXmlReader(transaction, CommandType.StoredProcedure, spName);
1520              }
1521          }
1522 
1523           #endregion  ExecuteXmlReader
1524 
1525           #region  FillDataset
1526           ///   <summary>
1527           ///  Execute a SqlCommand (that returns a resultset and takes no parameters) against the database specified in 
1528           ///  the connection string. 
1529           ///   </summary>
1530           ///   <remarks>
1531           ///  e.g.:  
1532           ///   FillDataset(connString, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"});
1533           ///   </remarks>
1534           ///   <param name="connectionString"> A valid connection string for a SqlConnection </param>
1535           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
1536           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
1537           ///   <param name="dataSet"> A dataset wich will contain the resultset generated by the command </param>
1538           ///   <param name="tableNames"> This array will be used to create table mappings allowing the DataTables to be referenced
1539           ///  by a user defined name (probably the actual table name) </param>
1540           public   static   void  FillDataset( string  connectionString, CommandType commandType,  string  commandText, DataSet dataSet,  string [] tableNames)
1541          {
1542               if ( connectionString  ==   null   ||  connectionString.Length  ==   0  )  throw   new  ArgumentNullException(  " connectionString "  );
1543               if ( dataSet  ==   null  )  throw   new  ArgumentNullException(  " dataSet "  );
1544              
1545               //  Create & open a SqlConnection, and dispose of it after we are done
1546               using  (SqlConnection connection  =   new  SqlConnection(connectionString))
1547              {
1548                  connection.Open();
1549 
1550                   //  Call the overload that takes a connection in place of the connection string
1551                  FillDataset(connection, commandType, commandText, dataSet, tableNames);
1552              }
1553          }
1554 
1555           ///   <summary>
1556           ///  Execute a SqlCommand (that returns a resultset) against the database specified in the connection string 
1557           ///  using the provided parameters.
1558           ///   </summary>
1559           ///   <remarks>
1560           ///  e.g.:  
1561           ///   FillDataset(connString, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, new SqlParameter("@prodid", 24));
1562           ///   </remarks>
1563           ///   <param name="connectionString"> A valid connection string for a SqlConnection </param>
1564           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
1565           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
1566           ///   <param name="commandParameters"> An array of SqlParamters used to execute the command </param>
1567           ///   <param name="dataSet"> A dataset wich will contain the resultset generated by the command </param>
1568           ///   <param name="tableNames"> This array will be used to create table mappings allowing the DataTables to be referenced
1569           ///  by a user defined name (probably the actual table name)
1570           ///   </param>
1571           public   static   void  FillDataset( string  connectionString, CommandType commandType,
1572               string  commandText, DataSet dataSet,  string [] tableNames,
1573               params  SqlParameter[] commandParameters)
1574          {
1575               if ( connectionString  ==   null   ||  connectionString.Length  ==   0  )  throw   new  ArgumentNullException(  " connectionString "  );
1576               if ( dataSet  ==   null  )  throw   new  ArgumentNullException(  " dataSet "  );
1577               //  Create & open a SqlConnection, and dispose of it after we are done
1578               using  (SqlConnection connection  =   new  SqlConnection(connectionString))
1579              {
1580                  connection.Open();
1581 
1582                   //  Call the overload that takes a connection in place of the connection string
1583                  FillDataset(connection, commandType, commandText, dataSet, tableNames, commandParameters);
1584              }
1585          }
1586 
1587           ///   <summary>
1588           ///  Execute a stored procedure via a SqlCommand (that returns a resultset) against the database specified in 
1589           ///  the connection string using the provided parameter values.  This method will query the database to discover the parameters for the 
1590           ///  stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
1591           ///   </summary>
1592           ///   <remarks>
1593           ///  This method provides no access to output parameters or the stored procedure's return value parameter.
1594           ///  
1595           ///  e.g.:  
1596           ///   FillDataset(connString, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, 24);
1597           ///   </remarks>
1598           ///   <param name="connectionString"> A valid connection string for a SqlConnection </param>
1599           ///   <param name="spName"> The name of the stored procedure </param>
1600           ///   <param name="dataSet"> A dataset wich will contain the resultset generated by the command </param>
1601           ///   <param name="tableNames"> This array will be used to create table mappings allowing the DataTables to be referenced
1602           ///  by a user defined name (probably the actual table name)
1603           ///   </param>     
1604           ///   <param name="parameterValues"> An array of objects to be assigned as the input values of the stored procedure </param>
1605           public   static   void  FillDataset( string  connectionString,  string  spName,
1606              DataSet dataSet,  string [] tableNames,
1607               params   object [] parameterValues)
1608          {
1609               if ( connectionString  ==   null   ||  connectionString.Length  ==   0  )  throw   new  ArgumentNullException(  " connectionString "  );
1610               if ( dataSet  ==   null  )  throw   new  ArgumentNullException(  " dataSet "  );
1611               //  Create & open a SqlConnection, and dispose of it after we are done
1612               using  (SqlConnection connection  =   new  SqlConnection(connectionString))
1613              {
1614                  connection.Open();
1615 
1616                   //  Call the overload that takes a connection in place of the connection string
1617                  FillDataset (connection, spName, dataSet, tableNames, parameterValues);
1618              }
1619          }
1620 
1621           ///   <summary>
1622           ///  Execute a SqlCommand (that returns a resultset and takes no parameters) against the provided SqlConnection. 
1623           ///   </summary>
1624           ///   <remarks>
1625           ///  e.g.:  
1626           ///   FillDataset(conn, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"});
1627           ///   </remarks>
1628           ///   <param name="connection"> A valid SqlConnection </param>
1629           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
1630           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
1631           ///   <param name="dataSet"> A dataset wich will contain the resultset generated by the command </param>
1632           ///   <param name="tableNames"> This array will be used to create table mappings allowing the DataTables to be referenced
1633           ///  by a user defined name (probably the actual table name)
1634           ///   </param>     
1635           public   static   void  FillDataset(SqlConnection connection, CommandType commandType, 
1636               string  commandText, DataSet dataSet,  string [] tableNames)
1637          {
1638              FillDataset(connection, commandType, commandText, dataSet, tableNames,  null );
1639          }
1640 
1641           ///   <summary>
1642           ///  Execute a SqlCommand (that returns a resultset) against the specified SqlConnection 
1643           ///  using the provided parameters.
1644           ///   </summary>
1645           ///   <remarks>
1646           ///  e.g.:  
1647           ///   FillDataset(conn, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, new SqlParameter("@prodid", 24));
1648           ///   </remarks>
1649           ///   <param name="connection"> A valid SqlConnection </param>
1650           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
1651           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
1652           ///   <param name="dataSet"> A dataset wich will contain the resultset generated by the command </param>
1653           ///   <param name="tableNames"> This array will be used to create table mappings allowing the DataTables to be referenced
1654           ///  by a user defined name (probably the actual table name)
1655           ///   </param>
1656           ///   <param name="commandParameters"> An array of SqlParamters used to execute the command </param>
1657           public   static   void  FillDataset(SqlConnection connection, CommandType commandType, 
1658               string  commandText, DataSet dataSet,  string [] tableNames,
1659               params  SqlParameter[] commandParameters)
1660          {
1661              FillDataset(connection,  null , commandType, commandText, dataSet, tableNames, commandParameters);
1662          }
1663 
1664           ///   <summary>
1665           ///  Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlConnection 
1666           ///  using the provided parameter values.  This method will query the database to discover the parameters for the 
1667           ///  stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
1668           ///   </summary>
1669           ///   <remarks>
1670           ///  This method provides no access to output parameters or the stored procedure's return value parameter.
1671           ///  
1672           ///  e.g.:  
1673           ///   FillDataset(conn, "GetOrders", ds, new string[] {"orders"}, 24, 36);
1674           ///   </remarks>
1675           ///   <param name="connection"> A valid SqlConnection </param>
1676           ///   <param name="spName"> The name of the stored procedure </param>
1677           ///   <param name="dataSet"> A dataset wich will contain the resultset generated by the command </param>
1678           ///   <param name="tableNames"> This array will be used to create table mappings allowing the DataTables to be referenced
1679           ///  by a user defined name (probably the actual table name)
1680           ///   </param>
1681           ///   <param name="parameterValues"> An array of objects to be assigned as the input values of the stored procedure </param>
1682           public   static   void  FillDataset(SqlConnection connection,  string  spName, 
1683              DataSet dataSet,  string [] tableNames,
1684               params   object [] parameterValues)
1685          {
1686               if  ( connection  ==   null  )  throw   new  ArgumentNullException(  " connection "  );
1687               if  (dataSet  ==   null  )  throw   new  ArgumentNullException(  " dataSet "  );
1688               if ( spName  ==   null   ||  spName.Length  ==   0  )  throw   new  ArgumentNullException(  " spName "  );
1689 
1690               //  If we receive parameter values, we need to figure out where they go
1691               if  ((parameterValues  !=   null )  &&  (parameterValues.Length  >   0 )) 
1692              {
1693                   //  Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
1694                  SqlParameter[] commandParameters  =  SqlHelperParameterCache.GetSpParameterSet(connection, spName);
1695 
1696                   //  Assign the provided values to these parameters based on parameter order
1697                  AssignParameterValues(commandParameters, parameterValues);
1698 
1699                   //  Call the overload that takes an array of SqlParameters
1700                  FillDataset(connection, CommandType.StoredProcedure, spName, dataSet, tableNames, commandParameters);
1701              }
1702               else  
1703              {
1704                   //  Otherwise we can just call the SP without params
1705                  FillDataset(connection, CommandType.StoredProcedure, spName, dataSet, tableNames);
1706              }    
1707          }
1708 
1709           ///   <summary>
1710           ///  Execute a SqlCommand (that returns a resultset and takes no parameters) against the provided SqlTransaction. 
1711           ///   </summary>
1712           ///   <remarks>
1713           ///  e.g.:  
1714           ///   FillDataset(trans, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"});
1715           ///   </remarks>
1716           ///   <param name="transaction"> A valid SqlTransaction </param>
1717           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
1718           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
1719           ///   <param name="dataSet"> A dataset wich will contain the resultset generated by the command </param>
1720           ///   <param name="tableNames"> This array will be used to create table mappings allowing the DataTables to be referenced
1721           ///  by a user defined name (probably the actual table name)
1722           ///   </param>
1723           public   static   void  FillDataset(SqlTransaction transaction, CommandType commandType, 
1724               string  commandText,
1725              DataSet dataSet,  string [] tableNames)
1726          {
1727              FillDataset (transaction, commandType, commandText, dataSet, tableNames,  null );    
1728          }
1729 
1730           ///   <summary>
1731           ///  Execute a SqlCommand (that returns a resultset) against the specified SqlTransaction
1732           ///  using the provided parameters.
1733           ///   </summary>
1734           ///   <remarks>
1735           ///  e.g.:  
1736           ///   FillDataset(trans, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, new SqlParameter("@prodid", 24));
1737           ///   </remarks>
1738           ///   <param name="transaction"> A valid SqlTransaction </param>
1739           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
1740           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
1741           ///   <param name="dataSet"> A dataset wich will contain the resultset generated by the command </param>
1742           ///   <param name="tableNames"> This array will be used to create table mappings allowing the DataTables to be referenced
1743           ///  by a user defined name (probably the actual table name)
1744           ///   </param>
1745           ///   <param name="commandParameters"> An array of SqlParamters used to execute the command </param>
1746           public   static   void  FillDataset(SqlTransaction transaction, CommandType commandType, 
1747               string  commandText, DataSet dataSet,  string [] tableNames,
1748               params  SqlParameter[] commandParameters)
1749          {
1750              FillDataset(transaction.Connection, transaction, commandType, commandText, dataSet, tableNames, commandParameters);
1751          }
1752 
1753           ///   <summary>
1754           ///  Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified 
1755           ///  SqlTransaction using the provided parameter values.  This method will query the database to discover the parameters for the 
1756           ///  stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
1757           ///   </summary>
1758           ///   <remarks>
1759           ///  This method provides no access to output parameters or the stored procedure's return value parameter.
1760           ///  
1761           ///  e.g.:  
1762           ///   FillDataset(trans, "GetOrders", ds, new string[]{"orders"}, 24, 36);
1763           ///   </remarks>
1764           ///   <param name="transaction"> A valid SqlTransaction </param>
1765           ///   <param name="spName"> The name of the stored procedure </param>
1766           ///   <param name="dataSet"> A dataset wich will contain the resultset generated by the command </param>
1767           ///   <param name="tableNames"> This array will be used to create table mappings allowing the DataTables to be referenced
1768           ///  by a user defined name (probably the actual table name)
1769           ///   </param>
1770           ///   <param name="parameterValues"> An array of objects to be assigned as the input values of the stored procedure </param>
1771           public   static   void  FillDataset(SqlTransaction transaction,  string  spName,
1772              DataSet dataSet,  string [] tableNames,
1773               params   object [] parameterValues) 
1774          {
1775               if ( transaction  ==   null  )  throw   new  ArgumentNullException(  " transaction "  );
1776               if ( transaction  !=   null   &&  transaction.Connection  ==   null  )  throw   new  ArgumentException(  " The transaction was rollbacked or commited, please provide an open transaction. " ,  " transaction "  );
1777               if ( dataSet  ==   null  )  throw   new  ArgumentNullException(  " dataSet "  );
1778               if ( spName  ==   null   ||  spName.Length  ==   0  )  throw   new  ArgumentNullException(  " spName "  );
1779 
1780               //  If we receive parameter values, we need to figure out where they go
1781               if  ((parameterValues  !=   null )  &&  (parameterValues.Length  >   0 )) 
1782              {
1783                   //  Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
1784                  SqlParameter[] commandParameters  =  SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
1785 
1786                   //  Assign the provided values to these parameters based on parameter order
1787                  AssignParameterValues(commandParameters, parameterValues);
1788 
1789                   //  Call the overload that takes an array of SqlParameters
1790                  FillDataset(transaction, CommandType.StoredProcedure, spName, dataSet, tableNames, commandParameters);
1791              }
1792               else  
1793              {
1794                   //  Otherwise we can just call the SP without params
1795                  FillDataset(transaction, CommandType.StoredProcedure, spName, dataSet, tableNames);
1796              }    
1797          }
1798 
1799           ///   <summary>
1800           ///  Private helper method that execute a SqlCommand (that returns a resultset) against the specified SqlTransaction and SqlConnection
1801           ///  using the provided parameters.
1802           ///   </summary>
1803           ///   <remarks>
1804           ///  e.g.:  
1805           ///   FillDataset(conn, trans, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, new SqlParameter("@prodid", 24));
1806           ///   </remarks>
1807           ///   <param name="connection"> A valid SqlConnection </param>
1808           ///   <param name="transaction"> A valid SqlTransaction </param>
1809           ///   <param name="commandType"> The CommandType (stored procedure, text, etc.) </param>
1810           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
1811           ///   <param name="dataSet"> A dataset wich will contain the resultset generated by the command </param>
1812           ///   <param name="tableNames"> This array will be used to create table mappings allowing the DataTables to be referenced
1813           ///  by a user defined name (probably the actual table name)
1814           ///   </param>
1815           ///   <param name="commandParameters"> An array of SqlParamters used to execute the command </param>
1816           private   static   void  FillDataset(SqlConnection connection, SqlTransaction transaction, CommandType commandType, 
1817               string  commandText, DataSet dataSet,  string [] tableNames,
1818               params  SqlParameter[] commandParameters)
1819          {
1820               if ( connection  ==   null  )  throw   new  ArgumentNullException(  " connection "  );
1821               if ( dataSet  ==   null  )  throw   new  ArgumentNullException(  " dataSet "  );
1822 
1823               //  Create a command and prepare it for execution
1824              SqlCommand command  =   new  SqlCommand();
1825               bool  mustCloseConnection  =   false ;
1826              PrepareCommand(command, connection, transaction, commandType, commandText, commandParameters,  out  mustCloseConnection );
1827                  
1828               //  Create the DataAdapter & DataSet
1829               using ( SqlDataAdapter dataAdapter  =   new  SqlDataAdapter(command) )
1830              {
1831                  
1832                   //  Add the table mappings specified by the user
1833                   if  (tableNames  !=   null   &&  tableNames.Length  >   0 )
1834                  {
1835                       string  tableName  =   " Table " ;
1836                       for  ( int  index = 0 ; index  <  tableNames.Length; index ++ )
1837                      {
1838                           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 "  );
1839                          dataAdapter.TableMappings.Add(tableName, tableNames[index]);
1840                          tableName  +=  (index  +   1 ).ToString();
1841                      }
1842                  }
1843                  
1844                   //  Fill the DataSet using default values for DataTable names, etc
1845                  dataAdapter.Fill(dataSet);
1846 
1847                   //  Detach the SqlParameters from the command object, so they can be used again
1848                  command.Parameters.Clear();
1849              }
1850 
1851               if ( mustCloseConnection )
1852                  connection.Close();
1853          }
1854           #endregion
1855          
1856           #region  UpdateDataset
1857           ///   <summary>
1858           ///  Executes the respective command for each inserted, updated, or deleted row in the DataSet.
1859           ///   </summary>
1860           ///   <remarks>
1861           ///  e.g.:  
1862           ///   UpdateDataset(conn, insertCommand, deleteCommand, updateCommand, dataSet, "Order");
1863           ///   </remarks>
1864           ///   <param name="insertCommand"> A valid transact-SQL statement or stored procedure to insert new records into the data source </param>
1865           ///   <param name="deleteCommand"> A valid transact-SQL statement or stored procedure to delete records from the data source </param>
1866           ///   <param name="updateCommand"> A valid transact-SQL statement or stored procedure used to update records in the data source </param>
1867           ///   <param name="dataSet"> The DataSet used to update the data source </param>
1868           ///   <param name="tableName"> The DataTable used to update the data source. </param>
1869           public   static   void  UpdateDataset(SqlCommand insertCommand, SqlCommand deleteCommand, SqlCommand updateCommand, DataSet dataSet,  string  tableName)
1870          {
1871               if ( insertCommand  ==   null  )  throw   new  ArgumentNullException(  " insertCommand "  );
1872               if ( deleteCommand  ==   null  )  throw   new  ArgumentNullException(  " deleteCommand "  );
1873               if ( updateCommand  ==   null  )  throw   new  ArgumentNullException(  " updateCommand "  );
1874               if ( tableName  ==   null   ||  tableName.Length  ==   0  )  throw   new  ArgumentNullException(  " tableName "  ); 
1875 
1876               //  Create a SqlDataAdapter, and dispose of it after we are done
1877               using  (SqlDataAdapter dataAdapter  =   new  SqlDataAdapter())
1878              {
1879                   //  Set the data adapter commands
1880                  dataAdapter.UpdateCommand  =  updateCommand;
1881                  dataAdapter.InsertCommand  =  insertCommand;
1882                  dataAdapter.DeleteCommand  =  deleteCommand;
1883 
1884                   //  Update the dataset changes in the data source
1885                  dataAdapter.Update (dataSet, tableName); 
1886 
1887                   //  Commit all the changes made to the DataSet
1888                  dataSet.AcceptChanges();
1889              }
1890          }
1891           #endregion
1892 
1893           #region  CreateCommand
1894           ///   <summary>
1895           ///  Simplify the creation of a Sql command object by allowing
1896           ///  a stored procedure and optional parameters to be provided
1897           ///   </summary>
1898           ///   <remarks>
1899           ///  e.g.:  
1900           ///   SqlCommand command = CreateCommand(conn, "AddCustomer", "CustomerID", "CustomerName");
1901           ///   </remarks>
1902           ///   <param name="connection"> A valid SqlConnection object </param>
1903           ///   <param name="spName"> The name of the stored procedure </param>
1904           ///   <param name="sourceColumns"> An array of string to be assigned as the source columns of the stored procedure parameters </param>
1905           ///   <returns> A valid SqlCommand object </returns>
1906           public   static  SqlCommand CreateCommand(SqlConnection connection,  string  spName,  params   string [] sourceColumns) 
1907          {
1908               if ( connection  ==   null  )  throw   new  ArgumentNullException(  " connection "  );
1909               if ( spName  ==   null   ||  spName.Length  ==   0  )  throw   new  ArgumentNullException(  " spName "  );
1910 
1911               //  Create a SqlCommand
1912              SqlCommand cmd  =   new  SqlCommand( spName, connection );
1913              cmd.CommandType  =  CommandType.StoredProcedure;
1914 
1915               //  If we receive parameter values, we need to figure out where they go
1916               if  ((sourceColumns  !=   null )  &&  (sourceColumns.Length  >   0 )) 
1917              {
1918                   //  Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
1919                  SqlParameter[] commandParameters  =  SqlHelperParameterCache.GetSpParameterSet(connection, spName);
1920 
1921                   //  Assign the provided source columns to these parameters based on parameter order
1922                   for  ( int  index = 0 ; index  <  sourceColumns.Length; index ++ )
1923                      commandParameters[index].SourceColumn  =  sourceColumns[index];
1924 
1925                   //  Attach the discovered parameters to the SqlCommand object
1926                  AttachParameters (cmd, commandParameters);
1927              }
1928 
1929               return  cmd;
1930          }
1931           #endregion
1932 
1933           #region  ExecuteNonQueryTypedParams
1934           ///   <summary>
1935           ///  Execute a stored procedure via a SqlCommand (that returns no resultset) against the database specified in 
1936           ///  the connection string using the dataRow column values as the stored procedure's parameters values.
1937           ///  This method will query the database to discover the parameters for the 
1938           ///  stored procedure (the first time each stored procedure is called), and assign the values based on row values.
1939           ///   </summary>
1940           ///   <param name="connectionString"> A valid connection string for a SqlConnection </param>
1941           ///   <param name="spName"> The name of the stored procedure </param>
1942           ///   <param name="dataRow"> The dataRow used to hold the stored procedure's parameter values. </param>
1943           ///   <returns> An int representing the number of rows affected by the command </returns>
1944           public   static   int  ExecuteNonQueryTypedParams(String connectionString, String spName, DataRow dataRow)
1945          {
1946               if ( connectionString  ==   null   ||  connectionString.Length  ==   0  )  throw   new  ArgumentNullException(  " connectionString "  );
1947               if ( spName  ==   null   ||  spName.Length  ==   0  )  throw   new  ArgumentNullException(  " spName "  );
1948              
1949               //  If the row has values, the store procedure parameters must be initialized
1950               if  (dataRow  !=   null   &&  dataRow.ItemArray.Length  >   0 )
1951              {
1952                   //  Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
1953                  SqlParameter[] commandParameters  =  SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
1954                  
1955                   //  Set the parameters values
1956                  AssignParameterValues(commandParameters, dataRow);
1957                                  
1958                   return  SqlHelper.ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName, commandParameters);
1959              }
1960               else
1961              {
1962                   return  SqlHelper.ExecuteNonQuery(connectionString, CommandType.StoredProcedure, spName);
1963              }
1964          }
1965 
1966           ///   <summary>
1967           ///  Execute a stored procedure via a SqlCommand (that returns no resultset) against the specified SqlConnection 
1968           ///  using the dataRow column values as the stored procedure's parameters values.  
1969           ///  This method will query the database to discover the parameters for the 
1970           ///  stored procedure (the first time each stored procedure is called), and assign the values based on row values.
1971           ///   </summary>
1972           ///   <param name="connection"> A valid SqlConnection object </param>
1973           ///   <param name="spName"> The name of the stored procedure </param>
1974           ///   <param name="dataRow"> The dataRow used to hold the stored procedure's parameter values. </param>
1975           ///   <returns> An int representing the number of rows affected by the command </returns>
1976           public   static   int  ExecuteNonQueryTypedParams(SqlConnection connection, String spName, DataRow dataRow)
1977          {
1978               if ( connection  ==   null  )  throw   new  ArgumentNullException(  " connection "  );
1979               if ( spName  ==   null   ||  spName.Length  ==   0  )  throw   new  ArgumentNullException(  " spName "  );
1980 
1981               //  If the row has values, the store procedure parameters must be initialized
1982               if  (dataRow  !=   null   &&  dataRow.ItemArray.Length  >   0 )
1983              {
1984                   //  Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
1985                  SqlParameter[] commandParameters  =  SqlHelperParameterCache.GetSpParameterSet(connection, spName);
1986                  
1987                   //  Set the parameters values
1988                  AssignParameterValues(commandParameters, dataRow);
1989                                  
1990                   return  SqlHelper.ExecuteNonQuery(connection, CommandType.StoredProcedure, spName, commandParameters);
1991              }
1992               else
1993              {
1994                   return  SqlHelper.ExecuteNonQuery(connection, CommandType.StoredProcedure, spName);
1995              }
1996          }
1997 
1998           ///   <summary>
1999           ///  Execute a stored procedure via a SqlCommand (that returns no resultset) against the specified
2000           ///  SqlTransaction using the dataRow column values as the stored procedure's parameters values.
2001           ///  This method will query the database to discover the parameters for the 
2002           ///  stored procedure (the first time each stored procedure is called), and assign the values based on row values.
2003           ///   </summary>
2004           ///   <param name="transaction"> A valid SqlTransaction object </param>
2005           ///   <param name="spName"> The name of the stored procedure </param>
2006           ///   <param name="dataRow"> The dataRow used to hold the stored procedure's parameter values. </param>
2007           ///   <returns> An int representing the number of rows affected by the command </returns>
2008           public   static   int  ExecuteNonQueryTypedParams(SqlTransaction transaction, String spName, DataRow dataRow)
2009          {
2010               if ( transaction  ==   null  )  throw   new  ArgumentNullException(  " transaction "  );
2011               if ( transaction  !=   null   &&  transaction.Connection  ==   null  )  throw   new  ArgumentException(  " The transaction was rollbacked or commited, please provide an open transaction. " ,  " transaction "  );
2012               if ( spName  ==   null   ||  spName.Length  ==   0  )  throw   new  ArgumentNullException(  " spName "  );
2013 
2014               //  Sf the row has values, the store procedure parameters must be initialized
2015               if  (dataRow  !=   null   &&  dataRow.ItemArray.Length  >   0 )
2016              {
2017                   //  Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
2018                  SqlParameter[] commandParameters  =  SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
2019                  
2020                   //  Set the parameters values
2021                  AssignParameterValues(commandParameters, dataRow);
2022                                  
2023                   return  SqlHelper.ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName, commandParameters);
2024              }
2025               else
2026              {
2027                   return  SqlHelper.ExecuteNonQuery(transaction, CommandType.StoredProcedure, spName);
2028              }
2029          }
2030           #endregion
2031 
2032           #region  ExecuteDatasetTypedParams
2033           ///   <summary>
2034           ///  Execute a stored procedure via a SqlCommand (that returns a resultset) against the database specified in 
2035           ///  the connection string using the dataRow column values as the stored procedure's parameters values.
2036           ///  This method will query the database to discover the parameters for the 
2037           ///  stored procedure (the first time each stored procedure is called), and assign the values based on row values.
2038           ///   </summary>
2039           ///   <param name="connectionString"> A valid connection string for a SqlConnection </param>
2040           ///   <param name="spName"> The name of the stored procedure </param>
2041           ///   <param name="dataRow"> The dataRow used to hold the stored procedure's parameter values. </param>
2042           ///   <returns> A dataset containing the resultset generated by the command </returns>
2043           public   static  DataSet ExecuteDatasetTypedParams( string  connectionString, String spName, DataRow dataRow)
2044          {
2045               if ( connectionString  ==   null   ||  connectionString.Length  ==   0  )  throw   new  ArgumentNullException(  " connectionString "  );
2046               if ( spName  ==   null   ||  spName.Length  ==   0  )  throw   new  ArgumentNullException(  " spName "  );
2047 
2048               // If the row has values, the store procedure parameters must be initialized
2049               if  ( dataRow  !=   null   &&  dataRow.ItemArray.Length  >   0 )
2050              {
2051                   //  Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
2052                  SqlParameter[] commandParameters  =  SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
2053                  
2054                   //  Set the parameters values
2055                  AssignParameterValues(commandParameters, dataRow);
2056                  
2057                   return  SqlHelper.ExecuteDataset(connectionString, CommandType.StoredProcedure, spName, commandParameters);
2058              }
2059               else
2060              {
2061                   return  SqlHelper.ExecuteDataset(connectionString, CommandType.StoredProcedure, spName);
2062              }
2063          }
2064 
2065           ///   <summary>
2066           ///  Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlConnection 
2067           ///  using the dataRow column values as the store procedure's parameters values.
2068           ///  This method will query the database to discover the parameters for the 
2069           ///  stored procedure (the first time each stored procedure is called), and assign the values based on row values.
2070           ///   </summary>
2071           ///   <param name="connection"> A valid SqlConnection object </param>
2072           ///   <param name="spName"> The name of the stored procedure </param>
2073           ///   <param name="dataRow"> The dataRow used to hold the stored procedure's parameter values. </param>
2074           ///   <returns> A dataset containing the resultset generated by the command </returns>
2075           public   static  DataSet ExecuteDatasetTypedParams(SqlConnection connection, String spName, DataRow dataRow)
2076          {
2077               if ( connection  ==   null  )  throw   new  ArgumentNullException(  " connection "  );
2078               if ( spName  ==   null   ||  spName.Length  ==   0  )  throw   new  ArgumentNullException(  " spName "  );
2079 
2080               //  If the row has values, the store procedure parameters must be initialized
2081               if ( dataRow  !=   null   &&  dataRow.ItemArray.Length  >   0 )
2082              {
2083                   //  Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
2084                  SqlParameter[] commandParameters  =  SqlHelperParameterCache.GetSpParameterSet(connection, spName);
2085                  
2086                   //  Set the parameters values
2087                  AssignParameterValues(commandParameters, dataRow);
2088                  
2089                   return  SqlHelper.ExecuteDataset(connection, CommandType.StoredProcedure, spName, commandParameters);
2090              }
2091               else
2092              {
2093                   return  SqlHelper.ExecuteDataset(connection, CommandType.StoredProcedure, spName);
2094              }
2095          }
2096 
2097           ///   <summary>
2098           ///  Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlTransaction 
2099           ///  using the dataRow column values as the stored procedure's parameters values.
2100           ///  This method will query the database to discover the parameters for the 
2101           ///  stored procedure (the first time each stored procedure is called), and assign the values based on row values.
2102           ///   </summary>
2103           ///   <param name="transaction"> A valid SqlTransaction object </param>
2104           ///   <param name="spName"> The name of the stored procedure </param>
2105           ///   <param name="dataRow"> The dataRow used to hold the stored procedure's parameter values. </param>
2106           ///   <returns> A dataset containing the resultset generated by the command </returns>
2107           public   static  DataSet ExecuteDatasetTypedParams(SqlTransaction transaction, String spName, DataRow dataRow)
2108          {
2109               if ( transaction  ==   null  )  throw   new  ArgumentNullException(  " transaction "  );
2110               if ( transaction  !=   null   &&  transaction.Connection  ==   null  )  throw   new  ArgumentException(  " The transaction was rollbacked or commited, please provide an open transaction. " ,  " transaction "  );
2111               if ( spName  ==   null   ||  spName.Length  ==   0  )  throw   new  ArgumentNullException(  " spName "  );
2112 
2113               //  If the row has values, the store procedure parameters must be initialized
2114               if ( dataRow  !=   null   &&  dataRow.ItemArray.Length  >   0 )
2115              {
2116                   //  Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
2117                  SqlParameter[] commandParameters  =  SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
2118                  
2119                   //  Set the parameters values
2120                  AssignParameterValues(commandParameters, dataRow);
2121                  
2122                   return  SqlHelper.ExecuteDataset(transaction, CommandType.StoredProcedure, spName, commandParameters);
2123              }
2124               else
2125              {
2126                   return  SqlHelper.ExecuteDataset(transaction, CommandType.StoredProcedure, spName);
2127              }
2128          }
2129 
2130           #endregion
2131 
2132           #region  ExecuteReaderTypedParams
2133           ///   <summary>
2134           ///  Execute a stored procedure via a SqlCommand (that returns a resultset) against the database specified in 
2135           ///  the connection string using the dataRow column values as the stored procedure's parameters values.
2136           ///  This method will query the database to discover the parameters for the 
2137           ///  stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
2138           ///   </summary>
2139           ///   <param name="connectionString"> A valid connection string for a SqlConnection </param>
2140           ///   <param name="spName"> The name of the stored procedure </param>
2141           ///   <param name="dataRow"> The dataRow used to hold the stored procedure's parameter values. </param>
2142           ///   <returns> A SqlDataReader containing the resultset generated by the command </returns>
2143           public   static  SqlDataReader ExecuteReaderTypedParams(String connectionString, String spName, DataRow dataRow)
2144          {
2145               if ( connectionString  ==   null   ||  connectionString.Length  ==   0  )  throw   new  ArgumentNullException(  " connectionString "  );
2146               if ( spName  ==   null   ||  spName.Length  ==   0  )  throw   new  ArgumentNullException(  " spName "  );
2147              
2148               //  If the row has values, the store procedure parameters must be initialized
2149               if  ( dataRow  !=   null   &&  dataRow.ItemArray.Length  >   0  )
2150              {
2151                   //  Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
2152                  SqlParameter[] commandParameters  =  SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
2153                  
2154                   //  Set the parameters values
2155                  AssignParameterValues(commandParameters, dataRow);
2156                  
2157                   return  SqlHelper.ExecuteReader(connectionString, CommandType.StoredProcedure, spName, commandParameters);
2158              }
2159               else
2160              {
2161                   return  SqlHelper.ExecuteReader(connectionString, CommandType.StoredProcedure, spName);
2162              }
2163          }
2164 
2165                  
2166           ///   <summary>
2167           ///  Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlConnection 
2168           ///  using the dataRow column values as the stored procedure's parameters values.
2169           ///  This method will query the database to discover the parameters for the 
2170           ///  stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
2171           ///   </summary>
2172           ///   <param name="connection"> A valid SqlConnection object </param>
2173           ///   <param name="spName"> The name of the stored procedure </param>
2174           ///   <param name="dataRow"> The dataRow used to hold the stored procedure's parameter values. </param>
2175           ///   <returns> A SqlDataReader containing the resultset generated by the command </returns>
2176           public   static  SqlDataReader ExecuteReaderTypedParams(SqlConnection connection, String spName, DataRow dataRow)
2177          {
2178               if ( connection  ==   null  )  throw   new  ArgumentNullException(  " connection "  );
2179               if ( spName  ==   null   ||  spName.Length  ==   0  )  throw   new  ArgumentNullException(  " spName "  );
2180 
2181               //  If the row has values, the store procedure parameters must be initialized
2182               if ( dataRow  !=   null   &&  dataRow.ItemArray.Length  >   0 )
2183              {
2184                   //  Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
2185                  SqlParameter[] commandParameters  =  SqlHelperParameterCache.GetSpParameterSet(connection, spName);
2186                  
2187                   //  Set the parameters values
2188                  AssignParameterValues(commandParameters, dataRow);
2189                  
2190                   return  SqlHelper.ExecuteReader(connection, CommandType.StoredProcedure, spName, commandParameters);
2191              }
2192               else
2193              {
2194                   return  SqlHelper.ExecuteReader(connection, CommandType.StoredProcedure, spName);
2195              }
2196          }
2197          
2198           ///   <summary>
2199           ///  Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlTransaction 
2200           ///  using the dataRow column values as the stored procedure's parameters values.
2201           ///  This method will query the database to discover the parameters for the 
2202           ///  stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
2203           ///   </summary>
2204           ///   <param name="transaction"> A valid SqlTransaction object </param>
2205           ///   <param name="spName"> The name of the stored procedure </param>
2206           ///   <param name="dataRow"> The dataRow used to hold the stored procedure's parameter values. </param>
2207           ///   <returns> A SqlDataReader containing the resultset generated by the command </returns>
2208           public   static  SqlDataReader ExecuteReaderTypedParams(SqlTransaction transaction, String spName, DataRow dataRow)
2209          {
2210               if ( transaction  ==   null  )  throw   new  ArgumentNullException(  " transaction "  );
2211               if ( transaction  !=   null   &&  transaction.Connection  ==   null  )  throw   new  ArgumentException(  " The transaction was rollbacked or commited, please provide an open transaction. " ,  " transaction "  );
2212               if ( spName  ==   null   ||  spName.Length  ==   0  )  throw   new  ArgumentNullException(  " spName "  );
2213 
2214               //  If the row has values, the store procedure parameters must be initialized
2215               if ( dataRow  !=   null   &&  dataRow.ItemArray.Length  >   0  )
2216              {
2217                   //  Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
2218                  SqlParameter[] commandParameters  =  SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
2219                  
2220                   //  Set the parameters values
2221                  AssignParameterValues(commandParameters, dataRow);
2222                  
2223                   return  SqlHelper.ExecuteReader(transaction, CommandType.StoredProcedure, spName, commandParameters);
2224              }
2225               else
2226              {
2227                   return  SqlHelper.ExecuteReader(transaction, CommandType.StoredProcedure, spName);
2228              }
2229          }
2230           #endregion
2231 
2232           #region  ExecuteScalarTypedParams
2233           ///   <summary>
2234           ///  Execute a stored procedure via a SqlCommand (that returns a 1x1 resultset) against the database specified in 
2235           ///  the connection string using the dataRow column values as the stored procedure's parameters values.
2236           ///  This method will query the database to discover the parameters for the 
2237           ///  stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
2238           ///   </summary>
2239           ///   <param name="connectionString"> A valid connection string for a SqlConnection </param>
2240           ///   <param name="spName"> The name of the stored procedure </param>
2241           ///   <param name="dataRow"> The dataRow used to hold the stored procedure's parameter values. </param>
2242           ///   <returns> An object containing the value in the 1x1 resultset generated by the command </returns>
2243           public   static   object  ExecuteScalarTypedParams(String connectionString, String spName, DataRow dataRow)
2244          {
2245               if ( connectionString  ==   null   ||  connectionString.Length  ==   0  )  throw   new  ArgumentNullException(  " connectionString "  );
2246               if ( spName  ==   null   ||  spName.Length  ==   0  )  throw   new  ArgumentNullException(  " spName "  );
2247              
2248               //  If the row has values, the store procedure parameters must be initialized
2249               if ( dataRow  !=   null   &&  dataRow.ItemArray.Length  >   0 )
2250              {
2251                   //  Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
2252                  SqlParameter[] commandParameters  =  SqlHelperParameterCache.GetSpParameterSet(connectionString, spName);
2253                  
2254                   //  Set the parameters values
2255                  AssignParameterValues(commandParameters, dataRow);
2256                  
2257                   return  SqlHelper.ExecuteScalar(connectionString, CommandType.StoredProcedure, spName, commandParameters);
2258              }
2259               else
2260              {
2261                   return  SqlHelper.ExecuteScalar(connectionString, CommandType.StoredProcedure, spName);
2262              }
2263          }
2264 
2265           ///   <summary>
2266           ///  Execute a stored procedure via a SqlCommand (that returns a 1x1 resultset) against the specified SqlConnection 
2267           ///  using the dataRow column values as the stored procedure's parameters values.
2268           ///  This method will query the database to discover the parameters for the 
2269           ///  stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
2270           ///   </summary>
2271           ///   <param name="connection"> A valid SqlConnection object </param>
2272           ///   <param name="spName"> The name of the stored procedure </param>
2273           ///   <param name="dataRow"> The dataRow used to hold the stored procedure's parameter values. </param>
2274           ///   <returns> An object containing the value in the 1x1 resultset generated by the command </returns>
2275           public   static   object  ExecuteScalarTypedParams(SqlConnection connection, String spName, DataRow dataRow)
2276          {
2277               if ( connection  ==   null  )  throw   new  ArgumentNullException(  " connection "  );
2278               if ( spName  ==   null   ||  spName.Length  ==   0  )  throw   new  ArgumentNullException(  " spName "  );
2279 
2280               //  If the row has values, the store procedure parameters must be initialized
2281               if ( dataRow  !=   null   &&  dataRow.ItemArray.Length  >   0 )
2282              {
2283                   //  Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
2284                  SqlParameter[] commandParameters  =  SqlHelperParameterCache.GetSpParameterSet(connection, spName);
2285                  
2286                   //  Set the parameters values
2287                  AssignParameterValues(commandParameters, dataRow);
2288                  
2289                   return  SqlHelper.ExecuteScalar(connection, CommandType.StoredProcedure, spName, commandParameters);
2290              }
2291               else
2292              {
2293                   return  SqlHelper.ExecuteScalar(connection, CommandType.StoredProcedure, spName);
2294              }
2295          }
2296 
2297           ///   <summary>
2298           ///  Execute a stored procedure via a SqlCommand (that returns a 1x1 resultset) against the specified SqlTransaction
2299           ///  using the dataRow column values as the stored procedure's parameters values.
2300           ///  This method will query the database to discover the parameters for the 
2301           ///  stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
2302           ///   </summary>
2303           ///   <param name="transaction"> A valid SqlTransaction object </param>
2304           ///   <param name="spName"> The name of the stored procedure </param>
2305           ///   <param name="dataRow"> The dataRow used to hold the stored procedure's parameter values. </param>
2306           ///   <returns> An object containing the value in the 1x1 resultset generated by the command </returns>
2307           public   static   object  ExecuteScalarTypedParams(SqlTransaction transaction, String spName, DataRow dataRow)
2308          {
2309               if ( transaction  ==   null  )  throw   new  ArgumentNullException(  " transaction "  );
2310               if ( transaction  !=   null   &&  transaction.Connection  ==   null  )  throw   new  ArgumentException(  " The transaction was rollbacked or commited, please provide an open transaction. " ,  " transaction "  );
2311               if ( spName  ==   null   ||  spName.Length  ==   0  )  throw   new  ArgumentNullException(  " spName "  );
2312 
2313               //  If the row has values, the store procedure parameters must be initialized
2314               if ( dataRow  !=   null   &&  dataRow.ItemArray.Length  >   0 )
2315              {
2316                   //  Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
2317                  SqlParameter[] commandParameters  =  SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
2318                  
2319                   //  Set the parameters values
2320                  AssignParameterValues(commandParameters, dataRow);
2321                  
2322                   return  SqlHelper.ExecuteScalar(transaction, CommandType.StoredProcedure, spName, commandParameters);
2323              }
2324               else
2325              {
2326                   return  SqlHelper.ExecuteScalar(transaction, CommandType.StoredProcedure, spName);
2327              }
2328          }
2329           #endregion
2330 
2331           #region  ExecuteXmlReaderTypedParams
2332           ///   <summary>
2333           ///  Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlConnection 
2334           ///  using the dataRow column values as the stored procedure's parameters values.
2335           ///  This method will query the database to discover the parameters for the 
2336           ///  stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
2337           ///   </summary>
2338           ///   <param name="connection"> A valid SqlConnection object </param>
2339           ///   <param name="spName"> The name of the stored procedure </param>
2340           ///   <param name="dataRow"> The dataRow used to hold the stored procedure's parameter values. </param>
2341           ///   <returns> An XmlReader containing the resultset generated by the command </returns>
2342           public   static  XmlReader ExecuteXmlReaderTypedParams(SqlConnection connection, String spName, DataRow dataRow)
2343          {
2344               if ( connection  ==   null  )  throw   new  ArgumentNullException(  " connection "  );
2345               if ( spName  ==   null   ||  spName.Length  ==   0  )  throw   new  ArgumentNullException(  " spName "  );
2346 
2347               //  If the row has values, the store procedure parameters must be initialized
2348               if ( dataRow  !=   null   &&  dataRow.ItemArray.Length  >   0 )
2349              {
2350                   //  Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
2351                  SqlParameter[] commandParameters  =  SqlHelperParameterCache.GetSpParameterSet(connection, spName);
2352                  
2353                   //  Set the parameters values
2354                  AssignParameterValues(commandParameters, dataRow);
2355                  
2356                   return  SqlHelper.ExecuteXmlReader(connection, CommandType.StoredProcedure, spName, commandParameters);
2357              }
2358               else
2359              {
2360                   return  SqlHelper.ExecuteXmlReader(connection, CommandType.StoredProcedure, spName);
2361              }
2362          }
2363 
2364           ///   <summary>
2365           ///  Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlTransaction 
2366           ///  using the dataRow column values as the stored procedure's parameters values.
2367           ///  This method will query the database to discover the parameters for the 
2368           ///  stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
2369           ///   </summary>
2370           ///   <param name="transaction"> A valid SqlTransaction object </param>
2371           ///   <param name="spName"> The name of the stored procedure </param>
2372           ///   <param name="dataRow"> The dataRow used to hold the stored procedure's parameter values. </param>
2373           ///   <returns> An XmlReader containing the resultset generated by the command </returns>
2374           public   static  XmlReader ExecuteXmlReaderTypedParams(SqlTransaction transaction, String spName, DataRow dataRow)
2375          {
2376               if ( transaction  ==   null  )  throw   new  ArgumentNullException(  " transaction "  );
2377               if ( transaction  !=   null   &&  transaction.Connection  ==   null  )  throw   new  ArgumentException(  " The transaction was rollbacked or commited, please provide an open transaction. " ,  " transaction "  );
2378               if ( spName  ==   null   ||  spName.Length  ==   0  )  throw   new  ArgumentNullException(  " spName "  );
2379 
2380               //  If the row has values, the store procedure parameters must be initialized
2381               if ( dataRow  !=   null   &&  dataRow.ItemArray.Length  >   0 )
2382              {
2383                   //  Pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache)
2384                  SqlParameter[] commandParameters  =  SqlHelperParameterCache.GetSpParameterSet(transaction.Connection, spName);
2385                  
2386                   //  Set the parameters values
2387                  AssignParameterValues(commandParameters, dataRow);
2388                  
2389                   return  SqlHelper.ExecuteXmlReader(transaction, CommandType.StoredProcedure, spName, commandParameters);
2390              }
2391               else
2392              {
2393                   return  SqlHelper.ExecuteXmlReader(transaction, CommandType.StoredProcedure, spName);
2394              }
2395          }
2396           #endregion
2397 
2398      }
2399 
2400       ///   <summary>
2401       ///  SqlHelperParameterCache provides functions to leverage a static cache of procedure parameters, and the
2402       ///  ability to discover parameters for stored procedures at run-time.
2403       ///   </summary>
2404       public   sealed   class  SqlHelperParameterCache
2405      {
2406           #region  private methods, variables, and constructors
2407 
2408           // Since this class provides only static methods, make the default constructor private to prevent 
2409           // instances from being created with "new SqlHelperParameterCache()"
2410           private  SqlHelperParameterCache() {}
2411 
2412           private   static  Hashtable paramCache  =  Hashtable.Synchronized( new  Hashtable());
2413 
2414           ///   <summary>
2415           ///  Resolve at run time the appropriate set of SqlParameters for a stored procedure
2416           ///   </summary>
2417           ///   <param name="connection"> A valid SqlConnection object </param>
2418           ///   <param name="spName"> The name of the stored procedure </param>
2419           ///   <param name="includeReturnValueParameter"> Whether or not to include their return value parameter </param>
2420           ///   <returns> The parameter array discovered. </returns>
2421           private   static  SqlParameter[] DiscoverSpParameterSet(SqlConnection connection,  string  spName,  bool  includeReturnValueParameter)
2422          {
2423               if ( connection  ==   null  )  throw   new  ArgumentNullException(  " connection "  );
2424               if ( spName  ==   null   ||  spName.Length  ==   0  )  throw   new  ArgumentNullException(  " spName "  );
2425 
2426              SqlCommand cmd  =   new  SqlCommand(spName, connection);
2427              cmd.CommandType  =  CommandType.StoredProcedure;
2428 
2429              connection.Open();
2430              SqlCommandBuilder.DeriveParameters(cmd);
2431              connection.Close();
2432 
2433               if  ( ! includeReturnValueParameter) 
2434              {
2435                  cmd.Parameters.RemoveAt( 0 );
2436              }
2437                  
2438              SqlParameter[] discoveredParameters  =   new  SqlParameter[cmd.Parameters.Count];
2439 
2440              cmd.Parameters.CopyTo(discoveredParameters,  0 );
2441 
2442               //  Init the parameters with a DBNull value
2443               foreach  (SqlParameter discoveredParameter  in  discoveredParameters)
2444              {
2445                  discoveredParameter.Value  =  DBNull.Value;
2446              }
2447               return  discoveredParameters;
2448          }
2449 
2450           ///   <summary>
2451           ///  Deep copy of cached SqlParameter array
2452           ///   </summary>
2453           ///   <param name="originalParameters"></param>
2454           ///   <returns></returns>
2455           private   static  SqlParameter[] CloneParameters(SqlParameter[] originalParameters)
2456          {
2457              SqlParameter[] clonedParameters  =   new  SqlParameter[originalParameters.Length];
2458 
2459               for  ( int  i  =   0 , j  =  originalParameters.Length; i  <  j; i ++ )
2460              {
2461                  clonedParameters[i]  =  (SqlParameter)((ICloneable)originalParameters[i]).Clone();
2462              }
2463 
2464               return  clonedParameters;
2465          }
2466 
2467           #endregion  private methods, variables, and constructors
2468 
2469           #region  caching functions
2470 
2471           ///   <summary>
2472           ///  Add parameter array to the cache
2473           ///   </summary>
2474           ///   <param name="connectionString"> A valid connection string for a SqlConnection </param>
2475           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
2476           ///   <param name="commandParameters"> An array of SqlParamters to be cached </param>
2477           public   static   void  CacheParameterSet( string  connectionString,  string  commandText,  params  SqlParameter[] commandParameters)
2478          {
2479               if ( connectionString  ==   null   ||  connectionString.Length  ==   0  )  throw   new  ArgumentNullException(  " connectionString "  );
2480               if ( commandText  ==   null   ||  commandText.Length  ==   0  )  throw   new  ArgumentNullException(  " commandText "  );
2481 
2482               string  hashKey  =  connectionString  +   " : "   +  commandText;
2483 
2484              paramCache[hashKey]  =  commandParameters;
2485          }
2486 
2487           ///   <summary>
2488           ///  Retrieve a parameter array from the cache
2489           ///   </summary>
2490           ///   <param name="connectionString"> A valid connection string for a SqlConnection </param>
2491           ///   <param name="commandText"> The stored procedure name or T-SQL command </param>
2492           ///   <returns> An array of SqlParamters </returns>
2493           public   static  SqlParameter[] GetCachedParameterSet( string  connectionString,  string  commandText)
2494          {
2495               if ( connectionString  ==   null   ||  connectionString.Length  ==   0  )  throw   new  ArgumentNullException(  " connectionString "  );
2496               if ( commandText  ==   null   ||  commandText.Length  ==   0  )  throw   new  ArgumentNullException(  " commandText "  );
2497 
2498               string  hashKey  =  connectionString  +   " : "   +  commandText;
2499 
2500              SqlParameter[] cachedParameters  =  paramCache[hashKey]  as  SqlParameter[];
2501               if  (cachedParameters  ==   null )
2502              {            
2503                   return   null ;
2504              }
2505               else
2506              {
2507                   return  CloneParameters(cachedParameters);
2508              }
2509          }
2510 
2511           #endregion  caching functions
2512 
2513           #region  Parameter Discovery Functions
2514 
2515           ///   <summary>
2516           ///  Retrieves the set of SqlParameters appropriate for the stored procedure
2517           ///   </summary>
2518           ///   <remarks>
2519           ///  This method will query the database for this information, and then store it in a cache for future requests.
2520           ///   </remarks>
2521           ///   <param name="connectionString"> A valid connection string for a SqlConnection </param>
2522           ///   <param name="spName"> The name of the stored procedure </param>
2523           ///   <returns> An array of SqlParameters </returns>
2524           public   static  SqlParameter[] GetSpParameterSet( string  connectionString,  string  spName)
2525          {
2526               return  GetSpParameterSet(connectionString, spName,  false );
2527          }
2528 
2529           ///   <summary>
2530           ///  Retrieves the set of SqlParameters appropriate for the stored procedure
2531           ///   </summary>
2532           ///   <remarks>
2533           ///  This method will query the database for this information, and then store it in a cache for future requests.
2534           ///   </remarks>
2535           ///   <param name="connectionString"> A valid connection string for a SqlConnection </param>
2536           ///   <param name="spName"> The name of the stored procedure </param>
2537           ///   <param name="includeReturnValueParameter"> A bool value indicating whether the return value parameter should be included in the results </param>
2538           ///   <returns> An array of SqlParameters </returns>
2539           public   static  SqlParameter[] GetSpParameterSet( string  connectionString,  string  spName,  bool  includeReturnValueParameter)
2540          {
2541               if ( connectionString  ==   null   ||  connectionString.Length  ==   0  )  throw   new  ArgumentNullException(  " connectionString "  );
2542               if ( spName  ==   null   ||  spName.Length  ==   0  )  throw   new  ArgumentNullException(  " spName "  );
2543 
2544               using (SqlConnection connection  =   new  SqlConnection(connectionString))
2545              {
2546                   return  GetSpParameterSetInternal(connection, spName, includeReturnValueParameter);
2547              }
2548          }
2549 
2550           ///   <summary>
2551           ///  Retrieves the set of SqlParameters appropriate for the stored procedure
2552           ///   </summary>
2553           ///   <remarks>
2554           ///  This method will query the database for this information, and then store it in a cache for future requests.
2555           ///   </remarks>
2556           ///   <param name="connection"> A valid SqlConnection object </param>
2557           ///   <param name="spName"> The name of the stored procedure </param>
2558           ///   <returns> An array of SqlParameters </returns>
2559           internal   static  SqlParameter[] GetSpParameterSet(SqlConnection connection,  string  spName)
2560          {
2561               return  GetSpParameterSet(connection, spName,  false );
2562          }
2563 
2564           ///   <summary>
2565           ///  Retrieves the set of SqlParameters appropriate for the stored procedure
2566           ///   </summary>
2567           ///   <remarks>
2568           ///  This method will query the database for this information, and then store it in a cache for future requests.
2569           ///   </remarks>
2570           ///   <param name="connection"> A valid SqlConnection object </param>
2571           ///   <param name="spName"> The name of the stored procedure </param>
2572           ///   <param name="includeReturnValueParameter"> A bool value indicating whether the return value parameter should be included in the results </param>
2573           ///   <returns> An array of SqlParameters </returns>
2574           internal   static  SqlParameter[] GetSpParameterSet(SqlConnection connection,  string  spName,  bool  includeReturnValueParameter)
2575          {
2576               if ( connection  ==   null  )  throw   new  ArgumentNullException(  " connection "  );
2577               using  (SqlConnection clonedConnection  =  (SqlConnection)((ICloneable)connection).Clone())
2578              {
2579                   return  GetSpParameterSetInternal(clonedConnection, spName, includeReturnValueParameter);
2580              }
2581          }
2582 
2583           ///   <summary>
2584           ///  Retrieves the set of SqlParameters appropriate for the stored procedure
2585           ///   </summary>
2586           ///   <param name="connection"> A valid SqlConnection object </param>
2587           ///   <param name="spName"> The name of the stored procedure </param>
2588           ///   <param name="includeReturnValueParameter"> A bool value indicating whether the return value parameter should be included in the results </param>
2589           ///   <returns> An array of SqlParameters </returns>
2590           private   static  SqlParameter[] GetSpParameterSetInternal(SqlConnection connection,  string  spName,  bool  includeReturnValueParameter)
2591          {
2592               if ( connection  ==   null  )  throw   new  ArgumentNullException(  " connection "  );
2593               if ( spName  ==   null   ||  spName.Length  ==   0  )  throw   new  ArgumentNullException(  " spName "  );
2594 
2595               string  hashKey  =  connection.ConnectionString  +   " : "   +  spName  +  (includeReturnValueParameter  ?   " :include ReturnValue Parameter " : "" );
2596 
2597              SqlParameter[] cachedParameters;
2598              
2599              cachedParameters  =  paramCache[hashKey]  as  SqlParameter[];
2600               if  (cachedParameters  ==   null )
2601              {    
2602                  SqlParameter[] spParameters  =  DiscoverSpParameterSet(connection, spName, includeReturnValueParameter);
2603                  paramCache[hashKey]  =  spParameters;
2604                  cachedParameters  =  spParameters;
2605              }
2606              
2607               return  CloneParameters(cachedParameters);
2608          }
2609          
2610           #endregion  Parameter Discovery Functions
2611 
2612      }
2613  }
2614