Sql server sqlhelper-连接从未关闭

我一直在使用sqlhelper类，但在系统中的用户活动数量增加后，我遇到了问题。托管公司提到该站点在服务器的CPU上产生了沉重的负载。erkaner_slearning数据库中打开了大量连接，这些连接继续产生负载，因为这些连接从未关闭。下面是sqlhelper类。你对下面的代码有什么建议吗？我找不到任何地方需要在下面明确关闭任何连接

public abstract class SqlHelper
{

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

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

    public static int ExecuteNonQuery(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
    {

        SqlCommand cmd = new SqlCommand();

        using (SqlConnection conn = new SqlConnection(connectionString))
        {
            PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
            int val = cmd.ExecuteNonQuery();
            cmd.Parameters.Clear();
            return val;
        }
    }

    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();
        //connection.Close();
        return val;
    }

    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();
        //trans.Connection.Close();
        return val;
    }

    public static SqlDataReader ExecuteReader(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
    {
        SqlCommand cmd = new SqlCommand();
        SqlConnection conn = new SqlConnection(connectionString);

        // we use a try/catch here because if the method throws an exception we want to 
        // close the connection throw code, because no datareader will exist, hence the 
        // commandBehaviour.CloseConnection will not work
        try
        {
            PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
            SqlDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
            cmd.Parameters.Clear();
            return rdr;
        }
        catch
        {
            conn.Close();
            throw;
        }
    }

    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;
        }
    }

    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();
        //connection.Close();
        return val;
    }

    /// <summary>
    /// add parameter array to the cache
    /// </summary>
    /// <param name="cacheKey">Key to the parameter cache</param>
    /// <param name="cmdParms">an array of SqlParamters to be cached</param>
    public static void CacheParameters(string cacheKey, params SqlParameter[] commandParameters)
    {
        parmCache[cacheKey] = commandParameters;
    }

    /// <summary>
    /// Retrieve cached parameters
    /// </summary>
    /// <param name="cacheKey">key used to lookup parameters</param>
    /// <returns>Cached SqlParamters array</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;
    }

    /// <summary>
    /// Prepare a command for execution
    /// </summary>
    /// <param name="cmd">SqlCommand object</param>
    /// <param name="conn">SqlConnection object</param>
    /// <param name="trans">SqlTransaction object</param>
    /// <param name="cmdType">Cmd type e.g. stored procedure or text</param>
    /// <param name="cmdText">Command text, e.g. Select * from Products</param>
    /// <param name="cmdParms">SqlParameters to use in the command</param>
    private static void PrepareCommand(SqlCommand cmd, SqlConnection conn, SqlTransaction trans, CommandType cmdType, string cmdText, SqlParameter[] cmdParms)
    {
       // bool mustCloseConnection = false;

        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);
        }


    }
}

公共抽象类SqlHelper
{
public static readonly string ConnectionString=ConfigurationManager.ConnectionStrings[“slecuting_ConnectionString”]。ConnectionString；
私有静态哈希表parmCache=Hashtable.Synchronized（newhashtable（））；
公共静态int ExecuteOnQuery（字符串连接字符串、CommandType cmdType、字符串cmdText、参数SqlParameter[]commandParameters）
{
SqlCommand cmd=新的SqlCommand（）；
使用（SqlConnection conn=newsqlconnection（connectionString））
{
PrepareCommand（cmd、conn、null、cmdType、cmdText、commandParameters）；
int val=cmd.ExecuteNonQuery（）；
cmd.Parameters.Clear（）；
返回val；
}
}
公共静态int ExecuteOnQuery（SqlConnection连接、CommandType cmdType、string cmdText、params SqlParameter[]commandParameters）
{
SqlCommand cmd=新的SqlCommand（）；
PrepareCommand（cmd、connection、null、cmdType、cmdText、commandParameters）；
int val=cmd.ExecuteNonQuery（）；
cmd.Parameters.Clear（）；
//connection.Close（）；
返回val；
}
公共静态int ExecuteOnQuery（SqlTransaction trans、CommandType cmdType、string cmdText、params SqlParameter[]commandParameters）
{
SqlCommand cmd=新的SqlCommand（）；
PrepareCommand（cmd、trans.Connection、trans、cmdType、cmdText、commandParameters）；
int val=cmd.ExecuteNonQuery（）；
cmd.Parameters.Clear（）；
//trans.Connection.Close（）；
返回val；
}
公共静态SqlDataReader ExecuteReader（字符串连接字符串、CommandType cmdType、字符串cmdText、参数SqlParameter[]commandParameters）
{
SqlCommand cmd=新的SqlCommand（）；
SqlConnection conn=新的SqlConnection（connectionString）；
//我们在这里使用try/catch，因为如果方法抛出异常，我们希望
//关闭连接抛出代码，因为不存在datareader，因此
//CommandBehavior.CloseConnection将不起作用
尝试
{
PrepareCommand（cmd、conn、null、cmdType、cmdText、commandParameters）；
SqlDataReader rdr=cmd.ExecuteReader（CommandBehavior.CloseConnection）；
cmd.Parameters.Clear（）；
返回rdr；
}
抓住
{
康涅狄格州关闭（）；
投掷；
}
}
公共静态对象ExecuteScalar（string connectionString、CommandType cmdType、string cmdText、params SqlParameter[]commandParameters）
{
SqlCommand cmd=新的SqlCommand（）；
使用（SqlConnection连接=新的SqlConnection（connectionString））
{
PrepareCommand（cmd、connection、null、cmdType、cmdText、commandParameters）；
object val=cmd.ExecuteScalar（）；
cmd.Parameters.Clear（）；
返回val；
}
}
公共静态对象ExecuteScalar（SqlConnection连接、CommandType cmdType、string cmdText、params SqlParameter[]commandParameters）
{
SqlCommand cmd=新的SqlCommand（）；
PrepareCommand（cmd、connection、null、cmdType、cmdText、commandParameters）；
object val=cmd.ExecuteScalar（）；
cmd.Parameters.Clear（）；
//connection.Close（）；
返回val；
}
/// 
///将参数数组添加到缓存
/// 
///参数缓存的键
///要缓存的SqlParameters数组
公共静态void CacheParameters（字符串cacheKey，参数SqlParameter[]commandParameters）
{
parmCache[cacheKey]=commandParameters；
}
/// 
///检索缓存参数
/// 
///用于查找参数的键
///缓存的SqlParameters数组
公共静态SqlParameter[]GetCachedParameters（字符串cacheKey）
{
SqlParameter[]cachedParms=（SqlParameter[]）parmCache[cacheKey]；
if（cachedParms==null）
返回null；
SqlParameter[]clonedParms=新的SqlParameter[cachedParms.Length]；
for（int i=0，j=cachedParms.Length；i

这非常简单：每次您有一个新的SQLConnection实例，在它不再使用后，关闭它。。例如：在方法

ExecuteNonQuery

中，在方法的末尾关闭它。。对于使用SQLConnection作为参数的其他方法，这意味着您可以实例化