//============================================================================== = // OleDbHelper based on Microsoft Data Access Application Block (DAAB) for .NET // http://msdn.microsoft.com/library/en-us/dnbda/html/daab-rm.asp // // OleDbHelper.

cs // // This file contains the implementations of the OleDbHelper and OleDbHelperPara meterCache // classes. // // The DAAB for MS Ole Db access for Oracle has been tested in the context of th is Nile implementation, // but has not undergone the generic functional testing that the SQL version has gone through. // You can use it in other .NET applications using Oracle databases. For comple te docs explaining how to use // and how it's built go to the originl appblock link. // For this sample, the code resides in the Nile namespaces not the Microsoft.Ap plicationBlocks namespace //============================================================================== using using using using using System; System.Data; System.Xml; System.Data.OleDb; System.Collections;

namespace SharpContent.ApplicationBlocks.Data { /// <summary> /// The OleDbHelper class is intended to encapsulate high performance, s calable best practices for /// common uses of OleDbClient. /// </summary> public sealed class OleDbHelper { #region private utility methods & constructors //Since this class provides only static methods, make the defaul t constructor private to prevent //instances from being created with "new OleDbHelper()". private OleDbHelper() {} /// <summary> /// This method is used to attach array's of OleDbParameters to an OleDbCommand. /// /// This method will assign a value of DbNull to any parameter w ith a direction of /// InputOutput and a value of null. /// /// This behavior will prevent default values from being used, b ut /// this will be the less common case than an intended pure outp ut parameter (derived as InputOutput) /// where the user provided no input value. /// </summary> /// <param name="command">The command to which the parameters wi

ll be added</param> /// <param name="commandParameters">an array of OleDbParameters tho be added to command</param> private static void AttachParameters(OleDbCommand command, OleDb Parameter[] commandParameters) { foreach (OleDbParameter p in commandParameters) { //check for derived output value with no value a ssigned if ((p.Direction == ParameterDirection.InputOutp ut) && (p.Value == null)) { p.Value = DBNull.Value; } command.Parameters.Add(p); } } /// <summary> /// This method assigns an array of values to an array of OleDbP arameters. /// </summary> /// <param name="commandParameters">array of OleDbParameters to be assigned values</param> /// <param name="parameterValues">array of objects holding the v alues to be assigned</param> private static void AssignParameterValues(OleDbParameter[] comma ndParameters, object[] parameterValues) { if ((commandParameters == null) || (parameterValues == n ull)) { //do nothing if we get no data return; } // we must have the same number of values as we pave par ameters to put them in if (commandParameters.Length != parameterValues.Length) { throw new ArgumentException("Parameter count doe s not match Parameter Value count."); } //iterate through the OleDbParameters, assigning the val ues from the corresponding position in the //value array for (int i = 0, j = commandParameters.Length; i < j; i++ ) { commandParameters[i].Value = parameterValues[i]; } } /// /// ransaction, command /// <summary> This method opens (if necessary) and assigns a connection, t type and parameters to the provided command.

/// </summary> /// <param name="command">the OleDbCommand to be prepared</param > /// <param name="connection">a valid OleDbConnection, on which t o execute this command</param> /// <param name="transaction">a valid OleDbTransaction, or 'null '</param> /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param> /// <param name="commandText">the stored procedure name or PL/SQ L command</param> /// <param name="commandParameters">an array of OleDbParameters to be associated with the command or 'null' if no parameters are required</param > private static void PrepareCommand(OleDbCommand command, OleDbCo nnection connection, OleDbTransaction transaction, CommandType commandType, stri ng commandText, OleDbParameter[] commandParameters) { //if the provided connection is not open, we will open i t if (connection.State != ConnectionState.Open) { connection.Open(); } //associate the connection with the command command.Connection = connection; //set the command text (stored procedure name or OleDb s tatement) command.CommandText = commandText; //if we were provided a transaction, assign it. if (transaction != null) { command.Transaction = transaction; } //set the command type command.CommandType = commandType; //attach the command parameters if they are provided if (commandParameters != null) { AttachParameters(command, commandParameters); } return; } #endregion private utility methods & constructors #region ExecuteNonQuery /// <summary> /// Execute an OleDbCommand (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.Stored Procedure, "PublishOrders"); /// </remarks> /// <param name="connectionString">a valid connection string for an OleDbConnection</param> /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param> /// <param name="commandText">the stored procedure name or PL/SQ L command</param> /// <returns>an int representing the number of rows affected by the command</returns> public static int ExecuteNonQuery(string connectionString, Comma ndType commandType, string commandText) { //pass through the call providing null for the set of Ol eDbParameters return ExecuteNonQuery(connectionString, commandType, co mmandText, (OleDbParameter[])null); } /// <summary> /// Execute an OleDbCommand (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.Stored Procedure, "PublishOrders", new OleDbParameter("@prodid", 24)); /// </remarks> /// <param name="connectionString">a valid connection string for a OleDbConnection</param> /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param> /// <param name="commandText">the stored procedure name or PL/SQ L command</param> /// <param name="commandParameters">an array of OleDbParameters used to execute the command</param> /// <returns>an int representing the number of rows affected by the command</returns> public static int ExecuteNonQuery(string connectionString, Comma ndType commandType, string commandText, params OleDbParameter[] commandParameter s) { //create & open an OleDbConnection, and dispose of it af ter we are done. using (OleDbConnection cn = new OleDbConnection(connecti onString)) { cn.Open(); //call the overload that takes a connection in p lace of the connection string return ExecuteNonQuery(cn, commandType, commandT ext, commandParameters); } }

/// <summary> /// Execute a stored procedure via an OleDbCommand (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 ca lled), and assign the values based on parameter order. /// </summary> /// <remarks> /// This method provides no access to output parameters or the s tored procedure's return value parameter. /// /// e.g.: /// int result = ExecuteNonQuery(connString, "PublishOrders", 2 4, 36); /// </remarks> /// <param name="connectionString">a valid connection string for a OleDbConnection</param> /// <param name="spName">the name of the stored prcedure</param> /// <param name="parameterValues">an array of objects to be assi gned as the input values of the stored procedure</param> /// <returns>an int representing the number of rows affected by the command</returns> public static int ExecuteNonQuery(string connectionString, strin g spName, params object[] parameterValues) { //if we got parameter values, we need to figure out wher e they go if ((parameterValues != null) && (parameterValues.Length > 0)) { //pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache) OleDbParameter[] commandParameters = OleDbHelper ParameterCache.GetSpParameterSet(connectionString, spName); //assign the provided values to these parameters based on parameter order AssignParameterValues(commandParameters, paramet erValues); //call the overload that takes an array of OleDb Parameters return ExecuteNonQuery(connectionString, Command Type.StoredProcedure, spName, commandParameters); } //otherwise we can just call the SP without params else { return ExecuteNonQuery(connectionString, Command Type.StoredProcedure, spName); } } /// <summary> /// Execute an OleDbDbCommand (that returns no resultset and tak es no parameters) against the provided OleDbConnection. /// </summary> /// <remarks> /// e.g.:

/// int result = ExecuteNonQuery(conn, CommandType.StoredProced ure, "PublishOrders"); /// </remarks> /// <param name="connection">a valid OleDbConnection</param> /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param> /// <param name="commandText">the stored procedure name or PL/SQ L command</param> /// <returns>an int representing the number of rows affected by the command</returns> public static int ExecuteNonQuery(OleDbConnection connection, Co mmandType commandType, string commandText) { //pass through the call providing null for the set of Ol eDbParameters return ExecuteNonQuery(connection, commandType, commandT ext, (OleDbParameter[])null); } /// <summary> /// Execute an OleDbCommand (that returns no resultset) against the specified OleDbConnection /// using the provided parameters. /// </summary> /// <remarks> /// e.g.: /// int result = ExecuteNonQuery(conn, CommandType.StoredProced ure, "PublishOrders", new OleDbParameter("@prodid", 24)); /// </remarks> /// <param name="connection">a valid OleDbConnection</param> /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param> /// <param name="commandText">the stored procedure name or PL/SQ L command</param> /// <param name="commandParameters">an array of OleDbParamters u sed to execute the command</param> /// <returns>an int representing the number of rows affected by the command</returns> public static int ExecuteNonQuery(OleDbConnection connection, Co mmandType commandType, string commandText, params OleDbParameter[] commandParame ters) { //create a command and prepare it for execution OleDbCommand cmd = new OleDbCommand(); PrepareCommand(cmd, connection, (OleDbTransaction)null, commandType, commandText, commandParameters); //finally, execute the command. return cmd.ExecuteNonQuery(); } /// <summary> /// Execute a stored procedure via an OleDbCommand (that returns no resultset) against the specified OleDbConnection /// 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 ca lled), and assign the values based on parameter order. /// </summary> /// <remarks>

/// This method provides no access to output parameters or the s tored procedure's return value parameter. /// /// e.g.: /// int result = ExecuteNonQuery(conn, "PublishOrders", 24, 36) ; /// </remarks> /// <param name="connection">a valid OleDbConnection</param> /// <param name="spName">the name of the stored prcedure</param> /// <param name="parameterValues">an array of objects to be assi gned as the input values of the stored procedure</param> /// <returns>an int representing the number of rows affected by the command</returns> public static int ExecuteNonQuery(OleDbConnection connection, st ring spName, params object[] parameterValues) { //if we got parameter values, we need to figure out wher e they go if ((parameterValues != null) && (parameterValues.Length > 0)) { //pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache) OleDbParameter[] commandParameters = OleDbHelper ParameterCache.GetSpParameterSet(connection.ConnectionString, spName); //assign the provided values to these parameters based on parameter order AssignParameterValues(commandParameters, paramet erValues); //call the overload that takes an array of OleDb Parameters return ExecuteNonQuery(connection, CommandType.S toredProcedure, spName, commandParameters); } //otherwise we can just call the SP without params else { return ExecuteNonQuery(connection, CommandType.S toredProcedure, spName); } } /// <summary> /// Execute an OleDbCommand (that returns no resultset and takes no parameters) against the provided OleDbTransaction. /// </summary> /// <remarks> /// e.g.: /// int result = ExecuteNonQuery(trans, CommandType.StoredProce dure, "PublishOrders"); /// </remarks> /// <param name="transaction">a valid OleDbTransaction</param> /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param> /// <param name="commandText">the stored procedure name or PL/SQ L command</param> /// <returns>an int representing the number of rows affected by the command</returns>

public static int ExecuteNonQuery(OleDbTransaction transaction, CommandType commandType, string commandText) { //pass through the call providing null for the set of Ol eDbParameters return ExecuteNonQuery(transaction, commandType, command Text, (OleDbParameter[])null); } /// <summary> /// Execute an OleDbCommand (that returns no resultset) against the specified OleDbTransaction /// using the provided parameters. /// </summary> /// <remarks> /// e.g.: /// int result = ExecuteNonQuery(trans, CommandType.StoredProce dure, "GetOrders", new OleDbParameter("@prodid", 24)); /// </remarks> /// <param name="transaction">a valid OleDbTransaction</param> /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param> /// <param name="commandText">the stored procedure name or PL/SQ L command</param> /// <param name="commandParameters">an array of OleDbParamters u sed to execute the command</param> /// <returns>an int representing the number of rows affected by the command</returns> public static int ExecuteNonQuery(OleDbTransaction transaction, CommandType commandType, string commandText, params OleDbParameter[] commandPara meters) { //create a command and prepare it for execution OleDbCommand cmd = new OleDbCommand(); PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters); //finally, execute the command. return cmd.ExecuteNonQuery(); } /// <summary> /// Execute a stored procedure via an OleDbCommand (that returns no resultset) against the specified /// OleDbTransaction 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 ca lled), and assign the values based on parameter order. /// </summary> /// <remarks> /// This method provides no access to output parameters or the s tored procedure's return value parameter. /// /// e.g.: /// int result = ExecuteNonQuery(conn, trans, "PublishOrders", 24, 36); /// </remarks> /// <param name="transaction">a valid OleDbTransaction</param> /// <param name="spName">the name of the stored procedure</param >

/// <param name="parameterValues">an array of objects to be assi gned as the input values of the stored procedure</param> /// <returns>an int representing the number of rows affected by the command</returns> public static int ExecuteNonQuery(OleDbTransaction transaction, string spName, params object[] parameterValues) { //if we got parameter values, we need to figure out wher e they go if ((parameterValues != null) && (parameterValues.Length > 0)) { //pull the parameters for this stored procedure from the parameter cache (or discover them & populet the cache) OleDbParameter[] commandParameters = OleDbHelper ParameterCache.GetSpParameterSet(transaction.Connection.ConnectionString, spName ); //assign the provided values to these parameters based on parameter order AssignParameterValues(commandParameters, paramet erValues); //call the overload that takes an array of OleDb Parameters return ExecuteNonQuery(transaction, CommandType. StoredProcedure, spName, commandParameters); } //otherwise we can just call the SP without para ms else { return ExecuteNonQuery(transaction, CommandType. StoredProcedure, spName); } } #endregion ExecuteNonQuery #region ExecuteDataSet /// <summary> /// Execute an OleDbCommand (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.StoredP rocedure, "GetOrders"); /// </remarks> /// <param name="connectionString">a valid connection string for an OleDbConnection</param> /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param> /// <param name="commandText">the stored procedure name or PL/SQ L command</param> /// <returns>a dataset containing the resultset generated by the command</returns> public static DataSet ExecuteDataset(string connectionString, Co

mmandType commandType, string commandText) { //pass through the call providing null for the set of Ol eDbParameters return ExecuteDataset(connectionString, commandType, com mandText, (OleDbParameter[])null); } /// <summary> /// Execute an OleDbCommand (that returns a resultset) against t he database specified in the connection string /// using the provided parameters. /// </summary> /// <remarks> /// e.g.: /// DataSet ds = ExecuteDataset(connString, CommandType.StoredP rocedure, "GetOrders", new OleDbParameter("@prodid", 24)); /// </remarks> /// <param name="connectionString">a valid connection string for an OleDbConnection</param> /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param> /// <param name="commandText">the stored procedure name or PL/SQ L command</param> /// <param name="commandParameters">an array of OleDbParamters u sed to execute the command</param> /// <returns>a dataset containing the resultset generated by the command</returns> public static DataSet ExecuteDataset(string connectionString, Co mmandType commandType, string commandText, params OleDbParameter[] commandParame ters) { //create & open an OleDbConnection, and dispose of it af ter we are done. using (OleDbConnection cn = new OleDbConnection(connecti onString)) { cn.Open(); //call the overload that takes a connection in p lace of the connection string return ExecuteDataset(cn, commandType, commandTe xt, commandParameters); } } /// <summary> /// Execute a stored procedure via an OleDbCommand (that returns a resultset) against the database specified in /// the conneciton 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 ca lled), and assign the values based on parameter order. /// </summary> /// <remarks> /// This method provides no access to output parameters or the s tored procedure's return value parameter. /// /// e.g.: /// DataSet ds = ExecuteDataset(connString, "GetOrders", 24, 36

); /// </remarks> /// <param name="connectionString">a valid connection string for an OleDbConnection</param> /// <param name="spName">the name of the stored procedure</param > /// <param name="parameterValues">an array of objects to be assi gned as the input values of the stored procedure</param> /// <returns>a dataset containing the resultset generated by the command</returns> public static DataSet ExecuteDataset(string connectionString, st ring spName, params object[] parameterValues) { //if we got parameter values, we need to figure out wher e they go if ((parameterValues != null) && (parameterValues.Length > 0)) { //pull the parameters for this stored procedure from the parameter cache (or discover them & populet the cache) OleDbParameter[] commandParameters = OleDbHelper ParameterCache.GetSpParameterSet(connectionString, spName); //assign the provided values to these parameters based on parameter order AssignParameterValues(commandParameters, paramet erValues); //call the overload that takes an array of OleDb Parameters return ExecuteDataset(connectionString, CommandT ype.StoredProcedure, spName, commandParameters); } //otherwise we can just call the SP without para ms else { return ExecuteDataset(connectionString, CommandT ype.StoredProcedure, spName); } } /// <summary> /// Execute an OleDbCommand (that returns a resultset and takes no parameters) against the provided OleDbConnection. /// </summary> /// <remarks> /// e.g.: /// DataSet ds = ExecuteDataset(conn, CommandType.StoredProcedu re, "GetOrders"); /// </remarks> /// <param name="connection">a valid OleDbConnection</param> /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param> /// <param name="commandText">the stored procedure name or PL/SQ L command</param> /// <returns>a dataset containing the resultset generated by the command</returns> public static DataSet ExecuteDataset(OleDbConnection connection, CommandType commandType, string commandText)

{ //pass through the call providing null for the set of Ol eDbParameters return ExecuteDataset(connection, commandType, commandTe xt, (OleDbParameter[])null); } /// <summary> /// Execute an OleDbCommand (that returns a resultset) against t he specified OleDbConnection /// using the provided parameters. /// </summary> /// <remarks> /// e.g.: /// DataSet ds = ExecuteDataset(conn, CommandType.StoredProcedu re, "GetOrders", new OleDbParameter("@prodid", 24)); /// </remarks> /// <param name="connection">a valid OleDbConnection</param> /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param> /// <param name="commandText">the stored procedure name or PL/SQ L command</param> /// <param name="commandParameters">an array of OleDbParamters u sed to execute the command</param> /// <returns>a dataset containing the resultset generated by the command</returns> public static DataSet ExecuteDataset(OleDbConnection connection, CommandType commandType, string commandText, params OleDbParameter[] commandPar ameters) { //create a command and prepare it for execution OleDbCommand cmd = new OleDbCommand(); PrepareCommand(cmd, connection, (OleDbTransaction)null, commandType, commandText, commandParameters); //create the DataAdapter & DataSet OleDbDataAdapter da = new OleDbDataAdapter(cmd); DataSet ds = new DataSet(); //fill the DataSet using default values for DataTable na mes, etc. da.Fill(ds); //return the dataset return ds; } /// <summary> /// Execute a stored procedure via an OleDbCommand (that returns a resultset) against the specified OleDbConnection /// 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 ca lled), and assign the values based on parameter order. /// </summary> /// <remarks> /// This method provides no access to output parameters or the s tored procedure's return value parameter. /// /// e.g.:

/// DataSet ds = ExecuteDataset(conn, "GetOrders", 24, 36); /// </remarks> /// <param name="connection">a valid OleDbConnection</param> /// <param name="spName">the name of the stored prcedure</param> /// <param name="parameterValues">an array of objects to be assi gned as the input values of the stored procedure</param> /// <returns>a dataset containing the resultset generated by the command</returns> public static DataSet ExecuteDataset(OleDbConnection connection, string spName, params object[] parameterValues) { //if we got parameter values, we need to figure out wher e they go if ((parameterValues != null) && (parameterValues.Length > 0)) { //pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache) OleDbParameter[] commandParameters = OleDbHelper ParameterCache.GetSpParameterSet(connection.ConnectionString, spName); //assign the provided values to these parameters based on parameter order AssignParameterValues(commandParameters, paramet erValues); //call the overload that takes an array of OleDb Parameters return ExecuteDataset(connection, CommandType.St oredProcedure, spName, commandParameters); } //otherwise we can just call the SP without para ms else { return ExecuteDataset(connection, CommandType.St oredProcedure, spName); } } /// <summary> /// Execute an OleDbCommand (that returns a resultset and takes no parameters) against the provided OleDbTransaction. /// </summary> /// <remarks> /// e.g.: /// DataSet ds = ExecuteDataset(trans, CommandType.StoredProced ure, "GetOrders"); /// </remarks> /// <param name="transaction">a valid OleDbTransaction</param> /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param> /// <param name="commandText">the stored procedure name or PL/SQ L command</param> /// <returns>a dataset containing the resultset generated by the command</returns> public static DataSet ExecuteDataset(OleDbTransaction transactio n, CommandType commandType, string commandText) { //pass through the call providing null for the set of Ol

eDbParameters return ExecuteDataset(transaction, commandType, commandT ext, (OleDbParameter[])null); } /// <summary> /// Execute an OleDbCommand (that returns a resultset) against t he specified OleDbTransaction /// using the provided parameters. /// </summary> /// <remarks> /// e.g.: /// DataSet ds = ExecuteDataset(trans, CommandType.StoredProced ure, "GetOrders", new OleDbParameter("@prodid", 24)); /// </remarks> /// <param name="transaction">a valid OleDbTransaction</param> /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param> /// <param name="commandText">the stored procedure name or PL/SQ L command</param> /// <param name="commandParameters">an array of OleDbParamters u sed to execute the command</param> /// <returns>a dataset containing the resultset generated by the command</returns> public static DataSet ExecuteDataset(OleDbTransaction transactio n, CommandType commandType, string commandText, params OleDbParameter[] commandP arameters) { //create a command and prepare it for execution OleDbCommand cmd = new OleDbCommand(); PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters); //create the DataAdapter & DataSet OleDbDataAdapter da = new OleDbDataAdapter(cmd); DataSet ds = new DataSet(); //fill the DataSet using default values for DataTable na mes, etc. da.Fill(ds); //return the dataset return ds; } /// <summary> /// Execute a stored procedure via an OleDbCommand (that returns a resultset) against the specified /// OleDbTransaction 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 ca lled), and assign the values based on parameter order. /// </summary> /// <remarks> /// This method provides no access to output parameters or the s tored procedure's return value parameter. /// /// e.g.: /// DataSet ds = ExecuteDataset(trans, "GetOrders", 24, 36); /// </remarks>

/// <param name="transaction">a valid OleDbTransaction</param> /// <param name="spName">the name of the stored prcedure</param> /// <param name="parameterValues">an array of objects to be assi gned as the input values of the stored procedure</param> /// <returns>a dataset containing the resultset generated by the command</returns> public static DataSet ExecuteDataset(OleDbTransaction transactio n, string spName, params object[] parameterValues) { //if we got parameter values, we need to figure out wher e they go if ((parameterValues != null) && (parameterValues.Length > 0)) { //pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache) OleDbParameter[] commandParameters = OleDbHelper ParameterCache.GetSpParameterSet(transaction.Connection.ConnectionString, spName ); //assign the provided values to these parameters based on parameter order AssignParameterValues(commandParameters, paramet erValues); //call the overload that takes an array of OleDb Parameters return ExecuteDataset(transaction, CommandType.S toredProcedure, spName, commandParameters); } //otherwise we can just call the SP without para ms else { return ExecuteDataset(transaction, CommandType.S toredProcedure, spName); } } #endregion ExecuteDataSet #region ExecuteReader /// <summary> /// this enum is used to indicate weather the connection was pro vided by the caller, or created by OleDbHelper, so that /// we can set the appropriate CommandBehavior when calling Exec uteReader() /// </summary> private enum OleDbConnectionOwnership { /// <summary>Connection is owned and managed by OleDbHel per</summary> Internal, /// <summary>Connection is owned and managed by the call er</summary> External } /// <summary>

/// Create and prepare an OleDbCommand, and call ExecuteReader w ith the appropriate CommandBehavior. /// </summary> /// <remarks> /// If we created and opened the connection, we want the connect ion to be closed when the DataReader is closed. /// /// If the caller provided the connection, we want to leave it t o them to manage. /// </remarks> /// <param name="connection">a valid OleDbConnection, on which t o execute this command</param> /// <param name="transaction">a valid OleDbTransaction, or 'null '</param> /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param> /// <param name="commandText">the stored procedure name or PL/SQ L command</param> /// <param name="commandParameters">an array of OleDbParameters to be associated with the command or 'null' if no parameters are required</param > /// <param name="connectionOwnership">indicates whether the conn ection parameter was provided by the caller, or created by OleDbHelper</param> /// <returns>OleDbDataReader containing the results of the comma nd</returns> private static OleDbDataReader ExecuteReader(OleDbConnection con nection, OleDbTransaction transaction, CommandType commandType, string commandTe xt, OleDbParameter[] commandParameters, OleDbConnectionOwnership connectionOwner ship) { //create a command and prepare it for execution OleDbCommand cmd = new OleDbCommand(); PrepareCommand(cmd, connection, transaction, commandType , commandText, commandParameters); //create a reader OleDbDataReader dr; // call ExecuteReader with the appropriate CommandBehavi or if (connectionOwnership == OleDbConnectionOwnership.Exte rnal) { dr = cmd.ExecuteReader(); } else { dr = cmd.ExecuteReader(CommandBehavior.CloseConn ection); } return dr; } /// <summary> /// Execute an OleDbCommand (that returns a resultset and takes no parameters) against the database specified in /// the connection string. /// </summary> /// <remarks>

/// e.g.: /// OleDbDataReader dr = ExecuteReader(connString, CommandType. StoredProcedure, "GetOrders"); /// </remarks> /// <param name="connectionString">a valid connection string for an OleDbConnection</param> /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param> /// <param name="commandText">the stored procedure name or PL/SQ L command</param> /// <returns>an OleDbDataReader containing the resultset generat ed by the command</returns> public static OleDbDataReader ExecuteReader(string connectionStr ing, CommandType commandType, string commandText) { //pass through the call providing null for the set of Ol eDbParameters return ExecuteReader(connectionString, commandType, comm andText, (OleDbParameter[])null); } /// <summary> /// Execute an OleDbCommand (that returns a resultset) against t he database specified in the connection string /// using the provided parameters. /// </summary> /// <remarks> /// e.g.: /// OleDbDataReader dr = ExecuteReader(connString, CommandType. StoredProcedure, "GetOrders", new OleDbParameter("@prodid", 24)); /// </remarks> /// <param name="connectionString">a valid connection string for an OleDbConnection</param> /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param> /// <param name="commandText">the stored procedure name or PL/SQ L command</param> /// <param name="commandParameters">an array of OleDbParameters used to execute the command</param> /// <returns>an OleDbDataReader containing the resultset generat ed by the command</returns> public static OleDbDataReader ExecuteReader(string connectionStr ing, CommandType commandType, string commandText, params OleDbParameter[] comman dParameters) { //create & open an OleDbbConnection OleDbConnection cn = new OleDbConnection(connectionStrin g); cn.Open(); try { //call the private overload that takes an intern ally owned connection in place of the connection string return ExecuteReader(cn, null, commandType, comm andText, commandParameters, OleDbConnectionOwnership.Internal); } catch { //if we fail to return the OleDbDataReader, we n

eeed to close the connection ourselves cn.Close(); throw; } } /// <summary> /// Execute a stored procedure via an OleDbCommand (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 ca lled), and assign the values based on parameter order. /// </summary> /// <remarks> /// This method provides no access to output parameters or the s tored procedure's return value parameter. /// /// e.g.: /// OleDbDataReader dr = ExecuteReader(connString, "GetOrders", 24, 36); /// </remarks> /// <param name="connectionString">a valid connection string for an OleDbConnection</param> /// <param name="spName">the name of the stored prcedure</param> /// <param name="parameterValues">an array of objects to be assi gned as the input values of the stored procedure</param> /// <returns>an OleDbDataReader containing the resultset generat ed by the command</returns> public static OleDbDataReader ExecuteReader(string connectionStr ing, string spName, params object[] parameterValues) { //if we got parameter values, we need to figure out wher e they go if ((parameterValues != null) && (parameterValues.Length > 0)) { //pull the parameters for this stored procedure from the parameter cache (or discover them & populate the cache) OleDbParameter[] commandParameters = OleDbHelper ParameterCache.GetSpParameterSet(connectionString, spName); //assign the provided values to these parameters based on parameter order AssignParameterValues(commandParameters, paramet erValues); //call the overload that takes an array of OleDb Parameters return ExecuteReader(connectionString, CommandTy pe.StoredProcedure, spName, commandParameters); } //otherwise we can just call the SP without params else { return ExecuteReader(connectionString, CommandTy pe.StoredProcedure, spName); } }

/// <summary> /// Execute an OleDbCommand (that returns a resultset and takes no parameters) against the provided OleDbConnection. /// </summary> /// <remarks> /// e.g.: /// OleDbDataReader dr = ExecuteReader(conn, CommandType.Stored Procedure, "GetOrders"); /// </remarks> /// <param name="connection">a valid OleDbConnection</param> /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param> /// <param name="commandText">the stored procedure name or PL/SQ L command</param> /// <returns>an OleDbDataReader containing the resultset generat ed by the command</returns> public static OleDbDataReader ExecuteReader(OleDbConnection conn ection, CommandType commandType, string commandText) { //pass through the call providing null for the set of Ol eDbParameters return ExecuteReader(connection, commandType, commandTex t, (OleDbParameter[])null); } /// <summary> /// Execute an OleDbCommand (that returns a resultset) against t he specified OleDbConnection /// using the provided parameters. /// </summary> /// <remarks> /// e.g.: /// OleDbDataReader dr = ExecuteReader(conn, CommandType.Stored Procedure, "GetOrders", new OleDbParameter("@prodid", 24)); /// </remarks> /// <param name="connection">a valid OleDbConnection</param> /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param> /// <param name="commandText">the stored procedure name or PL/SQ L command</param> /// <param name="commandParameters">an array of OleDbParamters u sed to execute the command</param> /// <returns>an OleDbDataReader containing the resultset generat ed by the command</returns> public static OleDbDataReader ExecuteReader(OleDbConnection conn ection, CommandType commandType, string commandText, params OleDbParameter[] com mandParameters) { //pass through the call to the private overload using a null transaction value and an externally owned connection return ExecuteReader(connection, (OleDbTransaction)null, commandType, commandText, commandParameters, OleDbConnectionOwnership.External) ; } /// <summary> /// Execute a stored procedure via an OleDbCommand (that returns a resultset) against the specified OleDbConnection /// 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 ca lled), and assign the values based on parameter order. /// </summary> /// <remarks> /// This method provides no access to output parameters or the s tored procedure's return value parameter. /// /// e.g.: /// OleDbDataReader dr = ExecuteReader(conn, "GetOrders", 24, 3 6); /// </remarks> /// <param name="connection">a valid OleDbConnection</param> /// <param name="spName">the name of the stored procedure</param > /// <param name="parameterValues">an array of objects to be assi gned as the input values of the stored procedure</param> /// <returns>an OleDbDataReader containing the resultset generat ed by the command</returns> public static OleDbDataReader ExecuteReader(OleDbConnection conn ection, string spName, params object[] parameterValues) { //if we got parameter values, we need to figure out wher e they go if ((parameterValues != null) && (parameterValues.Length > 0)) { OleDbParameter[] commandParameters = OleDbHelper ParameterCache.GetSpParameterSet(connection.ConnectionString, spName); AssignParameterValues(commandParameters, paramet erValues); return ExecuteReader(connection, CommandType.Sto redProcedure, spName, commandParameters); } //otherwise we can just call the SP without params else { return ExecuteReader(connection, CommandType.Sto redProcedure, spName); } } /// <summary> /// Execute an OleDbCommand (that returns a resultset and takes no parameters) against the provided OleDbTransaction. /// </summary> /// <remarks> /// e.g.: /// OleDbDataReader dr = ExecuteReader(trans, CommandType.Store dProcedure, "GetOrders"); /// </remarks> /// <param name="transaction">a valid OleDbTransaction</param> /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param> /// <param name="commandText">the stored procedure name or PL/SQ L command</param> /// <returns>an OleDbDataReader containing the resultset generat ed by the command</returns> public static OleDbDataReader ExecuteReader(OleDbTransaction tra

nsaction, CommandType commandType, string commandText) { //pass through the call providing null for the set of Ol eDbParameters return ExecuteReader(transaction, commandType, commandTe xt, (OleDbParameter[])null); } /// <summary> /// Execute an OleDbCommand (that returns a resultset) against t he specified OleDbTransaction /// using the provided parameters. /// </summary> /// <remarks> /// e.g.: /// OleDbDataReader dr = ExecuteReader(trans, CommandType.Stor edProcedure, "GetOrders", new OleDbParameter("@prodid", 24)); /// </remarks> /// <param name="transaction">a valid OleDbTransaction</param> /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param> /// <param name="commandText">the stored procedure name or PL/SQ L command</param> /// <param name="commandParameters">an array of OleDbParameters used to execute the command</param> /// <returns>an OleDbDataReader containing the resultset generat ed by the command</returns> public static OleDbDataReader ExecuteReader(OleDbTransaction tra nsaction, CommandType commandType, string commandText, params OleDbParameter[] c ommandParameters) { //pass through to private overload, indicating that the connection is owned by the caller return ExecuteReader(transaction.Connection, transaction , commandType, commandText, commandParameters, OleDbConnectionOwnership.External ); } /// <summary> /// Execute a stored procedure via an OleDbCommand (that returns a resultset) against the specified /// OleDbTransaction 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 ca lled), and assign the values based on parameter order. /// </summary> /// <remarks> /// This method provides no access to output parameters or the s tored procedure's return value parameter. /// /// e.g.: /// OleDbDataReader dr = ExecuteReader(trans, "GetOrders", 24, 36); /// </remarks> /// <param name="transaction">a valid OleDbTransaction</param> /// <param name="spName">the name of the stored prcedure</param> /// <param name="parameterValues">an array of objects to be assi gned as the input values of the stored procedure</param> /// <returns>an OleDbDataReader containing the resultset generat ed by the command</returns>

public static OleDbDataReader ExecuteReader(OleDbTransaction tra nsaction, string spName, params object[] parameterValues) { //if we got parameter values, we need to figure out wher e they go if ((parameterValues != null) && (parameterValues.Length > 0)) { OleDbParameter[] commandParameters = OleDbHelper ParameterCache.GetSpParameterSet(transaction.Connection.ConnectionString, spName ); AssignParameterValues(commandParameters, paramet erValues); return ExecuteReader(transaction, CommandType.St oredProcedure, spName, commandParameters); } //otherwise we can just call the SP without para ms else { return ExecuteReader(transaction, CommandType.St oredProcedure, spName); } } #endregion ExecuteReader #region ExecuteScalar /// <summary> /// Execute a OleDbCommand (that returns a 1x1 resultset and tak es 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 OleDbConnection</param> /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param> /// <param name="commandText">the stored procedure name or T-Ole Db command</param> /// <returns>an object containing the value in the 1x1 resultset generated by the command</returns> public static object ExecuteScalar(string connectionString, Comm andType commandType, string commandText) { //pass through the call providing null for the set of Ol eDbParameters return ExecuteScalar(connectionString, commandType, comm andText, (OleDbParameter[])null); } /// <summary> /// Execute a OleDbCommand (that returns a 1x1 resultset) agains

t the database specified in the connection string /// using the provided parameters. /// </summary> /// <remarks> /// e.g.: /// int orderCount = (int)ExecuteScalar(connString, CommandType .StoredProcedure, "GetOrderCount", new OleDbParameter("@prodid", 24)); /// </remarks> /// <param name="connectionString">a valid connection string for a OleDbConnection</param> /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param> /// <param name="commandText">the stored procedure name or T-Ole Db command</param> /// <param name="commandParameters">an array of OleDbParamters u sed to execute the command</param> /// <returns>an object containing the value in the 1x1 resultset generated by the command</returns> public static object ExecuteScalar(string connectionString, Comm andType commandType, string commandText, params OleDbParameter[] commandParamete rs) { //create & open a OleDbConnection, and dispose of it aft er we are done. using (OleDbConnection cn = new OleDbConnection(connecti onString)) { cn.Open(); //call the overload that takes a connection in p lace of the connection string return ExecuteScalar(cn, commandType, commandTex t, commandParameters); } } /// <summary> /// Execute a stored procedure via a OleDbCommand (that returns a 1x1 resultset) against the database specified in /// the conneciton 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 ca lled), and assign the values based on parameter order. /// </summary> /// <remarks> /// This method provides no access to output parameters or the s tored procedure's return value parameter. /// /// e.g.: /// int orderCount = (int)ExecuteScalar(connString, "GetOrderCo unt", 24, 36); /// </remarks> /// <param name="connectionString">a valid connection string for a OleDbConnection</param> /// <param name="spName">the name of the stored prcedure</param> /// <param name="parameterValues">an array of objects to be assi gned as the input values of the stored procedure</param> /// <returns>an object containing the value in the 1x1 resultset generated by the command</returns> public static object ExecuteScalar(string connectionString, stri

ng spName, params object[] parameterValues) { //if we got parameter values, we need to figure out wher e they go if ((parameterValues != null) && (parameterValues.Length > 0)) { //pull the parameters for this stored procedure from the parameter cache (or discover them & populet the cache) OleDbParameter[] commandParameters = OleDbHelper ParameterCache.GetSpParameterSet(connectionString, spName); //assign the provided values to these parameters based on parameter order AssignParameterValues(commandParameters, paramet erValues); //call the overload that takes an array of OleDb Parameters return ExecuteScalar(connectionString, CommandTy pe.StoredProcedure, spName, commandParameters); } //otherwise we can just call the SP without para ms else { return ExecuteScalar(connectionString, CommandTy pe.StoredProcedure, spName); } } /// <summary> /// Execute a OleDbCommand (that returns a 1x1 resultset and tak es no parameters) against the provided OleDbConnection. /// </summary> /// <remarks> /// e.g.: /// int orderCount = (int)ExecuteScalar(conn, CommandType.Store dProcedure, "GetOrderCount"); /// </remarks> /// <param name="connection">a valid OleDbConnection</param> /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param> /// <param name="commandText">the stored procedure name or T-Ole Db command</param> /// <returns>an object containing the value in the 1x1 resultset generated by the command</returns> public static object ExecuteScalar(OleDbConnection connection, C ommandType commandType, string commandText) { //pass through the call providing null for the set of Ol eDbParameters return ExecuteScalar(connection, commandType, commandTex t, (OleDbParameter[])null); } /// <summary> /// Execute a OleDbCommand (that returns a 1x1 resultset) agains t the specified OleDbConnection /// using the provided parameters.

/// </summary> /// <remarks> /// e.g.: /// int orderCount = (int)ExecuteScalar(conn, CommandType.Store dProcedure, "GetOrderCount", new OleDbParameter("@prodid", 24)); /// </remarks> /// <param name="connection">a valid OleDbConnection</param> /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param> /// <param name="commandText">the stored procedure name or T-Ole Db command</param> /// <param name="commandParameters">an array of OleDbParamters u sed to execute the command</param> /// <returns>an object containing the value in the 1x1 resultset generated by the command</returns> public static object ExecuteScalar(OleDbConnection connection, C ommandType commandType, string commandText, params OleDbParameter[] commandParam eters) { //create a command and prepare it for execution OleDbCommand cmd = new OleDbCommand(); PrepareCommand(cmd, connection, (OleDbTransaction)null, commandType, commandText, commandParameters); //execute the command & return the results return cmd.ExecuteScalar(); } /// <summary> /// Execute a stored procedure via a OleDbCommand (that returns a 1x1 resultset) against the specified OleDbConnection /// 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 ca lled), and assign the values based on parameter order. /// </summary> /// <remarks> /// This method provides no access to output parameters or the s tored procedure's return value parameter. /// /// e.g.: /// int orderCount = (int)ExecuteScalar(conn, "GetOrderCount", 24, 36); /// </remarks> /// <param name="connection">a valid OleDbConnection</param> /// <param name="spName">the name of the stored prcedure</param> /// <param name="parameterValues">an array of objects to be assi gned as the input values of the stored procedure</param> /// <returns>an object containing the value in the 1x1 resultset generated by the command</returns> public static object ExecuteScalar(OleDbConnection connection, s tring spName, params object[] parameterValues) { //if we got parameter values, we need to figure out wher e they go if ((parameterValues != null) && (parameterValues.Length > 0)) { //pull the parameters for this stored procedure from the parameter cache (or discover them & populet the cache)

OleDbParameter[] commandParameters = OleDbHelper ParameterCache.GetSpParameterSet(connection.ConnectionString, spName); //assign the provided values to these parameters based on parameter order AssignParameterValues(commandParameters, paramet erValues); //call the overload that takes an array of OleDb Parameters return ExecuteScalar(connection, CommandType.Sto redProcedure, spName, commandParameters); } //otherwise we can just call the SP without para ms else { return ExecuteScalar(connection, CommandType.Sto redProcedure, spName); } } /// <summary> /// Execute a OleDbCommand (that returns a 1x1 resultset and tak es no parameters) against the provided OleDbTransaction. /// </summary> /// <remarks> /// e.g.: /// int orderCount = (int)ExecuteScalar(trans, CommandType.Stor edProcedure, "GetOrderCount"); /// </remarks> /// <param name="transaction">a valid OleDbTransaction</param> /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param> /// <param name="commandText">the stored procedure name or T-Ole Db command</param> /// <returns>an object containing the value in the 1x1 resultset generated by the command</returns> public static object ExecuteScalar(OleDbTransaction transaction, CommandType commandType, string commandText) { //pass through the call providing null for the set of Ol eDbParameters return ExecuteScalar(transaction, commandType, commandTe xt, (OleDbParameter[])null); } /// <summary> /// Execute a OleDbCommand (that returns a 1x1 resultset) agains t the specified OleDbTransaction /// using the provided parameters. /// </summary> /// <remarks> /// e.g.: /// int orderCount = (int)ExecuteScalar(trans, CommandType.Stor edProcedure, "GetOrderCount", new OleDbParameter("@prodid", 24)); /// </remarks> /// <param name="transaction">a valid OleDbTransaction</param> /// <param name="commandType">the CommandType (stored procedure, text, etc.)</param>

/// <param name="commandText">the stored procedure name or T-Ole Db command</param> /// <param name="commandParameters">an array of OleDbParamters u sed to execute the command</param> /// <returns>an object containing the value in the 1x1 resultset generated by the command</returns> public static object ExecuteScalar(OleDbTransaction transaction, CommandType commandType, string commandText, params OleDbParameter[] commandPar ameters) { //create a command and prepare it for execution OleDbCommand cmd = new OleDbCommand(); PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters); //execute the command & return the results return cmd.ExecuteScalar(); } /// <summary> /// Execute a stored procedure via a OleDbCommand (that returns a 1x1 resultset) against the specified /// OleDbTransaction 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 ca lled), and assign the values based on parameter order. /// </summary> /// <remarks> /// This method provides no access to output parameters or the s tored procedure's return value parameter. /// /// e.g.: /// int orderCount = (int)ExecuteScalar(trans, "GetOrderCount", 24, 36); /// </remarks> /// <param name="transaction">a valid OleDbTransaction</param> /// <param name="spName">the name of the stored prcedure</param> /// <param name="parameterValues">an array of objects to be assi gned as the input values of the stored procedure</param> /// <returns>an object containing the value in the 1x1 resultset generated by the command</returns> public static object ExecuteScalar(OleDbTransaction transaction, string spName, params object[] parameterValues) { //if we got parameter values, we need to figure out wher e they go if ((parameterValues != null) && (parameterValues.Length > 0)) { //pull the parameters for this stored procedure from the parameter cache (or discover them & populet the cache) OleDbParameter[] commandParameters = OleDbHelper ParameterCache.GetSpParameterSet(transaction.Connection.ConnectionString, spName ); //assign the provided values to these parameters based on parameter order AssignParameterValues(commandParameters, paramet erValues);

//call the overload that takes an array of OleDb Parameters return ExecuteScalar(transaction, CommandType.St oredProcedure, spName, commandParameters); } //otherwise we can just call the SP without para ms else { return ExecuteScalar(transaction, CommandType.St oredProcedure, spName); } } #endregion ExecuteScalar } /// <summary> /// OleDbHelperParameterCache provides functions to leverage a static ca che of procedure parameters, and the /// ability to discover parameters for stored procedures at run-time. /// </summary> public sealed class OleDbHelperParameterCache { #region private methods, variables, and constructors //Since this class provides only static methods, make the defaul t constructor private to prevent //instances from being created with "new OleDbHelperParameterCac he()". private OleDbHelperParameterCache() {} private static Hashtable paramCache = Hashtable.Synchronized(new Hashtable()); /// <summary> /// resolve at run-time the appropriate set of OleDbParameters f or a stored procedure /// </summary> /// <param name="connectionString">a valid connection string for a OleDbConnection</param> /// <param name="spName">the name of the stored prcedure</param> /// <param name="includeReturnValueParameter">weather or not to onclude ther return value parameter</param> /// <returns></returns> private static OleDbParameter[] DiscoverSpParameterSet(string co nnectionString, string spName, bool includeReturnValueParameter) { using (OleDbConnection cn = new OleDbConnection(connecti onString)) using (OleDbCommand cmd = new OleDbCommand(spName,cn)) { cn.Open(); cmd.CommandType = CommandType.StoredProcedure; OleDbCommandBuilder.DeriveParameters(cmd); if (!includeReturnValueParameter) {

if (ParameterDirection.ReturnValue == cm d.Parameters[0].Direction) cmd.Parameters.RemoveAt(0); } OleDbParameter[] discoveredParameters = new OleD bParameter[cmd.Parameters.Count]; cmd.Parameters.CopyTo(discoveredParameters, 0); return discoveredParameters; } } //deep copy of cached OleDbParameter array private static OleDbParameter[] CloneParameters(OleDbParameter[] originalParameters) { OleDbParameter[] clonedParameters = new OleDbParameter[o riginalParameters.Length]; for (int i = 0, j = originalParameters.Length; i < j; i+ +) { clonedParameters[i] = (OleDbParameter)((ICloneab le)originalParameters[i]).Clone(); } return clonedParameters; } #endregion private methods, variables, and constructors #region caching functions /// <summary> /// add parameter array to the cache /// </summary> /// <param name="connectionString">a valid connection string for an OleDbConnection</param> /// <param name="commandText">the stored procedure name or T-Ole Db command</param> /// <param name="commandParameters">an array of OleDbParamters t o be cached</param> public static void CacheParameterSet(string connectionString, st ring commandText, params OleDbParameter[] commandParameters) { string hashKey = connectionString + ":" + commandText; paramCache[hashKey] = commandParameters; } /// <summary> /// retrieve a parameter array from the cache /// </summary> /// <param name="connectionString">a valid connection string for a OleDbConnection</param> /// <param name="commandText">the stored procedure name or T-Ole Db command</param> /// <returns>an array of OleDbParameters</returns>

public static OleDbParameter[] GetCachedParameterSet(string conn ectionString, string commandText) { string hashKey = connectionString + ":" + commandText; OleDbParameter[] cachedParameters = (OleDbParameter[])pa ramCache[hashKey]; if (cachedParameters == null) { return null; } else { return CloneParameters(cachedParameters); } } #endregion caching functions #region Parameter Discovery Functions /// <summary> /// Retrieves the set of OleDbParameters appropriate for the sto red procedure /// </summary> /// <remarks> /// This method will query the database for this information, an d then store it in a cache for future requests. /// </remarks> /// <param name="connectionString">a valid connection string for a OleDbConnection</param> /// <param name="spName">the name of the stored prcedure</param> /// <returns>an array of OleDbParameters</returns> public static OleDbParameter[] GetSpParameterSet(string connecti onString, string spName) { return GetSpParameterSet(connectionString, spName, true) ; } /// <summary> /// Retrieves the set of OleDbParameters appropriate for the sto red procedure /// </summary> /// <remarks> /// This method will query the database for this information, an d then store it in a cache for future requests. /// </remarks> /// <param name="connectionString">a valid connection string for an OleDbConnection</param> /// <param name="spName">the name of the stored procedure</param > /// <param name="includeReturnValueParameter">a bool value indic ating weather the return value parameter should be included in the results</para m> /// <returns>an array of OleDbParameters</returns> public static OleDbParameter[] GetSpParameterSet(string connecti onString, string spName, bool includeReturnValueParameter) {

string hashKey = connectionString + ":" + spName + (incl udeReturnValueParameter ? ":include ReturnValue Parameter":""); OleDbParameter[] cachedParameters; cachedParameters = (OleDbParameter[])paramCache[hashKey] ; if (cachedParameters == null) { cachedParameters = (OleDbParameter[])(paramCache [hashKey] = DiscoverSpParameterSet(connectionString, spName, includeReturnValueP arameter)); } return CloneParameters(cachedParameters); } #endregion Parameter Discovery Functions } }