高手们帮我看看这个数据库操作类有什么缺陷？

Question

方法是静态的，
有没有更好的操作类推荐
using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using System.Data.SqlClient;
/// <summary>
/// SqlHelper 摘要說明
/// </summary>
public class SqlHelper
{
    private static readonly string strConn = ConfigurationManager.AppSettings["cnn"];
    //private static readonly string strName = ConfigurationManager.AppSettings("userName").ToString();
   // private static readonly string strPass = ConfigurationManager.AppSettings("userPass").ToString();
    //
    // TODO: 在此處添加構造函數邏輯
    //
    public SqlHelper()
    {
    }
    public static SqlDataReader ExcuteRead(string nText, CommandType nType, SqlParameter[] paras)
    {        SqlConnection conn = new SqlConnection(strConn);
        SqlCommand cmd = new SqlCommand();
        try
        {
            PrepareCommand(conn, cmd, null, nType, nText, paras);
            SqlDataReader dr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
            cmd.Parameters.Clear();            return dr;
        }
        catch (SqlException ex)
        {
            throw new Exception(ex.Message, ex);        }
    }
    public static int ExcuteNonQurey(string nText, CommandType nType, SqlParameter[] paras)
    {        SqlCommand cmd = new SqlCommand();
        using (SqlConnection conn = new SqlConnection(strConn))
        {            PrepareCommand(conn, cmd, null, nType, nText, paras);
            int rows = cmd.ExecuteNonQuery();
            cmd.Parameters.Clear();
            return rows;        }
    }
    public static object ExcuteSclare(string nText, CommandType nType, SqlParameter[] paras)
    {
        SqlCommand cmd = new SqlCommand();
        using (SqlConnection conn = new SqlConnection(strConn))
        {            PrepareCommand(conn, cmd, null, nType, nText, paras);
            object obj = cmd.ExecuteScalar();
            cmd.Parameters.Clear();
            return obj;        }
    }
    public static DataSet ExcuteGetDataset(string nText, CommandType nType, SqlParameter[] paras)
    {        SqlConnection con = new SqlConnection(strConn);
        SqlCommand cmd = new SqlCommand();
        DataSet ds = new DataSet();
        try
        {
            PrepareCommand(con, cmd, null, nType, nText, paras);
            SqlDataAdapter sqlAdapter = new SqlDataAdapter(cmd);
            sqlAdapter.Fill(ds, "table1");            cmd.Parameters.Clear();            return ds;
        }
        catch (SqlException ex)
        {
            throw new Exception(ex.Message, ex);
        }
    }
   
    public static void PrepareCommand(SqlConnection con, SqlCommand cmd, SqlTransaction trans, CommandType nType, string nText, SqlParameter[] paras)
    {        if (con.State != ConnectionState.Open)
        {
            con.Open();
        }
        cmd.Connection = con;
        cmd.CommandText = nText;
        if (trans != null)
        {
            cmd.Transaction = trans;
        }
        cmd.CommandType = nType;
        if (paras != null)
        {
            foreach (SqlParameter para in paras)
            {                cmd.Parameters.Add(para);
            }
        }
    }
    private static DataSet GetDataSet(string sql)
    {
        //constring = System.Configuration.ConfigurationSettings.AppSettings("ConnectionString")
        SqlDataAdapter sda = new SqlDataAdapter(sql, strConn);
        DataSet ds = new DataSet();
        sda.Fill(ds);
        return ds;
    }
}

Answer 1

using System;
using System.Collections.Generic;
using System.Collections;
using System.Text;
using System.Data;
using System.Data.Common;
using Microsoft.Practices.EnterpriseLibrary.Data;
using System.Data.SqlClient;
using System.Web;
namespace DataAccess
{
    public sealed class DataAccess
    {
        DataAccess()
        { } 
        static readonly DataAccess da = new DataAccess();
        public static DataAccess GetDb
        {
            get
            {
                return da;
            }
        }
        public static readonly Database db = DatabaseFactory.CreateDatabase();
        public IList QueryDataSet(DbCommand cmd)
        {
            return db.ExecuteDataSet(cmd).Tables[0].DefaultView as IList;
        }
        public DbDataReader QueryDataReder(DbCommand cmd)
        {
            return db.ExecuteReader(cmd) as DbDataReader;
        }
        public bool Add<T>(T t) where T : Castle.ActiveRecord.ActiveRecordBase
        {
            try
            {
                t.Create();
                return true;
            }
            catch
            {
                return false;
            }
        }
        public bool Update<T>(T t) where T : Castle.ActiveRecord.ActiveRecordBase
        {
            try
            {
                t.Update();
                return true;
            }
            catch
            {
                return false;
            }
        }
        public bool Delete<T>(T t) where T : Castle.ActiveRecord.ActiveRecordBase
        {
            try
            {
                t.Delete();
                return true;
            }
            catch
            {
                return false;
            }
        }

Answer 2

using(SqlConnection con = new SqlConnection(strConn))
{
     /////相关代码
}
个人认为这样好一点

Answer 3

将SqlHelper类继承idispose接口，然后在SqlHelper类里添加析构函数来关闭数据库，然后在业务层调用的时候用
using(SqlHelper dd=new SqlHelper(..)),这样的话就不需要去自己数据库的关闭了，调用完后程序会自动关闭数据的连接.