一个简单的OleDb数据操作辅助类

using System;
using System.Data;
using System.Data.OleDb;
using System.Collections;
namespace Laiyunqing.OleDbHelper
...{
    数据库连接对象#region 数据库连接对象
    /**//// <summary>
    /// 通过调用DataConnection;获得数据库连接字符串;
    /// 为下列两个类库提供数据库连接字符串;
    /// </summary>
    /// <remarks>类名:connString</remarks>
    public sealed class connString
    ...{
        数据库连接字符串#region 数据库连接字符串
        
        /**//// <summary>
        /// 属性://静态类;返回数据库连接字符串
        /// </summary>
        public static string DbCnString
        ...{
            get
            ...{
                return ConnectionObj.ConnectionString;
            }
        }
        #endregion 数据库连接字符串
    }
    #endregion 数据库连接对象

    DataObj对数据库操作的核心类库#region DataObj对数据库操作的核心类库
    /**//// <summary>
    /// DataObj包含对数据库的所有操作和返回各种各种对象;
    /// 操作：包括插入、删除、修改、事务处理等数据库相关的操作;
    /// 返回对象：DataReader 、DataSet等;
    /// 可以执行SQL语句或存储过程;
    /// </summary>
    public sealed class DataObj
    ...{
        对Parameter数组参数的分配#region 对Parameter数组参数的分配

        /**//// <summary>
        /// 构造函数
        /// </summary>
        private DataObj() ...{}

        /**//// <summary>
        /// 则把OleDbParameters的每一个参数赋值到OleDbCommand中;
        /// </summary>
        /// <param name="command">Command对象</param>
        /// <param name="commandParameters">OleDbParameter数组参数</param>
        private static void AttachParameters(OleDbCommand command, OleDbParameter[] commandParameters)
        ...{
            foreach (OleDbParameter p in commandParameters)
            ...{
                if ((p.Direction == ParameterDirection.InputOutput) && (p.Value == null))
                ...{
                    p.Value = DBNull.Value;
                }
                
                command.Parameters.Add(p);
            }
        }

        /**//// <summary>
        /// 为OleDbParameter对象赋值.
        /// 则分配数组的值到Parameters数组中.
        /// </summary>
        /// <param name="commandParameters">OleDbParameter类型数组参数</param>
        /// <param name="parameterValues">Parameters数组</param>
        private static void AssignParameterValues(OleDbParameter[] commandParameters, object[] parameterValues)
        ...{
            if ((commandParameters == null) || (parameterValues == null)) 
            ...{
                return;
            }

            // 参数长度必须与参数长度相同;否则抛出错误信息;
            if (commandParameters.Length != parameterValues.Length)
            ...{
                throw new ArgumentException("Parameter count does not match Parameter Value count.");
            }

            //分配相应的值到参数位置;
            for (int i = 0, j = commandParameters.Length; i < j; i++)
            ...{
                commandParameters[i].Value = parameterValues[i];
            }
        }

        /**//// <summary>
        /// 对命令的属性进行初始化(如连接,事务等)
        /// </summary>
        /// <param name="command">Command对象</param>
        /// <param name="connection">Connection对象</param>
        /// <param name="transaction">Transaction对象或Null'</param>
        /// <param name="commandType">CommandType类型(SQL语句类型,普通SQL类型或存储过程类型)</param>
        /// <param name="commandText">SQL语名或存储过程名称</param>
        /// <param name="commandParameters">OleDbParameters数组参数</param>
        private static void PrepareCommand(OleDbCommand command, OleDbConnection connection, OleDbTransaction transaction, CommandType commandType, string commandText, OleDbParameter[] commandParameters)
        ...{
            if (connection.State != ConnectionState.Open)
            ...{
                connection.Open();
            }

            command.Connection = connection;

            command.CommandText = commandText;

            if (transaction != null)
            ...{
                command.Transaction = transaction;
            }

            command.CommandType = commandType;

            if (commandParameters != null)
            ...{
                //绑定参数
                AttachParameters(command, commandParameters);
            }

            return;
        }


        #endregion 对Parameter数组参数的分配

        ExecuteNonQuery执行插入、删除、修改、事务处理等数据库操作#region ExecuteNonQuery执行插入、删除、修改、事务处理等数据库操作
        /**//// <summary>
        /// 1.执行数据库的增删改操作
        /// </summary>
        /// <param name="commandType">执行Command对象的类型;可以是T-SQL command语句 或 存储过程;例:CommandType.Text、CommandType.StoredProcedure</param>
        /// <param name="commandText">T-SQL command语句 或 存储过程名称 例:"Select * From Orders"、"TestStoredProcedure"</param>
        /// <returns>返回一个System.Int32类型的执行数据库操作影响到的行数</returns>
        public static int ExecuteNonQuery(CommandType commandType, string commandText)
        ...{
            //调用重载(1--->2)
            return ExecuteNonQuery(commandType, commandText, (OleDbParameter[])null);
        }

        /**//// <summary>
        /// 2.执行数据库的增删改操作
        /// </summary>
        /// <remarks>
        /// 例: 
        /// int result = ExecuteNonQuery(CommandType.StoredProcedure, "PublishOrders", new OleDbParameter("@prodid", 24));
        /// </remarks>
        /// <param name="commandType">执行Command对象的类型;可以是T-SQL command语句 或 存储过程;例:CommandType.Text、CommandType.StoredProcedure</param>
        /// <param name="commandText">T-SQL command语句 或 存储过程名称 例:"Select * From Orders"、"TestStoredProcedure"</param>
        /// <param name="commandParameters">OleDbParameters数组参数;例:OleDbParameter [] param = new OleDbParameter[1];中的名称param</param>
        /// <returns>返回一个System.Int32类型的执行数据库操作影响到的行数</returns>
        public static int ExecuteNonQuery(CommandType commandType, string commandText, params OleDbParameter[] commandParameters)
        ...{
            //建立新的数据库连接对象;
            using (OleDbConnection cn = new OleDbConnection(connString.DbCnString))
            ...{
                cn.Open();

                //调用重载(2--->5)
                return ExecuteNonQuery(cn, commandType, commandText, commandParameters);
            }
        }
        /**//// <summary>
        ///  8.执行数据库的增删改操作
        /// </summary>
        /// <remarks>
        /// 例:  
        ///  int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "GetOrders", new OleDbParameter("@prodid", 24));
        /// </remarks>
        /// <param name="transaction">有效有Transation事务</param>
        /// <param name="commandType">执行Command对象的类型;可以是T-SQL command语句 或 存储过程;例:CommandType.Text、CommandType.StoredProcedure</param>
        /// <param name="commandText">T-SQL command语句 或 存储过程名称 例:"Select * From Orders"、"TestStoredProcedure"</param>
        /// <param name="commandParameters">OleDbParameters数组参数;例:OleDbParameter [] param = new OleDbParameter[1];中的名称param</param>
        /// <returns>返回一个System.Int32类型的执行数据库操作影响到的行数</returns>
        public static int ExecuteNonQuery(OleDbTransaction transaction, CommandType commandType, string commandText, params OleDbParameter[] commandParameters)
        ...{
            OleDbCommand cmd = new OleDbCommand();
            PrepareCommand(cmd, transaction.Connection, transaction, commandType, commandText, commandParameters);
            
            int retval = cmd.ExecuteNonQuery();
            
            cmd.Parameters.Clear();
            return retval;
        }

        /**//// <summary>
        /// 5.执行数据库的增删改操作
        /// </summary>
        /// <remarks>
        /// 例: 
        ///  int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders", new OleDbParameter("@prodid", 24));
        /// </remarks>
        /// <param name="connection">数据库连接对象Connection</param>
        /// <param name="commandType">执行Command对象的类型;可以是T-SQL command语句 或 存储过程;例:CommandType.Text、CommandType.StoredProcedure</param>
        /// <param name="commandText">T-SQL command语句 或 存储过程名称 例:"Select * From Orders"、"TestStoredProcedure"</param>
        /// <param name="commandParameters">OleDbParameters数组参数;例:OleDbParameter [] param = new OleDbParameter[1];中的名称param</param>
        /// <returns>返回一个System.Int32类型的执行数据库操作影响到的行数</returns>
        public static int ExecuteNonQuery(OleDbConnection connection, CommandType commandType, string commandText, params OleDbParameter[] commandParameters)
        ...{    
            //ExecuteNonQuery的核心；返回执行结果.
            OleDbCommand cmd = new OleDbCommand();
            PrepareCommand(cmd, connection, (OleDbTransaction)null, commandType, commandText, commandParameters);
            
            int retval = cmd.ExecuteNonQuery();
            
            cmd.Parameters.Clear();
            return retval;
        }

        /**//// <summary>
        ///  10.执行带事务处理的数据库的增删改操作
        /// </summary>
        /// <param name="commandText">SQL语句的字符串数组.例:string[] arrSql = {strSql1,strSql2};</param>
        /// <param name="param">OleDbParameters参数数组;例:OleDbParameter [][] arrParam = {param1,param2};</param>
        /// <returns>返回一个System.Int32类型的数据库事务操作影响到的几个表</returns>
        public static int ExecuteNonQuery(string[] commandText,OleDbParameter[][] param)
        ...{
            using(OleDbConnection cn = new OleDbConnection (connString.DbCnString))
            ...{
                cn.Open();
                OleDbCommand cmd = new OleDbCommand ();
                OleDbTransaction Trans = cn.BeginTransaction();
                        
                cmd.Connection = cn;
                cmd.Transaction = Trans;

                try
                ...{
                    int iResult = 0;
                    for (int i = 0;i < commandText.Length;i++)
                    ...{    
                        ExecuteNonQuery(Trans,CommandType.Text,commandText[i],param[i]);
                        iResult++;
                    }

                    Trans.Commit();//提交事务
                    return iResult;
                }
                catch(OleDbException e)
                ...{
                    Trans.Rollback();//回滚事务
                    e.Message.ToString();
                    return 0;
                }
                finally
                ...{
                    cmd.Dispose();
                    cn.Close();
                    cn.Dispose();
                }
            }
        }
        /**//// <summary>
        /// 11.执行数据库的增删改操作
        /// </summary>
        /// <param name="commandText">T-SQL command语句,例:"Select * From Orders"</param>
        /// <returns></returns>
        public static int  ExecuteNonQuery(string commandText)
        ...{
            return ExecuteNonQuery(CommandType.Text,commandText);
        }
        
        #endregion ExecuteNonQuery执行插入、删除、修改、事务处理等数据库操作

        ExecuteDataSet返回一个DataSet对象#region ExecuteDataSet返回一个DataSet对象
        /**//// <summary>
        /// 1.返回一个DataSet对象
        /// </summary>
        /// <remarks>
        /// 例:  
        /// DataSet ds = ExecuteDataset(CommandType.StoredProcedure, "GetOrders");
        /// </remarks>
        /// <param name="commandType">执行Command对象的类型;可以是T-SQL command语句 或 存储过程;例:CommandType.Text、CommandType.StoredProcedure</param>
        /// <param name="commandText">T-SQL command语句 或 存储过程名称 例:"Select * From Orders"、"TestStoredProcedure"</param>
        /// <returns>返回一个DataSet对象</returns>
        public static DataSet ExecuteDataset(CommandType commandType, string commandText)
        ...{
            return ExecuteDataset(commandType, commandText, (OleDbParameter[])null);
        }

        /**//// <summary>
        /// 2.返回一个DataSet对象
        /// </summary>
        /// <remarks>
        /// 例:  
        ///  DataSet ds = ExecuteDataset(CommandType.StoredProcedure, "GetOrders", new OleDbParameter("@prodid", 24));
        /// </remarks>
        /// <param name="commandType">执行Command对象的类型;可以是T-SQL command语句 或 存储过程;例:CommandType.Text、CommandType.StoredProcedure</param>
        /// <param name="commandText">T-SQL command语句 或 存储过程名称 例:"Select * From Orders"、"TestStoredProcedure"</param>
        /// <param name="commandParameters">OleDbParameters数组参数;例:OleDbParameter [] param = new OleDbParameter[1];中的名称param</param>
        /// <returns>返回一个DataSet对象</returns>
        public static DataSet ExecuteDataset(CommandType commandType, string commandText, params OleDbParameter[] commandParameters)
        ...{
            using (OleDbConnection cn = new OleDbConnection(connString.DbCnString))
            ...{
                cn.Open();

                return ExecuteDataset(cn, commandType, commandText, commandParameters);
            }
        }

        /**//// <summary>
        /// 5.返回一个DataSet对象
        /// </summary>
        /// <remarks>
        /// 例:  
        ///  DataSet ds = ExecuteDataset(conn, CommandType.StoredProcedure, "GetOrders", new OleDbParameter("@prodid", 24));
        /// </remarks>
        /// <param name="connection">数据库连接对象Connection</param>
        /// <param name="commandType">执行Command对象的类型;可以是T-SQL command语句 或 存储过程;例:CommandType.Text、CommandType.StoredProcedure</param>
        /// <param name="commandText">T-SQL command语句 或 存储过程名称 例:"Select * From Orders"、"TestStoredProcedure"</param>
        /// <param name="commandParameters">OleDbParameters数组参数;例:OleDbParameter [] param = new OleDbParameter[1];中的名称param</param>
        /// <returns>返回一个DataSet对象</returns>
        public static DataSet ExecuteDataset(OleDbConnection connection, CommandType commandType, string commandText, params OleDbParameter[] commandParameters)
        ...{
            OleDbCommand cmd = new OleDbCommand();
            PrepareCommand(cmd, connection, (OleDbTransaction)null, commandType, commandText, commandParameters);
            
            OleDbDataAdapter da = new OleDbDataAdapter(cmd);
            DataSet ds = new DataSet();

            da.Fill(ds);
                    
            cmd.Parameters.Clear();
            
            return ds;                        
        }
        
        /**//// <summary>
        /// 10.返回一个DataSet对象
        /// </summary>
        /// <param name="commandText">T-SQL command语句,例:"Select * From Orders"</param>
        /// <returns>返回一个DataSet对象</returns>
        public static DataSet ExecuteDataset(string commandText)
        ...{
            return ExecuteDataset(CommandType.Text, commandText, (OleDbParameter[])null);
        }
        #endregion ExecuteDataSet返回一个DataSet对象

        ExecuteReader返回一个DataReader对象#region ExecuteReader返回一个DataReader对象
        /**//// <summary>
        /// 创建一个枚举类型
        /// </summary>
        private enum SqlConnectionOwnership    
        ...{
            /**//// <summary>Connection is owned and managed by SqlHelper</summary>
            Internal,
            /**//// <summary>Connection is owned and managed by the caller</summary>
            External
        }

        /**//// <summary>
        /// 1.返回一个DataReader对象
        /// </summary>
        /// <param name="connection">数据库连接对象Connection</param>
        /// <param name="transaction">Transation事务对象</param>
        /// <param name="commandType">执行Command对象的类型;可以是T-SQL command语句 或 存储过程;例:CommandType.Text、CommandType.StoredProcedure</param>
        /// <param name="commandText">T-SQL command语句 或 存储过程名称 例:"Select * From Orders"、"TestStoredProcedure"</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>DataReader对象</returns>
        private static OleDbDataReader ExecuteReader(OleDbConnection connection, OleDbTransaction transaction, CommandType commandType, string commandText, OleDbParameter[] commandParameters, SqlConnectionOwnership connectionOwnership)
        ...{    
            OleDbCommand cmd = new OleDbCommand();
            PrepareCommand(cmd, connection, transaction, commandType, commandText, commandParameters);
            
            OleDbDataReader dr;
            if (connectionOwnership == SqlConnectionOwnership.External)
            ...{
                dr = cmd.ExecuteReader();
            }
            else
            ...{
                dr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
            }
            cmd.Dispose();
            cmd.Parameters.Clear();
            
            return dr;
        }

        /**//// <summary>
        /// 2.返回一个DataReader对象
        /// </summary>
        /// <remarks>
        /// 例:  
        ///  OleDbDataReader dr = ExecuteReader(CommandType.StoredProcedure, "GetOrders");
        /// </remarks>
        /// <param name="commandType">执行Command对象的类型;可以是T-SQL command语句 或 存储过程;例:CommandType.Text、CommandType.StoredProcedure</param>
        /// <param name="commandText">T-SQL command语句 或 存储过程名称 例:"Select * From Orders"、"TestStoredProcedure"</param>
        /// <returns>DataReader对象</returns>
        public static OleDbDataReader ExecuteReader(CommandType commandType, string commandText)
        ...{
            return ExecuteReader(commandType, commandText, (OleDbParameter[])null);
        }

        /**//// <summary>
        /// 3.返回一个DataReader对象
        /// </summary>
        /// <remarks>`
        /// 例:  
        ///  OleDbDataReader dr = ExecuteReader(connString, CommandType.StoredProcedure, "GetOrders", new OleDbParameter("@prodid", 24));
        /// </remarks>
        /// <param name="commandType">执行Command对象的类型;可以是T-SQL command语句 或 存储过程;例:CommandType.Text、CommandType.StoredProcedure</param>
        /// <param name="commandText">T-SQL command语句 或 存储过程名称 例:"Select * From Orders"、"TestStoredProcedure"</param>
        /// <param name="commandParameters">OleDbParameters数组参数;例:OleDbParameter [] param = new OleDbParameter[1];中的名称param</param>
        /// <returns>DataReader对象</returns>
        public static OleDbDataReader ExecuteReader(CommandType commandType, string commandText, params OleDbParameter[] commandParameters)
        ...{
            OleDbConnection cn = new OleDbConnection(connString.DbCnString);
            cn.Open();
            try
            ...{
                return ExecuteReader(cn, null, commandType, commandText, commandParameters,SqlConnectionOwnership.Internal);
            }
            catch
            ...{
                cn.Close();
                throw;
            }
        }

        /**//// <summary>
        /// 6.返回一个DataReader对象
        /// </summary>
        /// <remarks>
        /// 例:  
        ///  OleDbDataReader dr = ExecuteReader(conn, CommandType.StoredProcedure, "GetOrders", new OleDbParameter("@prodid", 24));
        /// </remarks>
        /// <param name="connection">数据库连接对象Connection</param>
        /// <param name="commandType">执行Command对象的类型;可以是T-SQL command语句 或 存储过程;例:CommandType.Text、CommandType.StoredProcedure</param>
        /// <param name="commandText">T-SQL command语句 或 存储过程名称 例:"Select * From Orders"、"TestStoredProcedure"</param>
        /// <param name="commandParameters">OleDbParameters数组参数;例:OleDbParameter [] param = new OleDbParameter[1];中的名称param</param>
        /// <returns>DataReader对象</returns>
        public static OleDbDataReader ExecuteReader(OleDbConnection connection, CommandType commandType, string commandText, params OleDbParameter[] commandParameters)
        ...{
            return ExecuteReader(connection, (OleDbTransaction)null, commandType, commandText, commandParameters, SqlConnectionOwnership.External);
        }

        /**//// <summary>
        /// 11.返回一个DataReader对象
        /// </summary>
        /// <param name="commandText">T-SQL command语句,例:"Select * From Orders"</param>
        /// <returns></returns>
        public static OleDbDataReader ExecuteReader(string commandText)
        ...{
            return ExecuteReader(CommandType.Text,commandText);
        }
        #endregion ExecuteReader返回一个DataReader对象

        ExecuteScalar 返回SQL语句执行的函数查询#region ExecuteScalar 返回SQL语句执行的函数查询
        /**//// <summary>
        /// 1.用ExecuteScalar方法执行SQL语句或存储过程
        /// </summary>
        /// <remarks>
        /// 例:  
        /// int orderCount = (int)ExecuteScalar(CommandType.StoredProcedure, "GetOrderCount");
        /// </remarks>
        /// <param name="commandType">执行Command对象的类型;可以是T-SQL command语句 或 存储过程;例:CommandType.Text、CommandType.StoredProcedure</param>
        /// <param name="commandText">T-SQL command语句 或 存储过程名称 例:"Select * From Orders"、"TestStoredProcedure"</param>
        /// <returns>返回Object对象类型数据;可能是int类型或String类型</returns>
        public static object ExecuteScalar(CommandType commandType, string commandText)
        ...{
            //重载
            return ExecuteScalar(commandType, commandText, (OleDbParameter[])null);
        }

        /**//// <summary>
        /// 2.用ExecuteScalar方法执行SQL语句或存储过程
        /// </summary>
        /// <remarks>
        /// 例:  
        /// int orderCount = (int)ExecuteScalar(CommandType.StoredProcedure, "GetOrderCount", new OleDbParameter("@prodid", 24));
        /// 返回存储过程中的@prodid.
        /// </remarks>
        /// <param name="commandType">执行Command对象的类型;可以是T-SQL command语句 或 存储过程;例:CommandType.Text、CommandType.StoredProcedure</param>
        /// <param name="commandText">T-SQL command语句 或 存储过程名称 例:"Select * From Orders"、"TestStoredProcedure"</param>
        /// <param name="commandParameters">OleDbParameters数组参数;例:OleDbParameter [] param = new OleDbParameter[1];中的名称param</param>
        /// <returns>返回Object对象类型数据;可能是int类型或String类型</returns>
        public static object ExecuteScalar(CommandType commandType, string commandText, params OleDbParameter[] commandParameters)
        ...{
            using (OleDbConnection cn = new OleDbConnection(connString.DbCnString))
            ...{
                cn.Open();

                return ExecuteScalar(cn, commandType, commandText, commandParameters);
            }
        }

        /**//// <summary>
        /// 5.用ExecuteScalar方法执行SQL语句或存储过程
        /// </summary>
        /// <remarks>
        /// 例:  
        ///  int orderCount = (int)ExecuteScalar(conn, CommandType.StoredProcedure, "GetOrderCount", new OleDbParameter("@prodid", 24));
        /// </remarks>
        /// <param name="connection">数据库连接对象Connection</param>
        /// <param name="commandType">执行Command对象的类型;可以是T-SQL command语句 或 存储过程;例:CommandType.Text、CommandType.StoredProcedure</param>
        /// <param name="commandText">T-SQL command语句 或 存储过程名称 例:"Select * From Orders"、"TestStoredProcedure"</param>
        /// <param name="commandParameters">OleDbParameters数组参数;例:OleDbParameter [] param = new OleDbParameter[1];中的名称param</param>
        /// <returns>返回Object对象类型数据;可能是int类型或String类型</returns>
        public static object ExecuteScalar(OleDbConnection connection, CommandType commandType, string commandText, params OleDbParameter[] commandParameters)
        ...{
            OleDbCommand cmd = new OleDbCommand();
            PrepareCommand(cmd, connection, (OleDbTransaction)null, commandType, commandText, commandParameters);
            
            object retval = cmd.ExecuteScalar();
            
            cmd.Parameters.Clear();
            return retval;
            
        }

        /**//// <summary>
        /// 10.用ExecuteScalar方法执行SQL语句
        /// </summary>
        /// <param name="commandText">T-SQL command语句;例:"Select * From Orders"</param>
        /// <returns>返回Object对象类型数据;可能是int类型或String类型</returns>
        public static object ExecuteScalar(string commandText)
        ...{
            //重载
            return ExecuteScalar(CommandType.Text,commandText);
        }
        #endregion ExecuteScalar 返回SQL语句执行的函数查询    

    }
    #endregion DataObj对数据库操作的核心类库

    Microsoft Visual .NET#region Microsoft Visual .NET
    /**//// <summary>.
    /// </summary>
    public sealed class SqlHelperParameterCache
    ...{

        private methods, variables, and constructors#region private methods, variables, and constructors

        /**//// <summary>
        /// 构造函数
        /// </summary>
        private SqlHelperParameterCache() ...{}

        private static Hashtable paramCache = Hashtable.Synchronized(new Hashtable());

        /**//// <summary>
        /// </summary>
        /// <param name="spName">存储过程名称</param>
        /// <param name="includeReturnValueParameter">布尔型whether or not to include their return value parameter</param>
        /// <returns>OleDbParameter数组</returns>
        private static OleDbParameter[] DiscoverSpParameterSet(string spName, bool includeReturnValueParameter)
        ...{
            using (OleDbConnection cn = new OleDbConnection(connString.DbCnString))
            using (OleDbCommand cmd = new OleDbCommand(spName,cn))
            ...{
                cn.Open();
                cmd.CommandType = CommandType.StoredProcedure;

                OleDbCommandBuilder.DeriveParameters(cmd);

                if (!includeReturnValueParameter) 
                ...{
                    cmd.Parameters.RemoveAt(0);
                }

                OleDbParameter[] discoveredParameters = new OleDbParameter[cmd.Parameters.Count];;

                cmd.Parameters.CopyTo(discoveredParameters, 0);

                return discoveredParameters;
            }
        }

        /**//// <summary>
        /// </summary>
        /// <param name="originalParameters">OleDbParameter数组</param>
        /// <returns>OleDbParameter数组</returns>
        private static OleDbParameter[] CloneParameters(OleDbParameter[] originalParameters)
        ...{
            OleDbParameter[] clonedParameters = new OleDbParameter[originalParameters.Length];

            for (int i = 0, j = originalParameters.Length; i < j; i++)
            ...{
                clonedParameters[i] = (OleDbParameter)((ICloneable)originalParameters[i]).Clone();
            }

            return clonedParameters;
        }

        #endregion private methods, variables, and constructors

        caching functions#region caching functions

        /**//// <summary>
        /// </summary>
        /// <param name="commandText">存储过程名称或T-SQL Command语句</param>
        /// <param name="commandParameters">OleDbParameter数组</param>
        public static void CacheParameterSet(string commandText, params OleDbParameter[] commandParameters)
        ...{
            string hashKey =connString.DbCnString + ":" + commandText;

            paramCache[hashKey] = commandParameters;
        }

        /**//// <summary>
        /// </summary>
        /// <param name="commandText">存储过程名称或T-SQL command语句</param>
        /// <returns>OleDbParameter数组</returns>
        public static OleDbParameter[] GetCachedParameterSet(string commandText)
        ...{
            string hashKey = connString.DbCnString + ":" + commandText;

            OleDbParameter[] cachedParameters = (OleDbParameter[])paramCache[hashKey];
            
            if (cachedParameters == null)
            ...{            
                return null;
            }
            else
            ...{
                return CloneParameters(cachedParameters);
            }
        }

        #endregion caching functions

        Parameter Discovery Functions#region Parameter Discovery Functions

        /**//// <summary>
        /// </summary>
        /// <param name="spName">存储过程名程</param>
        /// <returns>OleDbParameter数组</returns>
        public static OleDbParameter[] GetSpParameterSet(string spName)
        ...{
            return GetSpParameterSet(spName, false);
        }

        /**//// <summary>
        /// </summary>
        /// <param name="spName">存储过程名称</param>
        /// <param name="includeReturnValueParameter">布尔型;a bool value indicating whether the return value parameter should be included in the results</param>
        /// <returns>OleDbParameters参数</returns>
        public static OleDbParameter[] GetSpParameterSet(string spName, bool includeReturnValueParameter)
        ...{
            string hashKey = connString.DbCnString + ":" + spName + (includeReturnValueParameter ? ":include ReturnValue Parameter":"");

            OleDbParameter[] cachedParameters;
            
            cachedParameters = (OleDbParameter[])paramCache[hashKey];

            if (cachedParameters == null)
            ...{            
                cachedParameters = (OleDbParameter[])(paramCache[hashKey] = DiscoverSpParameterSet(spName, includeReturnValueParameter));
            }
            
            return CloneParameters(cachedParameters);
        }

        #endregion Parameter Discovery Functions

    }
    #endregion 
}

 

 下载代码：下载