基于.NET平台的分层架构实战（七）数据访问层的第一种实现:A

经过上面篇文章的介绍，整个系统的 框架 算是基本搭建完了，下面，我们要具体 实现 各个层次。关于 数据 访问 层的 实现 ，我准备讨论三种 实现 方式，这一篇文章讨论 第一 种：Access+动态生成SQL。 顾名思义，这种 实现 将使用Access作为后台 数据 库，而

经过上面篇文章的介绍，整个系统的框架算是基本搭建完了，下面，我们要具体实现各个层次。关于数据访问层的实现，我准备讨论三种实现方式，这一篇文章讨论第一种：Access+动态生成SQL。

顾名思义，这种实现将使用Access作为后台数据库，而操作方式也是最基本的使用SQL命令。

在具体编写实现代码之前，我们需要做一些准备工作：

第一步，我们要将Access数据库搭建完成，具体做法如下。

在Web工程下新建一个文件夹，命名为AccessData，并在其中新建一个mdb文件（即Access数据库文件），按照前面介绍过的数据库设计构架，将数据表及表间关系建好，这里不再赘述。

第二步，我们要进行一些配置。
打开Web工程下的Web.config文件，在其中的appSettings节点下，添加如下键值：


第一条为Access的连接字符串，第二条为Access数据库文件的路径，其中“~”表示网站根目录。

第三步，新建一个工程。
我们要新建一个工程AccessDAL，用来存放Access数据访问层的代码。

准备工作做完了，现在来实现具体的代码。

1.编写数据访问助手类
因为很多数据访问操作流程很相似，所以，这里将一些可复用的代码抽取出来，编写成助手类，以此减少代码量，提高代码复用性。
这个助手类放在AccessDAL下，叫AccessDALHelper，主要负责Access数据库的访问。它包括三个方法：
GetConnectionString：从配置文件中读取配置项，组合成连接字符串。
ExecuteSQLNonQuery：执行指定SQL语句，不返回任何值，一般用于Insert，Delete，Update命令。
ExecuteSQLDataReader：执行SQL语句返回查询结果，一般用于Select命令。
具体代码如下：

AccessDALHelper.cs:

AccessDALHelper

1. 1using System;
2. 2using System.Web;
3. 3using System.Web.Caching;
4. 4using System.Configuration;
5. 5using System.Data;
6. 6using System.Data.OleDb;
7. 7using NGuestBook.Utility;
8. 8
9. 9namespace NGuestBook.AccessDAL
10. 10{
11. 11 /**////
12. 12 /// Access数据库操作助手
13. 13 ///
14. 14 public sealed class AccessDALHelper
15. 15 {
16. 16 /**////
17. 17 /// 读取Access数据库的连接字符串
18. 18 /// 首先从缓存里读取，如果不存在则到配置文件中读取，并放入缓存
19. 19 ///
20. 20 /// Access数据库的连接字符串
21. 21 private static string GetConnectionString()
22. 22 {
23. 23 if (CacheAccess.GetFromCache("AccessConnectionString") != null)
24. 24 {
25. 25 return CacheAccess.GetFromCache("AccessConnectionString").ToString();
26. 26 }
27. 27 else
28. 28 {
29. 29 string dbPath = ConfigurationManager.AppSettings["AccessPath"];
30. 30 string dbAbsolutePath = HttpContext.Current.Server.MapPath(dbPath);
31. 31 string connectionString = ConfigurationManager.AppSettings["AccessConnectionString"];
32. 32
33. 33 CacheDependency fileDependency = new CacheDependency(HttpContext.Current.Server.MapPath("Web.Config"));
34. 34 CacheAccess.SaveToCache("AccessConnectionString", connectionString.Replace("{DBPath}", dbAbsolutePath), fileDependency);
35. 35
36. 36 return connectionString.Replace("{DBPath}", dbAbsolutePath);
37. 37 }
38. 38 }
39. 39
40. 40 /**////
41. 41 /// 执行SQL语句并且不返回任何值
42. 42 ///
43. 43 /// 所执行的SQL命令
44. 44 /// 参数集合
45. 45 public static void ExecuteSQLNonQuery(string SQLCommand,OleDbParameter[] parameters)
46. 46 {
47. 47 OleDbConnection connection = new OleDbConnection(GetConnectionString());
48. 48 OleDbCommand command = new OleDbCommand(SQLCommand, connection);
49. 49
50. 50 for (int i = 0; i < parameters.Length; i++)
51. 51 {
52. 52 command.Parameters.Add(parameters);
53. 53 }
54. 54
55. 55 connection.Open();
56. 56 command.ExecuteNonQuery();
57. 57 connection.Close();
58. 58 }
59. 59
60. 60 /**////
61. 61 /// 执行SQL语句并返回包含查询结果的DataReader
62. 62 ///
63. 63 /// 所执行的SQL命令
64. 64 /// 参数集合
65. 65 ///
66. 66 public static OleDbDataReader ExecuteSQLDataReader(string SQLCommand,OleDbParameter[] parameters)
67. 67 {
68. 68 OleDbConnection connection = new OleDbConnection(GetConnectionString());
69. 69 OleDbCommand command = new OleDbCommand(SQLCommand, connection);
70. 70
71. 71 for (int i = 0; i < parameters.Length; i++)
72. 72 {
73. 73 command.Parameters.Add(parameters);
74. 74 }
75. 75
76. 76 connection.Open();
77. 77 OleDbDataReader dataReader = command.ExecuteReader();
78. 78 //connection.Close();
79. 79
80. 80 return dataReader;
81. 81 }
82. 82 }
83. 83}

2.实现具体的数据访问操作类
因为前面已经定义了数据访问层接口，所以实现数据访问操作类就是很机械的工作了。下面仅以Admin的数据访问操作类为例：

AdminDAL:

AdminDAL

1. 1using System;
2. 2using System.Collections.Generic;
3. 3using System.Text;
4. 4using System.Data;
5. 5using System.Data.OleDb;
6. 6using NGuestBook.IDAL;
7. 7using NGuestBook.Entity;
8. 8
9. 9namespace NGuestBook.AccessDAL
10. 10{
11. 11 public class AdminDAL : IAdminDAL
12. 12 {
13. 13 /**////
14. 14 /// 插入管理员
15. 15 ///
16. 16 /// 管理员实体类
17. 17 /// 是否成功
18. 18 public bool Insert(AdminInfo admin)
19. 19 {
20. 20 string SQLCommand = "insert into [TAdmin]([Name],[Password]) values(@name,@password)";
21. 21 OleDbParameter[] parameters ={
22. 22 new OleDbParameter("name",admin.Name),
23. 23 new OleDbParameter("password",admin.Password)
24. 24 };
25. 25
26. 26 try
27. 27 {
28. 28 AccessDALHelper.ExecuteSQLNonQuery(SQLCommand, parameters);
29. 29 return true;
30. 30 }
31. 31 catch
32. 32 {
33. 33 return false;
34. 34 }
35. 35 }
36. 36
37. 37 /**////
38. 38 /// 删除管理员
39. 39 ///
40. 40 /// 欲删除的管理员的ID
41. 41 /// 是否成功
42. 42 public bool Delete(int id)
43. 43 {
44. 44 string SQLCommand = "delete from [TAdmin] where [ID]=@id";
45. 45 OleDbParameter[] parameters ={
46. 46 new OleDbParameter("id",id)
47. 47 };
48. 48
49. 49 try
50. 50 {
51. 51 AccessDALHelper.ExecuteSQLNonQuery(SQLCommand, parameters);
52. 52 return true;
53. 53 }
54. 54 catch
55. 55 {
56. 56 return false;
57. 57 }
58. 58 }
59. 59
60. 60 /**////
61. 61 /// 更新管理员信息
62. 62 ///
63. 63 /// 管理员实体类
64. 64 /// 是否成功
65. 65 public bool Update(AdminInfo admin)
66. 66 {
67. 67 string SQLCommand = "update [TAdmin] set [Name]=@name,[Password]=@password where [ID]=@id";
68. 68 OleDbParameter[] parameters ={
69. 69 new OleDbParameter("id",admin.ID),
70. 70 new OleDbParameter("name",admin.Name),
71. 71 new OleDbParameter("password",admin.Password)
72. 72 };
73. 73
74. 74 try
75. 75 {
76. 76 AccessDALHelper.ExecuteSQLNonQuery(SQLCommand, parameters);
77. 77 return true;
78. 78 }
79. 79 catch
80. 80 {
81. 81 return false;
82. 82 }
83. 83 }
84. 84
85. 85 /**////
86. 86 /// 按ID取得管理员信息
87. 87 ///
88. 88 /// 管理员ID
89. 89 /// 管理员实体类
90. 90 public AdminInfo GetByID(int id)
91. 91 {
92. 92 string SQLCommand = "select * from [TAdmin] where [ID]=@id";
93. 93 OleDbParameter[] parameters ={
94. 94 new OleDbParameter("id",id)
95. 95 };
96. 96
97. 97 try
98. 98 {
99. 99 OleDbDataReader dataReader = AccessDALHelper.ExecuteSQLDataReader(SQLCommand, parameters);
100. 100 if (!dataReader.HasRows)
101. 101 {
102. 102 throw new Exception();
103. 103 }
104. 104
105. 105 AdminInfo admin = new AdminInfo();
106. 106 dataReader.Read();
107. 107 admin.ID=(int)dataReader["ID"];
108. 108 admin.Name=(string)dataReader["Name"];
109. 109 admin.Password=(string)dataReader["Password"];
110. 110
111. 111 return admin;
112. 112 }
113. 113 catch
114. 114 {
115. 115 return null;
116. 116 }
117. 117 }
118. 118
119. 119 /**////
120. 120 /// 按用户名及密码取得管理员信息
121. 121 ///
122. 122 /// 用户名
123. 123 /// 密码
124. 124 /// 管理员实体类，不存在时返回null
125. 125 public AdminInfo GetByNameAndPassword(string name, string password)
126. 126 {
127. 127 string SQLCommand = "select * from [TAdmin] where [Name]=@name and [Password]=@password";
128. 128 OleDbParameter[] parameters ={
129. 129 new OleDbParameter("name",name),
130. 130 new OleDbParameter("password",password),
131. 131 };
132. 132
133. 133 try
134. 134 {
135. 135 OleDbDataReader dataReader = AccessDALHelper.ExecuteSQLDataReader(SQLCommand, parameters);
136. 136 if (!dataReader.HasRows)
137. 137 {
138. 138 throw new Exception();
139. 139 }
140. 140
141. 141 AdminInfo admin = new AdminInfo();
142. 142 dataReader.Read();
143. 143 admin.ID = (int)dataReader["ID"];
144. 144 admin.Name = (string)dataReader["Name"];
145. 145 admin.Password = (string)dataReader["Password"];
146. 146
147. 147 return admin;
148. 148 }
149. 149 catch
150. 150 {
151. 151 return null;
152. 152 }
153. 153 }
154. 154
155. 155 /**////
156. 156 /// 按管理员名取得管理员信息
157. 157 ///
158. 158 /// 管理员名
159. 159 /// 管理员实体类
160. 160 public AdminInfo GetByName(string name)
161. 161 {
162. 162 string SQLCommand = "select * from [TAdmin] where [Name]=@name";
163. 163 OleDbParameter[] parameters ={
164. 164 new OleDbParameter("name",name),
165. 165 };
166. 166
167. 167 try
168. 168 {
169. 169 OleDbDataReader dataReader = AccessDALHelper.ExecuteSQLDataReader(SQLCommand, parameters);
170. 170 if (!dataReader.HasRows)
171. 171 {
172. 172 throw new Exception();
173. 173 }
174. 174
175. 175 AdminInfo admin = new AdminInfo();
176. 176 dataReader.Read();
177. 177 admin.ID = (int)dataReader["ID"];
178. 178 admin.Name = (string)dataReader["Name"];
179. 179 admin.Password = (string)dataReader["Password"];
180. 180
181. 181 return admin;
182. 182 }
183. 183 catch
184. 184 {
185. 185 return null;
186. 186 }
187. 187 }
188. 188
189. 189 /**////
190. 190 /// 取得全部管理员信息
191. 191 ///
192. 192 /// 管理员实体类集合
193. 193 public IList GetAll()
194. 194 {
195. 195 string SQLCommand = "select * from [TAdmin]";
196. 196 try
197. 197 {
198. 198 OleDbDataReader dataReader = AccessDALHelper.ExecuteSQLDataReader(SQLCommand, null);
199. 199 if (!dataReader.HasRows)
200. 200 {
201. 201 throw new Exception();
202. 202 }
203. 203
204. 204 IList adminCollection = new List();
205. 205 int i = 0;
206. 206 while (dataReader.Read())
207. 207 {
208. 208 AdminInfo admin = new AdminInfo();
209. 209 admin.ID = (int)dataReader["ID"];
210. 210 admin.Name = (string)dataReader["Name"];
211. 211 admin.Password = (string)dataReader["Password"];
212. 212
213. 213 adminCollection.Add(admin);
214. 214 i++;
215. 215 }
216. 216
217. 217 return adminCollection;
218. 218 }
219. 219 catch
220. 220 {
221. 221 return null;
222. 222 }
223. 223 }
224. 224 }
225. 225}

可以看到，这里主要包括三种类型的操作，一种是修改型，如Insert；一种是返回单个实体类型，如GetByID；还有一种是返回实体类集合型，如GetAll。
MessageDAL和CommentDAL的实现非常相似，在这里不再赘述。