企业站点的架构(以Tohes的WebSite为样例) ----数据访问层

AccessHelper 类

 

2. namespace DataAccess
3. {
4.     public class AccessHelper
5.     {
6.         private OleDbConnection conn;
7.         private static readonly string OleDbConnectionString = ConfigurationManager.ConnectionStrings["OledbConnectionStrings"].ConnectionString;
9.         /// <summary>
10.         /// OleDb 数据库访问助手
11.         /// </summary>
12.         public AccessHelper()
13.         {
14.             this.conn = new OleDbConnection(OleDbConnectionString);
15.         }
18.         /// <summary>
19.         /// 打开链接对象
20.         /// </summary>
21.         private void ConnOpen()
22.         {
23.             if (this.conn.State == ConnectionState.Closed)
24.             {
25.                 this.conn.Open();
26.             }
27.         }
29.         /// <summary>
30.         /// 关闭链接对象
31.         /// </summary>
32.         private void ConnClose()
33.         {
34.             if (this.conn.State == ConnectionState.Open)
35.             {
36.                 this.conn.Close();
37.             }
38.         }
40.         /// <summary>
41.         /// 释放链接对象资源
42.         /// </summary>
43.         public void Dispose()
44.         {
45.             this.conn.Close();
46.             this.conn.Dispose();
47.             this.conn = null;
48.         }
54.         #region 执行成员
56.         /// <summary>
57.         /// 操作 OleDb 数据库并返回影响行。
58.         /// </summary>
59.         /// <param name="cmd">命令对象</param>
60.         /// <returns>影响行</returns>
61.         public int ExecuteNonQuery(OleDbCommand cmd)
62.         {
63.             int val;
64.             cmd.Connection = this.conn;
65.             ConnOpen();
66.             try
67.             {
68.                 val = cmd.ExecuteNonQuery();
69.             }
70.             catch
71.             {
72.                 throw;
73.             }
74.             finally
75.             {
76.                 cmd.Parameters.Clear();
77.                 this.Dispose();
78.             }
79.             return val;
81.         }
83.         /// <summary>
84.         /// 操作 OleDb 数据库并返回影响行。（支持事务处理）
85.         /// </summary>
86.         /// <param name="cmd">多个命令对象</param>
87.         /// <returns>最后命令对象影响行</returns>
88.         public int ExecuteNonQuery(OleDbCommand[] cmd)
89.         {
90.             int val;
91.             ConnOpen();
92.             OleDbTransaction sqlts = this.conn.BeginTransaction();
93.             try
94.             {
95.                 for (int i = 0; i < cmd.Length; i++)
96.                 {
97.                     cmd[i].Connection = this.conn;
98.                     cmd[i].Transaction = sqlts;
99.                     cmd[i].ExecuteNonQuery();
100.                     cmd[i].Parameters.Clear();
101.                 }
102.                 sqlts.Commit();
103.                 val = 1;
104.             }
105.             catch
106.             {
107.                 sqlts.Rollback();
108.                 throw;
109.             }
110.             finally
111.             {
112.                 this.Dispose();
113.             }
116.             return val;
117.         }
119.         /// <summary>
120.         /// 操作 OleDb 数据库并返回影响行。
121.         /// </summary>
122.         /// <param name="sqlstr">SQL 语句</param>
123.         /// <returns>影响行</returns>
124.         public int ExecuteNonQuery(string sqlstr)
125.         {
126.             int val;
127.             OleDbCommand cmd = new OleDbCommand(sqlstr, this.conn);
128.             this.conn.Open();
129.             try
130.             {
131.                 val = cmd.ExecuteNonQuery();
132.             }
133.             catch
134.             {
135.                 throw;
136.             }
137.             finally
138.             {
139.                 this.Dispose();
140.             }
141.             return val;
142.         }
144.         /// <summary>
145.         /// 操作 OleDb 数据库并返回第一行第一列数据。
146.         /// </summary>
147.         /// <param name="cmd">命令对象</param>
148.         /// <returns>第一行第一列数据</returns>
149.         public object ExecuteScalar(OleDbCommand cmd)
150.         {
151.             object val;
152.             cmd.Connection = this.conn;
153.             ConnOpen();
154.             try
155.             {
156.                 val = cmd.ExecuteScalar();
157.             }
158.             catch
159.             {
160.                 throw;
161.             }
162.             finally
163.             {
164.                 cmd.Parameters.Clear();
165.                 this.Dispose();
166.             }
167.             return val;
168.         }
170.         /// <summary>
171.         /// 操作 OleDb 数据库并返回第一行第一列数据。
172.         /// </summary>
173.         /// <param name="sqlstr">SQL 语句</param>
174.         /// <returns>第一行第一列数据</returns>
175.         public object ExecuteScalar(string sqlstr)
176.         {
177.             object val;
178.             OleDbCommand cmd = new OleDbCommand(sqlstr, this.conn);
179.             this.conn.Open();
180.             try
181.             {
182.                 val = cmd.ExecuteScalar();
183.             }
184.             catch
185.             {
186.                 throw;
187.             }
188.             finally
189.             {
190.                 this.Dispose();
191.             }
192.             return val;
193.         }
195.         /// <summary>
196.         /// 操作 OleDb 数据库返回只向前数据流（需要手动关闭流）。
197.         /// </summary>
198.         /// <param name="cmd">命令对象</param>
199.         /// <returns>只向前数据流</returns>
200.         public OleDbDataReader ExecuteReader(OleDbCommand cmd)
201.         {
202.             OleDbDataReader val;
203.             cmd.Connection = this.conn;
204.             ConnOpen();
205.             try
206.             {
207.                 val = cmd.ExecuteReader(CommandBehavior.CloseConnection);
208.             }
209.             catch
210.             {
211.                 cmd.Parameters.Clear();
212.                 this.Dispose();
213.                 throw;
214.             }
215.             return val;
216.         }
218.         /// <summary>
219.         /// 操作 OleDb 数据库返回只向前数据流（需要手动关闭流）。
220.         /// </summary>
221.         /// <param name="sqlstr">SQL 语句</param>
222.         /// <returns>只向前数据流</returns>
223.         public OleDbDataReader ExecuteReader(string sqlstr)
224.         {
225.             OleDbDataReader val;
226.             OleDbCommand cmd = new OleDbCommand(sqlstr, this.conn);
227.             ConnOpen();
228.             try
229.             {
230.                 val = cmd.ExecuteReader(CommandBehavior.CloseConnection);
231.             }
232.             catch
233.             {
234.                 this.Dispose();
235.                 throw;
236.             }
237.             return val;
238.         }
240.         /// <summary>
241.         /// 操作 OleDb 数据库返回已填充的数据集。
242.         /// </summary>
243.         /// <param name="cmd">命令对象</param>
244.         /// <returns>已填充的数据集</returns>
245.         public DataSet ExecuteDataSet(OleDbCommand cmd)
246.         {
247.             cmd.Connection = this.conn;
248.             OleDbDataAdapter da = new OleDbDataAdapter(cmd);
249.             DataSet ds = new DataSet();
250.             try
251.             {
252.                 da.Fill(ds);
253.             }
254.             catch
255.             {
256.                 throw;
257.             }
258.             finally
259.             {
260.                 da.Dispose();
261.                 cmd.Parameters.Clear();
262.                 this.Dispose();
263.             }
264.             return ds;
265.         }
267.         /// <summary>
268.         /// 操作 OleDb 数据库返回已填充的数据集。
269.         /// </summary>
270.         /// <param name="sqlstr">SQL 语句</param>
271.         /// <returns>已填充的数据集</returns>
272.         public DataSet ExecuteDataSet(string sqlstr)
273.         {
274.             OleDbCommand cmd = new OleDbCommand(sqlstr, this.conn);
275.             OleDbDataAdapter da = new OleDbDataAdapter(cmd);
276.             DataSet ds = new DataSet();
277.             try
278.             {
279.                 da.Fill(ds);
280.             }
281.             catch
282.             {
283.                 throw;
284.             }
285.             finally
286.             {
287.                 da.Dispose();
288.                 cmd.Parameters.Clear();
289.                 this.Dispose();
290.             }
291.             return ds;
292.         }
294.         #endregion