求一个好的SqlHelper类。

Question

因为数据太多。应用池问题。于是用的aspnetpager控件配合存储过程进行分页。结果在前台还行。但是在后台有一个页面。通过下拉框来查询不同条件的数据列表。分页的时候效率可以。但是下拉框多拉几次。页面加载的就很慢了。然后就有应用池超时问题了。DataSet和DataReader到底哪个好哦？都是讲数据丢到内存里的么？还有我的SqlHelper类。》。。求一个好的SqlHelper类：1，用Using连接数据库和其他...2，返回dataset的查询方法。可满足调用不同的存储过程。
   传递不同个数的参数。...

Answer 1

using System;   
using System.Data;   
using System.Configuration;   
using System.Web;   
using System.Collections;   
using System.Data.SqlClient;   
  
/// <summary>   
/// 数据库的通用访问代码   
/// 此类为抽象类，不允许实例化，在应用时直接调用即可   
/// </summary>   
public abstract class SqlHelper   
{   
    //获取数据库连接字符串，其属于静态变量且只读，项目中所有文档可以直接使用，但不能修改   
    public static readonly string ConnectionStringLocalTransaction = ConfigurationManager.ConnectionStrings["SqlConString"].ConnectionString;   
    // 哈希表用来存储缓存的参数信息，哈希表可以存储任意类型的参数。   
    private static Hashtable parmCache = Hashtable.Synchronized(new Hashtable());   
    /// <summary>   
    ///执行一个不需要返回值的SqlCommand命令，通过指定专用的连接字符串。   
    /// 使用参数数组形式提供参数列表   
    /// </summary>   
    /// <res>   
    /// 使用示例：   
    ///  int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));   
    /// </res>   
    /// <param name="connectionString">一个有效的数据库连接字符串</param>   
    /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>   
    /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>   
    /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>   
    /// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>   
    public static int ExecuteNonQuery(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)   
    {   
        SqlCommand cmd = new SqlCommand();   
        using (SqlConnection conn = new SqlConnection(connectionString))   
        {   
            //通过PrePareCommand方法将参数逐个加入到SqlCommand的参数集合中   
            PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);   
            int val = cmd.ExecuteNonQuery();   
            //清空SqlCommand中的参数列表   
            cmd.Parameters.Clear();   
            return val;   
        }   
    }   
    /// <summary>   
    ///执行一条不返回结果的SqlCommand，通过一个已经存在的数据库连接   
    /// 使用参数数组提供参数   
    /// </summary>   
    /// <res>   
    /// 使用示例：    
    ///  int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));   
    /// </res>   
    /// <param name="conn">一个现有的数据库连接</param>   
    /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>   
    /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>   
    /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>   
    /// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>   
    public static int ExecuteNonQuery(SqlConnection connection, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)   
    {   
        SqlCommand cmd = new SqlCommand();   
        PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);   
        int val = cmd.ExecuteNonQuery();   
        cmd.Parameters.Clear();   
        return val;   
    }   
    /// <summary>   
    /// 执行一条不返回结果的SqlCommand，通过一个已经存在的数据库事物处理   
    /// 使用参数数组提供参数   
    /// </summary>   
    /// <res>   
    /// 使用示例：   
    ///  int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));   
    /// </res>   
    /// <param name="trans">一个存在的 sql 事物处理</param>   
    /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>   
    /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>   
    /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>   
    /// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>   
    public static int ExecuteNonQuery(SqlTransaction trans, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)   
    {   
        SqlCommand cmd = new SqlCommand();   
        PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, commandParameters);   
        int val = cmd.ExecuteNonQuery();   
        cmd.Parameters.Clear();   
        return val;   
    }   
    /// <summary>   
    /// 执行一条返回结果集的SqlCommand命令，通过专用的连接字符串。   
    /// 使用参数数组提供参数   
    /// </summary>   
    /// <res>   
    /// 使用示例：    
    ///  SqlDataReader r = ExecuteReader(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));   
    /// </res>   
    /// <param name="connectionString">一个有效的数据库连接字符串</param>   
    /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>   
    /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>   
    /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>   
    /// <returns>返回一个包含结果的SqlDataReader</returns>   
    public static DataSet ExecuteReader(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)   
    {   
        SqlCommand cmd = new SqlCommand();   
        SqlConnection conn = new SqlConnection(connectionString);   
        // 在这里使用try/catch处理是因为如果方法出现异常，则SqlDataReader就不存在，   
        //CommandBehavior.CloseConnection的语句就不会执行，触发的异常由catch捕获。   
        //关闭数据库连接，并通过throw再次引发捕捉到的异常。   
        try  
        {   
            PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);   
            // SqlDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);   
            SqlDataAdapter sda = new SqlDataAdapter(cmd);   
            DataSet ds = new DataSet();   
            sda.Fill(ds);   
            cmd.Parameters.Clear();   
            return ds;   
        }   
        catch  
        {   
            conn.Close();   
            throw;   
        }   
    }   

Answer 2

    /// <summary>   
    /// 执行一条返回第一条记录第一列的SqlCommand命令，通过专用的连接字符串。   
    /// 使用参数数组提供参数   
    /// </summary>   
    /// <res>   
    /// 使用示例：    
    ///  Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));   
    /// </res>   
    /// <param name="connectionString">一个有效的数据库连接字符串</param>   
    /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>   
    /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>   
    /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>   
    /// <returns>返回一个object类型的数据，可以通过 Convert.To{Type}方法转换类型</returns>   
    public static object ExecuteScalar(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)   
    {   
        SqlCommand cmd = new SqlCommand();   
        using (SqlConnection connection = new SqlConnection(connectionString))   
        {   
            PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);   
            object val = cmd.ExecuteScalar();   
            cmd.Parameters.Clear();   
            return val;   
        }   
    }   
    /// <summary>   
    /// 执行一条返回第一条记录第一列的SqlCommand命令，通过已经存在的数据库连接。   
    /// 使用参数数组提供参数   
    /// </summary>   
    /// <res>   
    /// 使用示例：   
    ///  Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));   
    /// </res>   
    /// <param name="conn">一个已经存在的数据库连接</param>   
    /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>   
    /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>   
    /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>   
    /// <returns>返回一个object类型的数据，可以通过 Convert.To{Type}方法转换类型</returns>   
    public static object ExecuteScalar(SqlConnection connection, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)   
    {   
        SqlCommand cmd = new SqlCommand();   
        PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);   
        object val = cmd.ExecuteScalar();   
        cmd.Parameters.Clear();   
        return val;   
    }   
    /// <summary>   
    /// 缓存参数数组   
    /// </summary>   
    /// <param name="cacheKey">参数缓存的键值</param>   
    /// <param name="cmdParms">被缓存的参数列表</param>   
    public static void CacheParameters(string cacheKey, params SqlParameter[] commandParameters)   
    {   
        parmCache[cacheKey] = commandParameters;   
    }   
    /// <summary>   
    /// 获取被缓存的参数   
    /// </summary>   
    /// <param name="cacheKey">用于查找参数的KEY值</param>   
    /// <returns>返回缓存的参数数组</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++)   
            //使用clone方法复制参数列表中的参数   
            clonedParms[i] = (SqlParameter)((ICloneable)cachedParms[i]).Clone();   
        return clonedParms;   
    }   
    /// <summary>   
    /// 为执行命令准备参数   
    /// </summary>   
    /// <param name="cmd">SqlCommand 命令</param>   
    /// <param name="conn">已经存在的数据库连接</param>   
    /// <param name="trans">数据库事物处理</param>   
    /// <param name="cmdType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>   
    /// <param name="cmdText">Command text，T-SQL语句 例如 Select * from Products</param>   
    /// <param name="cmdParms">返回带参数的命令</param>   
    private static void PrepareCommand(SqlCommand cmd, SqlConnection conn, SqlTransaction trans, CommandType cmdType, string cmdText, SqlParameter[] cmdParms)   
    {   
        //判断数据库连接状态   
        if (conn.State != ConnectionState.Open)   
            conn.Open();   
        cmd.Connection = conn;   
        cmd.CommandText = cmdText;   
        //判断是否需要事物处理   
        if (trans != null)   
            cmd.Transaction = trans;   
        cmd.CommandType = cmdType;   
        if (cmdParms != null)   
        {   
            foreach (SqlParameter parm in cmdParms)   
                cmd.Parameters.Add(parm);   
        }   
    }   
}  

Answer 3

到网上搜
DataSet和DataReader不比在这问快得多？你想要写好的sqlhelper？

Answer 4

using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.Data.SqlClient;
using System.Configuration;
namespace PracticeMyBookShopDAL
{
    public static class DBHelper
    {        private static SqlConnection connection;
        public static SqlConnection Connection
        {
            get
            {
                string connectionString = "Data Source=localhost;Initial Catalog=MyBookShop;User ID=sa;password=123456";
                if (connection == null)
                {
                    connection = new SqlConnection(connectionString);
                    connection.Open();
                }
                else if (connection.State == System.Data.ConnectionState.Closed)
                {
                    connection.Open();
                }
                else if (connection.State == System.Data.ConnectionState.Broken)
                {
                    connection.Close();
                    connection.Open();
                }
                return connection;
            }
        }        public static int ExecuteCommand(string safeSql)
        {
            SqlCommand cmd = new SqlCommand(safeSql, Connection);
            int result = cmd.ExecuteNonQuery();
            return result;
        }        public static int ExecuteCommand(string sql, SqlParameter[] values)
        {
            SqlCommand cmd = new SqlCommand(sql, Connection);
            cmd.Parameters.AddRange(values);
            return cmd.ExecuteNonQuery();
        }        public static int ExecuteCommand(string sql, SqlParameter value)
        {
            SqlCommand cmd = new SqlCommand(sql, Connection);
            cmd.Parameters.Add(value);
            int result = cmd.ExecuteNonQuery();
            return result;
        }
        public static int ExecuteScalar(string safeSql)
        {
            SqlCommand cmd = new SqlCommand(safeSql, Connection);
            int result = (int)cmd.ExecuteScalar();
            return result;
        }        public static int ExecuteScalar(string sql, SqlParameter[] values)
        {
            SqlCommand cmd = new SqlCommand(sql, Connection);
            cmd.Parameters.AddRange(values);
            int result = (int)cmd.ExecuteScalar();
            return result;
        }        public static int ExecuteScalar(string sql, SqlParameter value)
        {
            SqlCommand cmd = new SqlCommand(sql, Connection);
            cmd.Parameters.Add(value);
            int result = (int)cmd.ExecuteScalar();
            return result;
        }        public static SqlDataReader ExecuteReader(string safeSql)
        {
            SqlCommand cmd = new SqlCommand(safeSql, Connection);
            SqlDataReader reader = cmd.ExecuteReader();
            return reader;
        }        public static SqlDataReader ExecuteReader(string sql, SqlParameter value)
        {
            SqlCommand cmd = new SqlCommand(sql, Connection);
            cmd.Parameters.Add(value);
            SqlDataReader reader = cmd.ExecuteReader();
            return reader;
        }        public static SqlDataReader ExecuteReader(string sql, SqlParameter[] values)
        {
            SqlCommand cmd = new SqlCommand(sql, Connection);
            cmd.Parameters.AddRange(values);
            SqlDataReader reader = cmd.ExecuteReader();
            return reader;
        }
        public static DataTable GetDataSet(string safeSql)
        {
            DataSet ds = new DataSet();
            SqlCommand cmd = new SqlCommand(safeSql, Connection);
            SqlDataAdapter da = new SqlDataAdapter(cmd);
            da.Fill(ds);
            return ds.Tables[0];
        }
        public static SqlDataReader GetReader(string safeSql)
        {
            SqlCommand cmd = new SqlCommand(safeSql, Connection);
            SqlDataReader reader = cmd.ExecuteReader();
            return reader;
        }        public static SqlDataReader GetReader(string sql, params SqlParameter[] values)
        {
            SqlCommand cmd = new SqlCommand(sql, Connection);
            cmd.Parameters.AddRange(values);
            SqlDataReader reader = cmd.ExecuteReader();
            return reader;
        }
    }
}

Answer 5

参考
http://blog.csdn.net/LCL_data/archive/2009/07/19/4361258.aspx

Answer 6

http://download.csdn.net/source/367464

Answer 7

DatSet 连接数据库时是非面向连接的。把表全部读到Sql中的缓冲池，并断开于数据库的连接。
Datareader 连接数据库时是面向连接的。读表时，只能向前读取，读完数据后有用户决定是否断开连接。
DataSet读取、处理速度较慢。
DataReader读取、处理速度较快。
在对DataSet数据集中的数据进行更新后，可以把数据更新回原来的数据库。
在对DataReader中的数据进行更新后，没有办法进行数据库更新。  
在DataSet中支持分页、动态排序等操作。
在DataReader中没有分页、动态排序的功能。sqlhelper很多，看看petshop或到51aspx.com里看看很多资料
参考
参考