Click here to Skip to main content
Click here to Skip to main content
Articles » Web Development » ASP.NET » Samples » Downloads
 
Add your own
alternative version

Reusable navigation and workflow for both Windows and Web using Microsoft UIP blocks

, 29 Mar 2009
Reusable navigation and workflow for Windows and Web using Microsoft UIP blocks.
ASPDotNetUIP.zip
ASPDotNetUIP
App_Code
App_Data
Bin
Microsoft.ApplicationBlocks.Data.dll
Microsoft.ApplicationBlocks.UIProcess.dll
MyController.dll
MyController
bin
Debug
Microsoft.ApplicationBlocks.Data.dll
Microsoft.ApplicationBlocks.UIProcess.dll
MyController.dll
obj
Debug
MyController.dll
TempPE
Properties
MyTask
bin
Debug
obj
Debug
TempPE
Properties
Model.dll
Model
bin
Debug
Model.dll
obj
Debug
Refactor
TempPE
Properties
Model.dll
WindowsApplication
WindowsUIPExample
bin
Debug
Microsoft.ApplicationBlocks.Data.dll
Microsoft.ApplicationBlocks.UIProcess.dll
Model.dll
MyController.dll
WindowsUIPExample.exe
WindowsUIPExample.vshost.exe
obj
Debug
Refactor
TempPE
Properties
Settings.settings
<?xml version="1.0"?>
<doc>
    <assembly>
        <name>Microsoft.ApplicationBlocks.Data</name>
    </assembly>
    <members>
        <member name="T:Microsoft.ApplicationBlocks.Data.SqlHelper">
            <summary>
            The SqlHelper class is intended to encapsulate high performance, scalable best practices for 
            common uses of SqlClient
            </summary>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.AttachParameters(System.Data.SqlClient.SqlCommand,System.Data.SqlClient.SqlParameter[])">
            <summary>
            This method is used to attach array of SqlParameters to a SqlCommand.
            
            This method will assign a value of DbNull to any parameter with a direction of
            InputOutput and a value of null.  
            
            This behavior will prevent default values from being used, but
            this will be the less common case than an intended pure output parameter (derived as InputOutput)
            where the user provided no input value.
            </summary>
            <param name="command">The command to which the parameters will be added</param>
            <param name="commandParameters">An array of SqlParameters to be added to command</param>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.AssignParameterValues(System.Data.SqlClient.SqlParameter[],System.Data.DataRow)">
            <summary>
            This method assigns dataRow column values to an array of SqlParameters
            </summary>
            <param name="commandParameters">Array of SqlParameters to be assigned values</param>
            <param name="dataRow">The dataRow used to hold the stored procedure's parameter values</param>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.AssignParameterValues(System.Data.SqlClient.SqlParameter[],System.Object[])">
            <summary>
            This method assigns an array of values to an array of SqlParameters
            </summary>
            <param name="commandParameters">Array of SqlParameters to be assigned values</param>
            <param name="parameterValues">Array of objects holding the values to be assigned</param>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.PrepareCommand(System.Data.SqlClient.SqlCommand,System.Data.SqlClient.SqlConnection,System.Data.SqlClient.SqlTransaction,System.Data.CommandType,System.String,System.Data.SqlClient.SqlParameter[],System.Boolean@)">
            <summary>
            This method opens (if necessary) and assigns a connection, transaction, command type and parameters 
            to the provided command
            </summary>
            <param name="command">The SqlCommand to be prepared</param>
            <param name="connection">A valid SqlConnection, on which to execute this command</param>
            <param name="transaction">A valid SqlTransaction, or 'null'</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="commandParameters">An array of SqlParameters to be associated with the command or 'null' if no parameters are required</param>
            <param name="mustCloseConnection"><c>true</c> if the connection was opened by the method, otherwose is false.</param>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteNonQuery(System.String,System.Data.CommandType,System.String)">
            <summary>
            Execute a SqlCommand (that returns no resultset and takes no parameters) against the database specified in 
            the connection string
            </summary>
            <remarks>
            e.g.:  
             int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders");
            </remarks>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <returns>An int representing the number of rows affected by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteNonQuery(System.String,System.Data.CommandType,System.String,System.Data.SqlClient.SqlParameter[])">
            <summary>
            Execute a SqlCommand (that returns no resultset) against the database specified in the connection string 
            using the provided parameters
            </summary>
            <remarks>
            e.g.:  
             int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
            </remarks>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
            <returns>An int representing the number of rows affected by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteNonQuery(System.String,System.String,System.Object[])">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns no resultset) against the database specified in 
            the connection string using the provided parameter values.  This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <remarks>
            This method provides no access to output parameters or the stored procedure's return value parameter.
            
            e.g.:  
             int result = ExecuteNonQuery(connString, "PublishOrders", 24, 36);
            </remarks>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="spName">The name of the stored prcedure</param>
            <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
            <returns>An int representing the number of rows affected by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteNonQuery(System.Data.SqlClient.SqlConnection,System.Data.CommandType,System.String)">
            <summary>
            Execute a SqlCommand (that returns no resultset and takes no parameters) against the provided SqlConnection. 
            </summary>
            <remarks>
            e.g.:  
             int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders");
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <returns>An int representing the number of rows affected by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteNonQuery(System.Data.SqlClient.SqlConnection,System.Data.CommandType,System.String,System.Data.SqlClient.SqlParameter[])">
            <summary>
            Execute a SqlCommand (that returns no resultset) against the specified SqlConnection 
            using the provided parameters.
            </summary>
            <remarks>
            e.g.:  
             int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
            <returns>An int representing the number of rows affected by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteNonQuery(System.Data.SqlClient.SqlConnection,System.String,System.Object[])">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns no resultset) against the specified SqlConnection 
            using the provided parameter values.  This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <remarks>
            This method provides no access to output parameters or the stored procedure's return value parameter.
            
            e.g.:  
             int result = ExecuteNonQuery(conn, "PublishOrders", 24, 36);
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
            <returns>An int representing the number of rows affected by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteNonQuery(System.Data.SqlClient.SqlTransaction,System.Data.CommandType,System.String)">
            <summary>
            Execute a SqlCommand (that returns no resultset and takes no parameters) against the provided SqlTransaction. 
            </summary>
            <remarks>
            e.g.:  
             int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "PublishOrders");
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <returns>An int representing the number of rows affected by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteNonQuery(System.Data.SqlClient.SqlTransaction,System.Data.CommandType,System.String,System.Data.SqlClient.SqlParameter[])">
            <summary>
            Execute a SqlCommand (that returns no resultset) against the specified SqlTransaction
            using the provided parameters.
            </summary>
            <remarks>
            e.g.:  
             int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
            <returns>An int representing the number of rows affected by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteNonQuery(System.Data.SqlClient.SqlTransaction,System.String,System.Object[])">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns no resultset) against the specified 
            SqlTransaction using the provided parameter values.  This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <remarks>
            This method provides no access to output parameters or the stored procedure's return value parameter.
            
            e.g.:  
             int result = ExecuteNonQuery(conn, trans, "PublishOrders", 24, 36);
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
            <returns>An int representing the number of rows affected by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteDataset(System.String,System.Data.CommandType,System.String)">
            <summary>
            Execute a SqlCommand (that returns a resultset and takes no parameters) against the database specified in 
            the connection string. 
            </summary>
            <remarks>
            e.g.:  
             DataSet ds = ExecuteDataset(connString, CommandType.StoredProcedure, "GetOrders");
            </remarks>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <returns>A dataset containing the resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteDataset(System.String,System.Data.CommandType,System.String,System.Data.SqlClient.SqlParameter[])">
            <summary>
            Execute a SqlCommand (that returns a resultset) against the database specified in the connection string 
            using the provided parameters.
            </summary>
            <remarks>
            e.g.:  
             DataSet ds = ExecuteDataset(connString, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
            </remarks>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
            <returns>A dataset containing the resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteDataset(System.String,System.String,System.Object[])">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the database specified in 
            the connection string using the provided parameter values.  This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <remarks>
            This method provides no access to output parameters or the stored procedure's return value parameter.
            
            e.g.:  
             DataSet ds = ExecuteDataset(connString, "GetOrders", 24, 36);
            </remarks>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
            <returns>A dataset containing the resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteDataset(System.Data.SqlClient.SqlConnection,System.Data.CommandType,System.String)">
            <summary>
            Execute a SqlCommand (that returns a resultset and takes no parameters) against the provided SqlConnection. 
            </summary>
            <remarks>
            e.g.:  
             DataSet ds = ExecuteDataset(conn, CommandType.StoredProcedure, "GetOrders");
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <returns>A dataset containing the resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteDataset(System.Data.SqlClient.SqlConnection,System.Data.CommandType,System.String,System.Data.SqlClient.SqlParameter[])">
            <summary>
            Execute a SqlCommand (that returns a resultset) against the specified SqlConnection 
            using the provided parameters.
            </summary>
            <remarks>
            e.g.:  
             DataSet ds = ExecuteDataset(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
            <returns>A dataset containing the resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteDataset(System.Data.SqlClient.SqlConnection,System.String,System.Object[])">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlConnection 
            using the provided parameter values.  This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <remarks>
            This method provides no access to output parameters or the stored procedure's return value parameter.
            
            e.g.:  
             DataSet ds = ExecuteDataset(conn, "GetOrders", 24, 36);
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
            <returns>A dataset containing the resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteDataset(System.Data.SqlClient.SqlTransaction,System.Data.CommandType,System.String)">
            <summary>
            Execute a SqlCommand (that returns a resultset and takes no parameters) against the provided SqlTransaction. 
            </summary>
            <remarks>
            e.g.:  
             DataSet ds = ExecuteDataset(trans, CommandType.StoredProcedure, "GetOrders");
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <returns>A dataset containing the resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteDataset(System.Data.SqlClient.SqlTransaction,System.Data.CommandType,System.String,System.Data.SqlClient.SqlParameter[])">
            <summary>
            Execute a SqlCommand (that returns a resultset) against the specified SqlTransaction
            using the provided parameters.
            </summary>
            <remarks>
            e.g.:  
             DataSet ds = ExecuteDataset(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
            <returns>A dataset containing the resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteDataset(System.Data.SqlClient.SqlTransaction,System.String,System.Object[])">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified 
            SqlTransaction using the provided parameter values.  This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <remarks>
            This method provides no access to output parameters or the stored procedure's return value parameter.
            
            e.g.:  
             DataSet ds = ExecuteDataset(trans, "GetOrders", 24, 36);
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
            <returns>A dataset containing the resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteReader(System.Data.SqlClient.SqlConnection,System.Data.SqlClient.SqlTransaction,System.Data.CommandType,System.String,System.Data.SqlClient.SqlParameter[],Microsoft.ApplicationBlocks.Data.SqlHelper.SqlConnectionOwnership)">
            <summary>
            Create and prepare a SqlCommand, and call ExecuteReader with the appropriate CommandBehavior.
            </summary>
            <remarks>
            If we created and opened the connection, we want the connection to be closed when the DataReader is closed.
            
            If the caller provided the connection, we want to leave it to them to manage.
            </remarks>
            <param name="connection">A valid SqlConnection, on which to execute this command</param>
            <param name="transaction">A valid SqlTransaction, or 'null'</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="commandParameters">An array of SqlParameters to be associated with the command or 'null' if no parameters are required</param>
            <param name="connectionOwnership">Indicates whether the connection parameter was provided by the caller, or created by SqlHelper</param>
            <returns>SqlDataReader containing the results of the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteReader(System.String,System.Data.CommandType,System.String)">
            <summary>
            Execute a SqlCommand (that returns a resultset and takes no parameters) against the database specified in 
            the connection string. 
            </summary>
            <remarks>
            e.g.:  
             SqlDataReader dr = ExecuteReader(connString, CommandType.StoredProcedure, "GetOrders");
            </remarks>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <returns>A SqlDataReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteReader(System.String,System.Data.CommandType,System.String,System.Data.SqlClient.SqlParameter[])">
            <summary>
            Execute a SqlCommand (that returns a resultset) against the database specified in the connection string 
            using the provided parameters.
            </summary>
            <remarks>
            e.g.:  
             SqlDataReader dr = ExecuteReader(connString, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
            </remarks>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
            <returns>A SqlDataReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteReader(System.String,System.String,System.Object[])">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the database specified in 
            the connection string using the provided parameter values.  This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <remarks>
            This method provides no access to output parameters or the stored procedure's return value parameter.
            
            e.g.:  
             SqlDataReader dr = ExecuteReader(connString, "GetOrders", 24, 36);
            </remarks>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
            <returns>A SqlDataReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteReader(System.Data.SqlClient.SqlConnection,System.Data.CommandType,System.String)">
            <summary>
            Execute a SqlCommand (that returns a resultset and takes no parameters) against the provided SqlConnection. 
            </summary>
            <remarks>
            e.g.:  
             SqlDataReader dr = ExecuteReader(conn, CommandType.StoredProcedure, "GetOrders");
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <returns>A SqlDataReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteReader(System.Data.SqlClient.SqlConnection,System.Data.CommandType,System.String,System.Data.SqlClient.SqlParameter[])">
            <summary>
            Execute a SqlCommand (that returns a resultset) against the specified SqlConnection 
            using the provided parameters.
            </summary>
            <remarks>
            e.g.:  
             SqlDataReader dr = ExecuteReader(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
            <returns>A SqlDataReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteReader(System.Data.SqlClient.SqlConnection,System.String,System.Object[])">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlConnection 
            using the provided parameter values.  This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <remarks>
            This method provides no access to output parameters or the stored procedure's return value parameter.
            
            e.g.:  
             SqlDataReader dr = ExecuteReader(conn, "GetOrders", 24, 36);
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
            <returns>A SqlDataReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteReader(System.Data.SqlClient.SqlTransaction,System.Data.CommandType,System.String)">
            <summary>
            Execute a SqlCommand (that returns a resultset and takes no parameters) against the provided SqlTransaction. 
            </summary>
            <remarks>
            e.g.:  
             SqlDataReader dr = ExecuteReader(trans, CommandType.StoredProcedure, "GetOrders");
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <returns>A SqlDataReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteReader(System.Data.SqlClient.SqlTransaction,System.Data.CommandType,System.String,System.Data.SqlClient.SqlParameter[])">
            <summary>
            Execute a SqlCommand (that returns a resultset) against the specified SqlTransaction
            using the provided parameters.
            </summary>
            <remarks>
            e.g.:  
              SqlDataReader dr = ExecuteReader(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
            <returns>A SqlDataReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteReader(System.Data.SqlClient.SqlTransaction,System.String,System.Object[])">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified
            SqlTransaction using the provided parameter values.  This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <remarks>
            This method provides no access to output parameters or the stored procedure's return value parameter.
            
            e.g.:  
             SqlDataReader dr = ExecuteReader(trans, "GetOrders", 24, 36);
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
            <returns>A SqlDataReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteScalar(System.String,System.Data.CommandType,System.String)">
            <summary>
            Execute a SqlCommand (that returns a 1x1 resultset and takes no parameters) against the database specified in 
            the connection string. 
            </summary>
            <remarks>
            e.g.:  
             int orderCount = (int)ExecuteScalar(connString, CommandType.StoredProcedure, "GetOrderCount");
            </remarks>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteScalar(System.String,System.Data.CommandType,System.String,System.Data.SqlClient.SqlParameter[])">
            <summary>
            Execute a SqlCommand (that returns a 1x1 resultset) against the database specified in the connection string 
            using the provided parameters.
            </summary>
            <remarks>
            e.g.:  
             int orderCount = (int)ExecuteScalar(connString, CommandType.StoredProcedure, "GetOrderCount", new SqlParameter("@prodid", 24));
            </remarks>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
            <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteScalar(System.String,System.String,System.Object[])">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a 1x1 resultset) against the database specified in 
            the connection string using the provided parameter values.  This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <remarks>
            This method provides no access to output parameters or the stored procedure's return value parameter.
            
            e.g.:  
             int orderCount = (int)ExecuteScalar(connString, "GetOrderCount", 24, 36);
            </remarks>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
            <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteScalar(System.Data.SqlClient.SqlConnection,System.Data.CommandType,System.String)">
            <summary>
            Execute a SqlCommand (that returns a 1x1 resultset and takes no parameters) against the provided SqlConnection. 
            </summary>
            <remarks>
            e.g.:  
             int orderCount = (int)ExecuteScalar(conn, CommandType.StoredProcedure, "GetOrderCount");
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteScalar(System.Data.SqlClient.SqlConnection,System.Data.CommandType,System.String,System.Data.SqlClient.SqlParameter[])">
            <summary>
            Execute a SqlCommand (that returns a 1x1 resultset) against the specified SqlConnection 
            using the provided parameters.
            </summary>
            <remarks>
            e.g.:  
             int orderCount = (int)ExecuteScalar(conn, CommandType.StoredProcedure, "GetOrderCount", new SqlParameter("@prodid", 24));
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
            <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteScalar(System.Data.SqlClient.SqlConnection,System.String,System.Object[])">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a 1x1 resultset) against the specified SqlConnection 
            using the provided parameter values.  This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <remarks>
            This method provides no access to output parameters or the stored procedure's return value parameter.
            
            e.g.:  
             int orderCount = (int)ExecuteScalar(conn, "GetOrderCount", 24, 36);
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
            <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteScalar(System.Data.SqlClient.SqlTransaction,System.Data.CommandType,System.String)">
            <summary>
            Execute a SqlCommand (that returns a 1x1 resultset and takes no parameters) against the provided SqlTransaction. 
            </summary>
            <remarks>
            e.g.:  
             int orderCount = (int)ExecuteScalar(trans, CommandType.StoredProcedure, "GetOrderCount");
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteScalar(System.Data.SqlClient.SqlTransaction,System.Data.CommandType,System.String,System.Data.SqlClient.SqlParameter[])">
            <summary>
            Execute a SqlCommand (that returns a 1x1 resultset) against the specified SqlTransaction
            using the provided parameters.
            </summary>
            <remarks>
            e.g.:  
             int orderCount = (int)ExecuteScalar(trans, CommandType.StoredProcedure, "GetOrderCount", new SqlParameter("@prodid", 24));
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
            <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteScalar(System.Data.SqlClient.SqlTransaction,System.String,System.Object[])">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a 1x1 resultset) against the specified
            SqlTransaction using the provided parameter values.  This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <remarks>
            This method provides no access to output parameters or the stored procedure's return value parameter.
            
            e.g.:  
             int orderCount = (int)ExecuteScalar(trans, "GetOrderCount", 24, 36);
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
            <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteXmlReader(System.Data.SqlClient.SqlConnection,System.Data.CommandType,System.String)">
            <summary>
            Execute a SqlCommand (that returns a resultset and takes no parameters) against the provided SqlConnection. 
            </summary>
            <remarks>
            e.g.:  
             XmlReader r = ExecuteXmlReader(conn, CommandType.StoredProcedure, "GetOrders");
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command using "FOR XML AUTO"</param>
            <returns>An XmlReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteXmlReader(System.Data.SqlClient.SqlConnection,System.Data.CommandType,System.String,System.Data.SqlClient.SqlParameter[])">
            <summary>
            Execute a SqlCommand (that returns a resultset) against the specified SqlConnection 
            using the provided parameters.
            </summary>
            <remarks>
            e.g.:  
             XmlReader r = ExecuteXmlReader(conn, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command using "FOR XML AUTO"</param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
            <returns>An XmlReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteXmlReader(System.Data.SqlClient.SqlConnection,System.String,System.Object[])">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlConnection 
            using the provided parameter values.  This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <remarks>
            This method provides no access to output parameters or the stored procedure's return value parameter.
            
            e.g.:  
             XmlReader r = ExecuteXmlReader(conn, "GetOrders", 24, 36);
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="spName">The name of the stored procedure using "FOR XML AUTO"</param>
            <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
            <returns>An XmlReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteXmlReader(System.Data.SqlClient.SqlTransaction,System.Data.CommandType,System.String)">
            <summary>
            Execute a SqlCommand (that returns a resultset and takes no parameters) against the provided SqlTransaction. 
            </summary>
            <remarks>
            e.g.:  
             XmlReader r = ExecuteXmlReader(trans, CommandType.StoredProcedure, "GetOrders");
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command using "FOR XML AUTO"</param>
            <returns>An XmlReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteXmlReader(System.Data.SqlClient.SqlTransaction,System.Data.CommandType,System.String,System.Data.SqlClient.SqlParameter[])">
            <summary>
            Execute a SqlCommand (that returns a resultset) against the specified SqlTransaction
            using the provided parameters.
            </summary>
            <remarks>
            e.g.:  
             XmlReader r = ExecuteXmlReader(trans, CommandType.StoredProcedure, "GetOrders", new SqlParameter("@prodid", 24));
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command using "FOR XML AUTO"</param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
            <returns>An XmlReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteXmlReader(System.Data.SqlClient.SqlTransaction,System.String,System.Object[])">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified 
            SqlTransaction using the provided parameter values.  This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <remarks>
            This method provides no access to output parameters or the stored procedure's return value parameter.
            
            e.g.:  
             XmlReader r = ExecuteXmlReader(trans, "GetOrders", 24, 36);
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
            <returns>A dataset containing the resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.FillDataset(System.String,System.Data.CommandType,System.String,System.Data.DataSet,System.String[])">
            <summary>
            Execute a SqlCommand (that returns a resultset and takes no parameters) against the database specified in 
            the connection string. 
            </summary>
            <remarks>
            e.g.:  
             FillDataset(connString, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"});
            </remarks>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
            <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
            by a user defined name (probably the actual table name)</param>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.FillDataset(System.String,System.Data.CommandType,System.String,System.Data.DataSet,System.String[],System.Data.SqlClient.SqlParameter[])">
            <summary>
            Execute a SqlCommand (that returns a resultset) against the database specified in the connection string 
            using the provided parameters.
            </summary>
            <remarks>
            e.g.:  
             FillDataset(connString, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, new SqlParameter("@prodid", 24));
            </remarks>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
            <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
            <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
            by a user defined name (probably the actual table name)
            </param>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.FillDataset(System.String,System.String,System.Data.DataSet,System.String[],System.Object[])">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the database specified in 
            the connection string using the provided parameter values.  This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <remarks>
            This method provides no access to output parameters or the stored procedure's return value parameter.
            
            e.g.:  
             FillDataset(connString, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, 24);
            </remarks>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
            <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
            by a user defined name (probably the actual table name)
            </param>    
            <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.FillDataset(System.Data.SqlClient.SqlConnection,System.Data.CommandType,System.String,System.Data.DataSet,System.String[])">
            <summary>
            Execute a SqlCommand (that returns a resultset and takes no parameters) against the provided SqlConnection. 
            </summary>
            <remarks>
            e.g.:  
             FillDataset(conn, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"});
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
            <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
            by a user defined name (probably the actual table name)
            </param>    
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.FillDataset(System.Data.SqlClient.SqlConnection,System.Data.CommandType,System.String,System.Data.DataSet,System.String[],System.Data.SqlClient.SqlParameter[])">
            <summary>
            Execute a SqlCommand (that returns a resultset) against the specified SqlConnection 
            using the provided parameters.
            </summary>
            <remarks>
            e.g.:  
             FillDataset(conn, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, new SqlParameter("@prodid", 24));
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
            <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
            by a user defined name (probably the actual table name)
            </param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.FillDataset(System.Data.SqlClient.SqlConnection,System.String,System.Data.DataSet,System.String[],System.Object[])">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlConnection 
            using the provided parameter values.  This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <remarks>
            This method provides no access to output parameters or the stored procedure's return value parameter.
            
            e.g.:  
             FillDataset(conn, "GetOrders", ds, new string[] {"orders"}, 24, 36);
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
            <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
            by a user defined name (probably the actual table name)
            </param>
            <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.FillDataset(System.Data.SqlClient.SqlTransaction,System.Data.CommandType,System.String,System.Data.DataSet,System.String[])">
            <summary>
            Execute a SqlCommand (that returns a resultset and takes no parameters) against the provided SqlTransaction. 
            </summary>
            <remarks>
            e.g.:  
             FillDataset(trans, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"});
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
            <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
            by a user defined name (probably the actual table name)
            </param>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.FillDataset(System.Data.SqlClient.SqlTransaction,System.Data.CommandType,System.String,System.Data.DataSet,System.String[],System.Data.SqlClient.SqlParameter[])">
            <summary>
            Execute a SqlCommand (that returns a resultset) against the specified SqlTransaction
            using the provided parameters.
            </summary>
            <remarks>
            e.g.:  
             FillDataset(trans, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, new SqlParameter("@prodid", 24));
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
            <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
            by a user defined name (probably the actual table name)
            </param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.FillDataset(System.Data.SqlClient.SqlTransaction,System.String,System.Data.DataSet,System.String[],System.Object[])">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified 
            SqlTransaction using the provided parameter values.  This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <remarks>
            This method provides no access to output parameters or the stored procedure's return value parameter.
            
            e.g.:  
             FillDataset(trans, "GetOrders", ds, new string[]{"orders"}, 24, 36);
            </remarks>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
            <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
            by a user defined name (probably the actual table name)
            </param>
            <param name="parameterValues">An array of objects to be assigned as the input values of the stored procedure</param>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.FillDataset(System.Data.SqlClient.SqlConnection,System.Data.SqlClient.SqlTransaction,System.Data.CommandType,System.String,System.Data.DataSet,System.String[],System.Data.SqlClient.SqlParameter[])">
            <summary>
            Private helper method that execute a SqlCommand (that returns a resultset) against the specified SqlTransaction and SqlConnection
            using the provided parameters.
            </summary>
            <remarks>
            e.g.:  
             FillDataset(conn, trans, CommandType.StoredProcedure, "GetOrders", ds, new string[] {"orders"}, new SqlParameter("@prodid", 24));
            </remarks>
            <param name="connection">A valid SqlConnection</param>
            <param name="transaction">A valid SqlTransaction</param>
            <param name="commandType">The CommandType (stored procedure, text, etc.)</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="dataSet">A dataset wich will contain the resultset generated by the command</param>
            <param name="tableNames">This array will be used to create table mappings allowing the DataTables to be referenced
            by a user defined name (probably the actual table name)
            </param>
            <param name="commandParameters">An array of SqlParamters used to execute the command</param>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.UpdateDataset(System.Data.SqlClient.SqlCommand,System.Data.SqlClient.SqlCommand,System.Data.SqlClient.SqlCommand,System.Data.DataSet,System.String)">
            <summary>
            Executes the respective command for each inserted, updated, or deleted row in the DataSet.
            </summary>
            <remarks>
            e.g.:  
             UpdateDataset(conn, insertCommand, deleteCommand, updateCommand, dataSet, "Order");
            </remarks>
            <param name="insertCommand">A valid transact-SQL statement or stored procedure to insert new records into the data source</param>
            <param name="deleteCommand">A valid transact-SQL statement or stored procedure to delete records from the data source</param>
            <param name="updateCommand">A valid transact-SQL statement or stored procedure used to update records in the data source</param>
            <param name="dataSet">The DataSet used to update the data source</param>
            <param name="tableName">The DataTable used to update the data source.</param>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.CreateCommand(System.Data.SqlClient.SqlConnection,System.String,System.String[])">
            <summary>
            Simplify the creation of a Sql command object by allowing
            a stored procedure and optional parameters to be provided
            </summary>
            <remarks>
            e.g.:  
             SqlCommand command = CreateCommand(conn, "AddCustomer", "CustomerID", "CustomerName");
            </remarks>
            <param name="connection">A valid SqlConnection object</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="sourceColumns">An array of string to be assigned as the source columns of the stored procedure parameters</param>
            <returns>A valid SqlCommand object</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteNonQueryTypedParams(System.String,System.String,System.Data.DataRow)">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns no resultset) against the database specified in 
            the connection string using the dataRow column values as the stored procedure's parameters values.
            This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on row values.
            </summary>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
            <returns>An int representing the number of rows affected by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteNonQueryTypedParams(System.Data.SqlClient.SqlConnection,System.String,System.Data.DataRow)">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns no resultset) against the specified SqlConnection 
            using the dataRow column values as the stored procedure's parameters values.  
            This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on row values.
            </summary>
            <param name="connection">A valid SqlConnection object</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
            <returns>An int representing the number of rows affected by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteNonQueryTypedParams(System.Data.SqlClient.SqlTransaction,System.String,System.Data.DataRow)">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns no resultset) against the specified
            SqlTransaction using the dataRow column values as the stored procedure's parameters values.
            This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on row values.
            </summary>
            <param name="transaction">A valid SqlTransaction object</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
            <returns>An int representing the number of rows affected by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteDatasetTypedParams(System.String,System.String,System.Data.DataRow)">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the database specified in 
            the connection string using the dataRow column values as the stored procedure's parameters values.
            This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on row values.
            </summary>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
            <returns>A dataset containing the resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteDatasetTypedParams(System.Data.SqlClient.SqlConnection,System.String,System.Data.DataRow)">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlConnection 
            using the dataRow column values as the store procedure's parameters values.
            This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on row values.
            </summary>
            <param name="connection">A valid SqlConnection object</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
            <returns>A dataset containing the resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteDatasetTypedParams(System.Data.SqlClient.SqlTransaction,System.String,System.Data.DataRow)">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlTransaction 
            using the dataRow column values as the stored procedure's parameters values.
            This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on row values.
            </summary>
            <param name="transaction">A valid SqlTransaction object</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
            <returns>A dataset containing the resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteReaderTypedParams(System.String,System.String,System.Data.DataRow)">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the database specified in 
            the connection string using the dataRow column values as the stored procedure's parameters values.
            This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
            <returns>A SqlDataReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteReaderTypedParams(System.Data.SqlClient.SqlConnection,System.String,System.Data.DataRow)">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlConnection 
            using the dataRow column values as the stored procedure's parameters values.
            This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <param name="connection">A valid SqlConnection object</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
            <returns>A SqlDataReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteReaderTypedParams(System.Data.SqlClient.SqlTransaction,System.String,System.Data.DataRow)">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlTransaction 
            using the dataRow column values as the stored procedure's parameters values.
            This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <param name="transaction">A valid SqlTransaction object</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
            <returns>A SqlDataReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteScalarTypedParams(System.String,System.String,System.Data.DataRow)">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a 1x1 resultset) against the database specified in 
            the connection string using the dataRow column values as the stored procedure's parameters values.
            This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
            <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteScalarTypedParams(System.Data.SqlClient.SqlConnection,System.String,System.Data.DataRow)">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a 1x1 resultset) against the specified SqlConnection 
            using the dataRow column values as the stored procedure's parameters values.
            This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <param name="connection">A valid SqlConnection object</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
            <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteScalarTypedParams(System.Data.SqlClient.SqlTransaction,System.String,System.Data.DataRow)">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a 1x1 resultset) against the specified SqlTransaction
            using the dataRow column values as the stored procedure's parameters values.
            This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <param name="transaction">A valid SqlTransaction object</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
            <returns>An object containing the value in the 1x1 resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteXmlReaderTypedParams(System.Data.SqlClient.SqlConnection,System.String,System.Data.DataRow)">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlConnection 
            using the dataRow column values as the stored procedure's parameters values.
            This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <param name="connection">A valid SqlConnection object</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
            <returns>An XmlReader containing the resultset generated by the command</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelper.ExecuteXmlReaderTypedParams(System.Data.SqlClient.SqlTransaction,System.String,System.Data.DataRow)">
            <summary>
            Execute a stored procedure via a SqlCommand (that returns a resultset) against the specified SqlTransaction 
            using the dataRow column values as the stored procedure's parameters values.
            This method will query the database to discover the parameters for the 
            stored procedure (the first time each stored procedure is called), and assign the values based on parameter order.
            </summary>
            <param name="transaction">A valid SqlTransaction object</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="dataRow">The dataRow used to hold the stored procedure's parameter values.</param>
            <returns>An XmlReader containing the resultset generated by the command</returns>
        </member>
        <member name="T:Microsoft.ApplicationBlocks.Data.SqlHelper.SqlConnectionOwnership">
            <summary>
            This enum is used to indicate whether the connection was provided by the caller, or created by SqlHelper, so that
            we can set the appropriate CommandBehavior when calling ExecuteReader()
            </summary>
        </member>
        <member name="F:Microsoft.ApplicationBlocks.Data.SqlHelper.SqlConnectionOwnership.Internal">
            <summary>Connection is owned and managed by SqlHelper</summary>
        </member>
        <member name="F:Microsoft.ApplicationBlocks.Data.SqlHelper.SqlConnectionOwnership.External">
            <summary>Connection is owned and managed by the caller</summary>
        </member>
        <member name="T:Microsoft.ApplicationBlocks.Data.SqlHelperParameterCache">
            <summary>
            SqlHelperParameterCache provides functions to leverage a static cache of procedure parameters, and the
            ability to discover parameters for stored procedures at run-time.
            </summary>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelperParameterCache.DiscoverSpParameterSet(System.Data.SqlClient.SqlConnection,System.String,System.Boolean)">
            <summary>
            Resolve at run time the appropriate set of SqlParameters for a stored procedure
            </summary>
            <param name="connection">A valid SqlConnection object</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="includeReturnValueParameter">Whether or not to include their return value parameter</param>
            <returns>The parameter array discovered.</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelperParameterCache.CloneParameters(System.Data.SqlClient.SqlParameter[])">
            <summary>
            Deep copy of cached SqlParameter array
            </summary>
            <param name="originalParameters"></param>
            <returns></returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelperParameterCache.CacheParameterSet(System.String,System.String,System.Data.SqlClient.SqlParameter[])">
            <summary>
            Add parameter array to the cache
            </summary>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <param name="commandParameters">An array of SqlParamters to be cached</param>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelperParameterCache.GetCachedParameterSet(System.String,System.String)">
            <summary>
            Retrieve a parameter array from the cache
            </summary>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="commandText">The stored procedure name or T-SQL command</param>
            <returns>An array of SqlParamters</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelperParameterCache.GetSpParameterSet(System.String,System.String)">
            <summary>
            Retrieves the set of SqlParameters appropriate for the stored procedure
            </summary>
            <remarks>
            This method will query the database for this information, and then store it in a cache for future requests.
            </remarks>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="spName">The name of the stored procedure</param>
            <returns>An array of SqlParameters</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelperParameterCache.GetSpParameterSet(System.String,System.String,System.Boolean)">
            <summary>
            Retrieves the set of SqlParameters appropriate for the stored procedure
            </summary>
            <remarks>
            This method will query the database for this information, and then store it in a cache for future requests.
            </remarks>
            <param name="connectionString">A valid connection string for a SqlConnection</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="includeReturnValueParameter">A bool value indicating whether the return value parameter should be included in the results</param>
            <returns>An array of SqlParameters</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelperParameterCache.GetSpParameterSet(System.Data.SqlClient.SqlConnection,System.String)">
            <summary>
            Retrieves the set of SqlParameters appropriate for the stored procedure
            </summary>
            <remarks>
            This method will query the database for this information, and then store it in a cache for future requests.
            </remarks>
            <param name="connection">A valid SqlConnection object</param>
            <param name="spName">The name of the stored procedure</param>
            <returns>An array of SqlParameters</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelperParameterCache.GetSpParameterSet(System.Data.SqlClient.SqlConnection,System.String,System.Boolean)">
            <summary>
            Retrieves the set of SqlParameters appropriate for the stored procedure
            </summary>
            <remarks>
            This method will query the database for this information, and then store it in a cache for future requests.
            </remarks>
            <param name="connection">A valid SqlConnection object</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="includeReturnValueParameter">A bool value indicating whether the return value parameter should be included in the results</param>
            <returns>An array of SqlParameters</returns>
        </member>
        <member name="M:Microsoft.ApplicationBlocks.Data.SqlHelperParameterCache.GetSpParameterSetInternal(System.Data.SqlClient.SqlConnection,System.String,System.Boolean)">
            <summary>
            Retrieves the set of SqlParameters appropriate for the stored procedure
            </summary>
            <param name="connection">A valid SqlConnection object</param>
            <param name="spName">The name of the stored procedure</param>
            <param name="includeReturnValueParameter">A bool value indicating whether the return value parameter should be included in the results</param>
            <returns>An array of SqlParameters</returns>
        </member>
    </members>
</doc>

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Share

About the Author

Shivprasad koirala
Architect http://www.questpond.com
India India

I am a Microsoft MVP for ASP/ASP.NET and currently a CEO of a small
E-learning company in India. We are very much active in making training videos ,
writing books and corporate trainings. Do visit my site for 
.NET, C# , design pattern , WCF , Silverlight
, LINQ , ASP.NET , ADO.NET , Sharepoint , UML , SQL Server  training 
and Interview questions and answers


| Advertise | Privacy | Mobile
Web03 | 2.8.140814.1 | Last Updated 30 Mar 2009
Article Copyright 2008 by Shivprasad koirala
Everything else Copyright © CodeProject, 1999-2014
Terms of Service
Layout: fixed | fluid