个人关于SQLHelper的应用

 SQLHelper是什么我就不多说了，这里想谈一下个人关于SQLHelper的应用，希望对您有所帮助。

1. using System;
2. using System.Data;
3. using System.Configuration;
4. using System.Web;
5. using System.Web.Security;
6. using System.Collections;
7. using System.Data.SqlClient;
9. /// <summary>
10. /// 数据库的通用访问代码
11. /// 此类为抽象类，不允许实例化，在应用时直接调用即可
12. /// </summary>
13. public abstract class SqlHelper
14. {
15.     //获取数据库连接字符串，其属于静态变量且只读，项目中所有文档可以直接使用，但不能修改
16.     public static readonly string ConnectionStringLocalTransaction = ConfigurationManager.ConnectionStrings["pubsConnectionString"].ConnectionString;
18.     // 哈希表用来存储缓存的参数信息，哈希表可以存储任意类型的参数。
19.     private static Hashtable parmCache = Hashtable.Synchronized(new Hashtable());
21.     /// <summary>
22.     ///执行一个不需要返回值的SqlCommand命令，通过指定专用的连接字符串。
23.     /// 使用参数数组形式提供参数列表 
24.     /// </summary>
25.     /// <remarks>
26.     /// 使用示例：
27.     ///  int result = ExecuteNonQuery(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
28.     /// </remarks>
29.     /// <param name="connectionString">一个有效的数据库连接字符串</param>
30.     /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
31.     /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
32.     /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
33.     /// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
34.     public static int ExecuteNonQuery(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
35.     {
37.         SqlCommand cmd = new SqlCommand();
39.         using (SqlConnection conn = new SqlConnection(connectionString))
40.         {
41.             //通过PrePareCommand方法将参数逐个加入到SqlCommand的参数集合中
42.             PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
43.             int val = cmd.ExecuteNonQuery();
45.             //清空SqlCommand中的参数列表
46.             cmd.Parameters.Clear();
47.             return val;
48.         }
49.     }
50.     
51.     /// <summary>
52.     ///执行一条不返回结果的SqlCommand，通过一个已经存在的数据库连接 
53.     /// 使用参数数组提供参数
54.     /// </summary>
55.     /// <remarks>
56.     /// 使用示例：  
57.     ///  int result = ExecuteNonQuery(conn, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
58.     /// </remarks>
59.     /// <param name="conn">一个现有的数据库连接</param>
60.     /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
61.     /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
62.     /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
63.     /// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
64.     public static int ExecuteNonQuery(SqlConnection connection, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
65.     {
67.         SqlCommand cmd = new SqlCommand();
69.         PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
70.         int val = cmd.ExecuteNonQuery();
71.         cmd.Parameters.Clear();
72.         return val;
73.     }
75.     /// <summary>
76.     /// 执行一条不返回结果的SqlCommand，通过一个已经存在的数据库事物处理 
77.     /// 使用参数数组提供参数
78.     /// </summary>
79.     /// <remarks>
80.     /// 使用示例： 
81.     ///  int result = ExecuteNonQuery(trans, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
82.     /// </remarks>
83.     /// <param name="trans">一个存在的 sql 事物处理</param>
84.     /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
85.     /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
86.     /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
87.     /// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
88.     public static int ExecuteNonQuery(SqlTransaction trans, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
89.     {
90.         SqlCommand cmd = new SqlCommand();
91.         PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, commandParameters);
92.         int val = cmd.ExecuteNonQuery();
93.         cmd.Parameters.Clear();
94.         return val;
95.     }
97.     /// <summary>
98.     /// 执行一条返回结果集的SqlCommand命令，通过专用的连接字符串。
99.     /// 使用参数数组提供参数
100.     /// </summary>
101.     /// <remarks>
102.     /// 使用示例：  
103.     ///  SqlDataReader r = ExecuteReader(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
104.     /// </remarks>
105.     /// <param name="connectionString">一个有效的数据库连接字符串</param>
106.     /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
107.     /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
108.     /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
109.     /// <returns>返回一个包含结果的SqlDataReader</returns>
110.     public static SqlDataReader ExecuteReader(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
111.     {
112.         SqlCommand cmd = new SqlCommand();
113.         SqlConnection conn = new SqlConnection(connectionString);
115.         // 在这里使用try/catch处理是因为如果方法出现异常，则SqlDataReader就不存在，
116.         //CommandBehavior.CloseConnection的语句就不会执行，触发的异常由catch捕获。
117.         //关闭数据库连接，并通过throw再次引发捕捉到的异常。
118.         try
119.         {
120.             PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
121.             SqlDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
122.             cmd.Parameters.Clear();
123.             return rdr;
124.         }
125.         catch
126.         {
127.             conn.Close();
128.             throw;
129.         }
130.     }
132.     /// <summary>
133.     /// 执行一条返回第一条记录第一列的SqlCommand命令，通过专用的连接字符串。 
134.     /// 使用参数数组提供参数
135.     /// </summary>
136.     /// <remarks>
137.     /// 使用示例：  
138.     ///  Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
139.     /// </remarks>
140.     /// <param name="connectionString">一个有效的数据库连接字符串</param>
141.     /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
142.     /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
143.     /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
144.     /// <returns>返回一个object类型的数据，可以通过 Convert.To{Type}方法转换类型</returns>
145.     public static object ExecuteScalar(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
146.     {
147.         SqlCommand cmd = new SqlCommand();
149.         using (SqlConnection connection = new SqlConnection(connectionString))
150.         {
151.             PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
152.             object val = cmd.ExecuteScalar();
153.             cmd.Parameters.Clear();
154.             return val;
155.         }
156.     }
158.     /// <summary>
159.     /// 执行一条返回第一条记录第一列的SqlCommand命令，通过已经存在的数据库连接。
160.     /// 使用参数数组提供参数
161.     /// </summary>
162.     /// <remarks>
163.     /// 使用示例： 
164.     ///  Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
165.     /// </remarks>
166.     /// <param name="conn">一个已经存在的数据库连接</param>
167.     /// <param name="commandType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
168.     /// <param name="commandText">存储过程的名字或者 T-SQL 语句</param>
169.     /// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
170.     /// <returns>返回一个object类型的数据，可以通过 Convert.To{Type}方法转换类型</returns>
171.     public static object ExecuteScalar(SqlConnection connection, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
172.     {
174.         SqlCommand cmd = new SqlCommand();
176.         PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
177.         object val = cmd.ExecuteScalar();
178.         cmd.Parameters.Clear();
179.         return val;
180.     }
182.     /// <summary>
183.     /// 缓存参数数组
184.     /// </summary>
185.     /// <param name="cacheKey">参数缓存的键值</param>
186.     /// <param name="cmdParms">被缓存的参数列表</param>
187.     public static void CacheParameters(string cacheKey, params SqlParameter[] commandParameters)
188.     {
189.         parmCache[cacheKey] = commandParameters;
190.     }
192.     /// <summary>
193.     /// 获取被缓存的参数
194.     /// </summary>
195.     /// <param name="cacheKey">用于查找参数的KEY值</param>
196.     /// <returns>返回缓存的参数数组</returns>
197.     public static SqlParameter[] GetCachedParameters(string cacheKey)
198.     {
199.         SqlParameter[] cachedParms = (SqlParameter[])parmCache[cacheKey];
201.         if (cachedParms == null)
202.             return null;
204.         //新建一个参数的克隆列表
205.         SqlParameter[] clonedParms = new SqlParameter[cachedParms.Length];
207.         //通过循环为克隆参数列表赋值
208.         for (int i = 0, j = cachedParms.Length; i < j; i++)
209.             //使用clone方法复制参数列表中的参数
210.             clonedParms[i] = (SqlParameter)((ICloneable)cachedParms[i]).Clone();
212.         return clonedParms;
213.     }
215.     /// <summary>
216.     /// 为执行命令准备参数
217.     /// </summary>
218.     /// <param name="cmd">SqlCommand 命令</param>
219.     /// <param name="conn">已经存在的数据库连接</param>
220.     /// <param name="trans">数据库事物处理</param>
221.     /// <param name="cmdType">SqlCommand命令类型 (存储过程， T-SQL语句， 等等。)</param>
222.     /// <param name="cmdText">Command text，T-SQL语句 例如 Select * from Products</param>
223.     /// <param name="cmdParms">返回带参数的命令</param>
224.     private static void PrepareCommand(SqlCommand cmd, SqlConnection conn, SqlTransaction trans, CommandType cmdType, string cmdText, SqlParameter[] cmdParms)
225.     {
227.         //判断数据库连接状态
228.         if (conn.State != ConnectionState.Open)
229.             conn.Open();
231.         cmd.Connection = conn;
232.         cmd.CommandText = cmdText;
234.         //判断是否需要事物处理
235.         if (trans != null)
236.             cmd.Transaction = trans;
238.         cmd.CommandType = cmdType;
240.         if (cmdParms != null)
241.         {
242.             foreach (SqlParameter parm in cmdParms)
243.                 cmd.Parameters.Add(parm);
244.         }
245.     }
246. }

这个应该很眼熟吧，OK，下面开始：

一习惯在数据层干的事情，准备一个查询（这里我习惯用List<>），将结果返回。

1. public static List<UsersInfo> SelectAllUsersInfo()
2.     {
3.         List<UsersInfo> list = new List<UsersInfo>();
4.         SqlDataReader dr = SqlHelper.ExecuteReader(
5.             SqlHelper.ConnectionStringLocalTransaction,
6.             CommandType.Text,
7.             "select * from Users");
8.         while (dr.Read())
9.         {
10.             UsersInfo ui = new UsersInfo();
11.             ui.Id = dr.GetInt32(0);
12.             ui.Name = dr.GetString(1);
13.             ui.Sex = dr.GetBoolean(2);
14.             list.Add(ui);
15.         }
16.         dr.Close();
17.         return list;
18.     }

UserInfo是一个类是封装属性过程的地方：

1. using System;
2. using System.Data;
3. using System.Configuration;
4. using System.Web;
5. using System.Web.Security;
6. using System.Web.UI;
7. using System.Web.UI.WebControls;
8. using System.Web.UI.WebControls.WebParts;
9. using System.Web.UI.HtmlControls;
11. /// <summary>
12. /// UsersInfo 的摘要说明
13. /// </summary>
14. public class UsersInfo
15. {
16.     public UsersInfo()
17.     {}
19.     private int id;
20.     public int Id
21.     {
22.         get { return id; }
23.         set { id = value; }
24.     }
25.     private string name;
26.     public string Name
27.     {
28.         get { return name; }
29.         set { name = value; }
30.     }
31.     private bool sex;
32.     public bool Sex
33.     {
34.         get { return sex; }
35.         set { sex = value; }
36.     }
37. }

二在业务逻辑里我想检查这个查询是否成功并且要把它显示出来

1.  public static int GetAllUsersInfo(GridView gv)
2.     {
3.         try
4.         {
5.             List<UsersInfo> list = ReadData.SelectAllUsersInfo();
6.             if (list == null)
7.             {
8.                 //返回表示没有符合要求的查询值
9.                 return 1;
10.             }
11.             else
12.             {
13.                 //将符合要求的查询结果返回给页面进行显示
14.                 gv.DataSource = list;
15.                 gv.DataBind();
16.                 return 2;
17.             }
18.         }
19.         catch (Exception)
20.         {
21.             //返回标示异常值
22.             return 0;
23.         }        
24.     }

三在页面看看这个结果

1. public string Bind()
2.     {
3.         int state = ReadUsersInfo.GetAllUsersInfo(this.GridView1);
4.         switch (state)
5.         {
6.             case 0:
7.                 //查询过程出现异常
8.                 return "异常的友好提示";
9.                 this.GridView1.Visible = false;
10.                 break;
11.             case 1:
12.                 return "没有符合要求的结果";
13.                 this.GridView1.Visible = false;
14.                 break;
15.             case 2:
16.                 return null;
17.                 this.GridView1.Visible = true;
18.                 break;
19.         }
20.     }

四最后在Page_Load方法中调用一下

1. protected void Page_Load(object sender, EventArgs e)
2.     {
3.         if (!Page.IsPostBack)
4.         {
5.             Response.Write("<script>alert('" + Bind() + "');</script>");
6.         }        
7.     }

实际上个人感觉这么做还有不好的地方，显示层和业务逻辑层有渗透这个很让我头疼，曾经想把结果集的验证抽出来封一个方法，但是没有搞定List<>的动态加载问题，所以在这里也想请教一下有关的解决方法，或者也欢迎大家把自己更好的数据库分层操作拿出来看看邮箱：ask.me1@163.com。