用于.net的SqlHelpher(sqlserver)

public static readonly string CONN_STRING_DEFAULT =
                    ConfigurationManager.ConnectionStrings["connHRDB"].ConnectionString;

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

        #region PrepareCommand等

        /// <summary>
        /// 构造SqlCommand的connection、trans、CommandType、CommandText、Parameters
        /// </summary>
        /// <param name="cmd">SqlCommand</param>
        /// <param name="conn">SqlConnection</param>
        /// <param name="trans">SqlTransaction</param>
        /// <param name="cmdType">CommandType</param>
        /// <param name="cmdText">CommandText</param>
        /// <param name="cmdParms">Parameters</param>
        private static void PrepareCommand(SqlCommand cmd, SqlConnection conn, SqlTransaction trans, CommandType cmdType, string cmdText, SqlParameter[] cmdParms)
        {
            if (trans != null)
                conn = trans.Connection;

            if (conn.State != ConnectionState.Open)
                conn.Open();

            cmd.Connection = conn;
            cmd.CommandText = cmdText;
            cmd.CommandType = cmdType;
            cmd.CommandTimeout = 120;

            if (trans != null)
                cmd.Transaction = trans;

            if (cmdParms != null)
            {
                foreach (SqlParameter parm in cmdParms)
                    cmd.Parameters.Add(parm);
            }
        }

        /// <summary>
        /// 缓冲SqlParameters到全局数组
        /// </summary>
        /// <param name="cacheKey">键值</param>
        /// <param name="cmdParms">参数数组</param>
        public static void CacheParameters(string cacheKey, SqlParameter[] cmdParms)
        {
            parmCache[cacheKey] = cmdParms;
        }

        /// <summary>
        /// 根据键，从缓冲中提取SqlParameters(新克隆的对象)
        /// </summary>
        /// <param name="cacheKey">键值</param>
        /// <returns>SqlParameter[]</returns>
        public static SqlParameter[] GetCachedParameters(string cacheKey)
        {
            SqlParameter[] cachedParms = (SqlParameter[])parmCache[cacheKey];

            if (cachedParms == null)
                return null;

            SqlParameter[] clonedParms = new SqlParameter[cachedParms.Length];

            for (int i = 0, j = cachedParms.Length; i < j; i++)
                clonedParms[i] = (SqlParameter)((ICloneable)cachedParms[i]).Clone();

            return clonedParms;
        }

        #endregion PrepareCommand等

        #region OpenConn

        /// <summary>
        /// 返回缺省的数据库连接
        /// </summary>
        /// <returns>打开的默认数据库连接</returns>
        public static System.Data.SqlClient.SqlConnection OpenConn()
        {
            return OpenConn(CONN_STRING_DEFAULT);
        }

        /// <summary>
        /// 返回指定的数据库连接
        /// </summary>
        /// <param name="connString">指定的数据库连接字符串</param>
        /// <returns>制定连接字符串代表的数据库连接</returns>
        public static System.Data.SqlClient.SqlConnection OpenConn(string connString)
        {
            try
            {
                SqlConnection sqlConn = new System.Data.SqlClient.SqlConnection(connString);
                if (sqlConn.State != ConnectionState.Open)
                    sqlConn.Open();
                return sqlConn;
            }
            catch (Exception e)
            {
                throw (e);
            }
        }

        #endregion OpenConn

        #region OpenTrans

        /// <summary>
        /// 打开一个数据库事务,使用默认的数据库连接(包括打开数据库连接)
        /// </summary>
        /// <returns></returns>
        public static System.Data.SqlClient.SqlTransaction OpenTrans()
        {
            return OpenTrans(CONN_STRING_DEFAULT);
        }

        /// <summary>
        /// 打开一个数据库事务(包括打开数据库连接)
        /// </summary>
        /// <param name="connString">指定的数据库连接字符串</param>
        /// <returns>打开的数据库事务</returns>
        public static System.Data.SqlClient.SqlTransaction OpenTrans(string connString)
        {
            try
            {
                System.Data.SqlClient.SqlConnection conn = OpenConn(connString);
                System.Data.SqlClient.SqlTransaction trans = conn.BeginTransaction();
                return trans;
            }
            catch (Exception e)
            {
                throw (e);
            }
        }

        #endregion OpenTrans

        #region ExecuteNonQuery

        /// <summary>
        /// 执行一条sql语句(包括insert,update,delete)
        /// 使用默认的数据库连接
        /// </summary>
        /// <param name="cmdType">CommandType</param>
        /// <param name="cmdText">sql语句</param>
        /// <returns>返回执行sql语句受影响的行数</returns>
        public static int ExecuteNonQuery(string cmdText)
        {
            int ret = 0;
            SqlConnection conn = null;
            try
            {
                conn = OpenConn();
                ret = ExecuteNonQuery(conn, null, CommandType.Text, cmdText, null);
                return ret;
            }
            catch (Exception e)
            {
                throw (e);
            }
            finally
            {
                if (conn != null && conn.State == ConnectionState.Open)
                    conn.Close();
            }
        }

        /// <summary>
        /// 执行一条sql语句(包括insert,update,delete)/存储过程
        /// 使用默认的数据库连接
        /// </summary>
        /// <param name="cmdType">CommandType</param>
        /// <param name="cmdText">sql语句/存储过程</param>
        /// <returns>返回执行sql语句受影响的行数</returns>
        public static int ExecuteNonQuery(CommandType cmdType, string cmdText)
        {
            int ret = 0;
            SqlConnection conn = null;
            try
            {
                conn = OpenConn();
                ret = ExecuteNonQuery(conn, null, cmdType, cmdText, null);
                return ret;
            }
            catch (Exception e)
            {
                throw (e);
            }
            finally
            {
                if (conn != null && conn.State == ConnectionState.Open)
                    conn.Close();
            }
        }

        /// <summary>
        /// 执行一条sql语句(包括insert,update,delete)
        /// 使用默认的数据库连接
        /// </summary>
        /// <param name="cmdText">sql语句</param>
        /// <param name="cmdParms">SqlCommand 的参数数组</param>
        /// <returns>返回执行sql语句受影响的行数</returns>
        public static int ExecuteNonQuery(string cmdText, params SqlParameter[] cmdParms)
        {
            int ret = 0;
            SqlConnection conn = null;
            try
            {
                conn = OpenConn();
                ret = ExecuteNonQuery(conn, null, CommandType.Text, cmdText, cmdParms);
                return ret;
            }
            catch (Exception e)
            {
                throw (e);
            }
            finally
            {
                if (conn != null && conn.State == ConnectionState.Open)
                    conn.Close();
            }
        }

        /// <summary>
        /// 执行一条sql语句(包括insert,update,delete)/存储过程
        /// 使用默认的数据库连接
        /// </summary>
        /// <param name="cmdType">CommandType</param>
        /// <param name="cmdText">sql语句/存储过程</param>
        /// <param name="cmdParms">SqlCommand 的参数数组</param>
        /// <returns>返回执行sql语句受影响的行数</returns>
        public static int ExecuteNonQuery(CommandType cmdType, string cmdText, params SqlParameter[] cmdParms)
        {
            int ret = 0;
            SqlConnection conn = null;
            try
            {
                conn = OpenConn();
                ret = ExecuteNonQuery(conn, null, cmdType, cmdText, cmdParms);
                return ret;
            }
            catch (Exception e)
            {
                throw (e);
            }
            finally
            {
                if (conn != null && conn.State == ConnectionState.Open)
                    conn.Close();
            }
        }

        /// <summary>
        /// 执行一条sql语句(包括insert,update,delete)
        /// 使用指定的数据库连接串创建连接
        /// </summary>
        /// <param name="connString">指定的数据库连接字符串</param>
        /// <param name="cmdText">sql语句/存储过程</param>
        /// <param name="cmdParms">SqlCommand 的参数数组</param>
        /// <returns>返回执行sql语句受影响的行数</returns>
        public static int ExecuteNonQuery(string connString, string cmdText, params SqlParameter[] cmdParms)
        {
            int ret = 0;
            SqlConnection conn = null;
            try
            {
                conn = OpenConn(connString);
                ret = ExecuteNonQuery(conn, null, CommandType.Text, cmdText, cmdParms);
                return ret;
            }
            catch (Exception e)
            {
                throw (e);
            }
            finally
            {
                if (conn != null && conn.State == ConnectionState.Open)
                    conn.Close();
            }
        }

        /// <summary>
        /// 执行一条返回一个DataSet的SqlCommand命令，通过专用的连接字符串。
        /// 使用参数数组提供参数
        /// </summary>
        /// <remarks>
        /// 使用示例：