本文主要讲述Asp.net B/S结构 下基础的三层架构项目。
三层主要是指的界面UI层，逻辑层，数据层。
界面UI层：用于用户观看，体验的表示层。
逻辑层：程序运行逻辑的封装层。
数据层：程序数据相关操作的封装层。
每层当中还可以进行不同的详细划分，因为是基础教程，先领新手入门，所以不进行复杂的讲解。
有问题可以到我所在的社区中国微软.NET技术交流社区cnntec.com 找AZ猫 欢迎各位转载，请保留此信息，感谢您的合作。
准备工具：
Microsoft Visual Studio 2008 以下简称vs08
Microsoft SQLServer 2005 以下简称 数据库
安装就不详说了。
首先，我们新建一个项目：
如下图
打开VS2008后，点击创建项目，选择C#中的web项目，选择ASP.NET web应用程序，填写名称为StudyCSharp.Web 选择保存的路径，填写解决方案名称StudyCSharp，记得勾下创建解决方杂的选项。
确定 建好项目后，右侧的解决方案资源管理器如下图
保存的目录中应有如下图中的文件夹和文件
现在我们要对项目进行三层架构，刚才我们在创建项目的时候，已经创建了UI层，即web项目。 现在我们要创建BLL层和DAL层等 。
如下图
在文件中，我们选择添加，选择新建项目，弹出如下图
左侧，我们选择windows项目，右则我们选择类库。 然后在名称中输入StudyCSharp.BLL 路径地址可以不用更改。
创建完后项目目录下如下图
根据以上操作，我们再创建StudyCSharp.DAL和StudyCSharp.Entity及StudyCSharp.Utility
创建完如下图：
各项目说明：
StudyCSharp.Web项目：表示层，用于显示给用户观看和操作体验的
StudyCSharp.BLL项目：逻辑层，程序实现逻辑
StudyCSharp.DAL项目：数据层，程序数据相关操作封装
StudyCSharp.Entity项目：实体类，映射数据库表结构
StudyCSharp.Utility项目：实用应用层，封装相关应用操作
项目目录中如下图：
到此为止，三层的框架已经搭建好了，但是还不能正常运用，我们还要进行一些配置和修改。
首选，我们修改DAL层，删除默认的Class1.cs文件，新建SQLHelper.cs类和Configuration.cs类。
SQLHelper类CNNTEC以前发布过，现在不重复。
不明白的可以看 SqlHelper
http://www.cnntec.com/showtopic-899.html
以下是Coniguration.cs类内容
1.using System;
2.using System.Collections.Generic;
3.using System.Text;
4.using System.Data;
5.namespace StudyCSharp.DAL
6.{
7.public partial class Configuration
8.{
9.public static string DateFormat
10.{
11.get
12.{
13.string formatStr = System.Configuration.ConfigurationManager.AppSettings["DateFormat"];
14.if (formatStr == null)
15.{
16.return "yyyy/MM/dd HH:mm";
17.}
18.return "yyyy/MM/dd HH:mm";
19.}
20.}
21.private static string mConnectionString = string.Empty;
22.public static string ConnectionString
23.{
24.get
25.{
26.if (mConnectionString == string.Empty)
27.{
28.mConnectionString = System.Configuration.ConfigurationManager.AppSettings["ConnectionString"];
29.}
30.return mConnectionString;
31.}
32.set
33.{
34.mConnectionString = value;
35.}
36.}
37.static EnumNetDbType mDbType = EnumNetDbType.Sql;
38.public static EnumNetDbType DbType
39.{
40.get
41.{
42.return mDbType;
43.}
44.set
45.{
46.mDbType = value;
47.}
48.}
49.//public static int GetOracleSequenceNextValue(string sequenceName)
50.//{
51.//string sequel = "select" + sequenceName + ".nextval from dual";
52.//return (int)(OracleHelper.ExecuteScalar(ConnectionString, CommandType.Text, sequel));
53.//}
54.}
55.public enum EnumNetDbType
56.{
57.Sql = 0,
58.Oracle = 1,
59.OleDb = 2
60.}
61.public enum EnumPersistStatus
62.{
63.New = 0,
64.Update = 1,
65.Delete = 2
66.}
67.}
添加完2个类后，我们需对DAL项目的引用文件夹点右键，选择添加引用。
如图
选择System.Configuration，确定，添加后如下图。
完成以后我们再继续来配置web项目下的web.config文件，主要是连接数据库。
如下图
在appSettings节点下。原节点为<appSettings/> 我们改成如上图设置
发现很多新手不知道数据库连接字符串怎么写。简单的教下如何用vs08来自动生成这个字符串.
如下图
我们 打开web项目下的Default.aspx文件，选择拆分，然后双击左侧工具栏上的SqlDataSource控件。
会在视图和代码中生成相应的视图和代码，不用管它，我们点击控件上的配置数据源。
弹出窗口如下图：
选择新建链接，如上图，在弹出窗口中，选择如上图。
然后我们根据自己的数据库来配置，选择数据库，数据库认证，输入用户名，密码，保存密码，选择数据库。
点高级，出现如下图
弹出如上图对话框，就可以复制这个字符串，这个字符串就是链接字符串。
OK，现在我们来配置实体类。 实体类为数据库表的映射，即与数据库的表对应。
我们建立数据库为StudyCSharp，建立表为UserInformation 具体建表一下会儿给出代码。
我们在Entity项目上点击右键，选择添加类，然后写入如下图数据。 与数据库中表UserInformation对应。
如图：
我们做了这个数据库的实体映射后我们要怎么用呢？怎么才能操作这个实体像在操作数据库一样的呢？
我们马上来配置DAL项目。 对DAL项目右键，选择新建类。
如下图：
因为是直接项目右键，所以不用做选择。
直接输入名称即可 这里我们是操作的UserInformation所以我们类名命名为Userinformation_DAL.cs，确定
如下图：
然后在类中，我们添加如下名命空间的引用：
1.Using System.Data;
2.Using System.Data.SqlClient;
并将类前面加上public如下图
未完，照下图操作，继续添加引用
在弹出的对话框中，我们选择项目栏，选中刚才我们建立的数据训的映射类
如下图
需要的数据库脚本如下。 创建表和相关存储过程。这个不是我们主讲的核心，所以略过，赋上脚本。
1.USE [StudyCSharp]
2.GO
3.SET ANSI_NULLS ON
4.GO
5.SET QUOTED_IDENTIFIER ON
6.GO
7.CREATE TABLE [dbo].[SC_Userinformation](
8.[ID] [int] IDENTITY(1,1) NOT NULL,
9.[UserName] [nvarchar](32) COLLATE SQL_Latin1_General_CP1_CI_AS NOT NULL,
10.[UserPassword] [nvarchar](128) COLLATE SQL_Latin1_General_CP1_CI_AS NOT NULL,
11.CONSTRAINT [PK_SC_Userinformation] PRIMARY KEY CLUSTERED
12.(
13.[ID] ASC
14.)WITH (IGNORE_DUP_KEY = OFF) ON [PRIMARY]
15.) ON [PRIMARY]
16.USE [StudyCSharp]
17.GO
18.SET ANSI_NULLS ON
19.GO
20.SET QUOTED_IDENTIFIER ON
21.GO
22.CREATE PROCEDURE [dbo].[SP_SelectAllFromUserinformatoin]
23.AS
24.BEGIN
25.Select * from SC_userinformation
26.END
27.USE [StudyCSharp]
28.GO
29.SET ANSI_NULLS ON
30.GO
31.SET QUOTED_IDENTIFIER ON
32.GO
33.CREATE PROCEDURE [dbo].[SP_SelectAllFromUserinformatoinById]
34.@UID int
35.AS
36.BEGIN
37.Select * from SC_userinformation where id=@UID
38.END
39.USE [StudyCSharp]
40.GO
41.SET ANSI_NULLS ON
42.GO
43.SET QUOTED_IDENTIFIER ON
44.GO
45.CREATE PROCEDURE [dbo].[SP_InsertUserinformatoin]
46.@ID int=null,
47.@UserName nvarchar(32),
48.@UserPassword nvarchar(128)
49.AS
50.BEGIN
51.Insert into SC_Userinformation
52.(
53.UserName,
54.UserPassword
55.)
56.values
57.(
58.@UserName,
59.@UserPassword
60.)
61.select @@identity as 'identity'
62.END
63.USE [StudyCSharp]
64.GO
65.SET ANSI_NULLS ON
66.GO
67.SET QUOTED_IDENTIFIER ON
68.GO
69.CREATE PROCEDURE [dbo].[SP_UpdateUserinformatoin]
70.@ID int,
71.@UserName nvarchar(32),
72.@UserPassword nvarchar(128)
73.AS
74.BEGIN
75.Update SC_Userinformation
76.SET UserName=@UserName,
77.UserPassword=@UserPassword
78.where ID=@ID
79.END
80.USE [StudyCSharp]
81.GO
82.SET ANSI_NULLS ON
83.GO
84.SET QUOTED_IDENTIFIER ON
85.GO
86.CREATE PROCEDURE [dbo].[SP_UserLogin]
87.@UserName nvarchar(32),
88.@UserPassword nvarchar(128)
89.AS
90.BEGIN
91.select count(id)
92.from SC_UserInformation
93.where username=@UserName
94.and userPassword=@UserPassword
95.END
存储过程相关调用，详细Userinformation_DAL.cs中的说明。
附上Userinformation_DAL.cs文件内容如下
1.using System;
2.using System.Collections.Generic;
3.using System.Text;
4.using System.Data;
5.using System.Data.SqlClient;
6.namespace StudyCSharp.DAL
7.{
8.public partial class Userinformation_DAL
9.{
10./// <summary>
11./// 用户登录验证
12./// </summary>
13./// <param name="userName">用户名</param>
14./// <param name="userPassword">密码</param>
15./// <returns>布尔值True成功</returns>
16.public static bool UserLogin(string userName, string userPassword)
17.{
18.string sequel = "SP_UserLogin";
19.SqlParameter[] paras = new SqlParameter[]
20.{
21.new SqlParameter("@UserLoginName", userName),
22.new SqlParameter("@UserPassword",userPassword)
23.};
24.int result =(int)SqlHelper.ExecuteScalar(Configuration.ConnectionString, CommandType.StoredProcedure, sequel, paras);
25.if (result > 0)
26.{
27.return true;
28.}
29.else
30.{
31.return false;
32.}
33.}
34./// <summary>
35./// 添加新用户
36./// </summary>
37./// <param name="ui">用户信息实体</param>
38./// <returns>用户编号</returns>
39.public static int CreateUserInfo(StudyCSharp.Entity.UserInformation ui)
40.{
41.string sequel = "SP_InsertUserinformatoin";
42.SqlParameter[] paras = (SqlParameter[])ValueParas(ui);
43.int result = SqlHelper.ExecuteNonQuery(Configuration.ConnectionString, CommandType.StoredProcedure, sequel, paras);
44.return result;
45.}
46./// <summary>
47./// 获取用户所有信息
48./// </summary>
49./// <returns>泛型实体</returns>
50.public static List<StudyCSharp.Entity.UserInformation> GetAllUserInfo()
51.{
52.string sequel = "SP_SelectAllFromUserinformatoin";
53.DataTable dt = SqlHelper.ExecuteDataSet(Configuration.ConnectionString, CommandType.StoredProcedure, sequel,null).Tables[0];
54.return LoadListFromDataView(dt.DefaultView);
55.}
56./// <summary>
57./// 获取用户所有信息同上，不同的是不是调用的存储过程，而是直接拼写的SQL
58./// </summary>
59./// <returns>DataTable</returns>
60.public static DataTable GetAllUserInfoBySql()
61.{
62.string sequel = "Select * from SC_UserInformation";
63.DataTable dt = SqlHelper.ExecuteDataSet(Configuration.ConnectionString, CommandType.Text, sequel, null).Tables[0];
64.return dt;
65.}
66./// <summary>
67./// 获取某用户信息
68./// </summary>
69./// <param name="empId">用户id</param>
70./// <returns>用户信息实体</returns>
71.public static StudyCSharp.Entity.UserInformation GetUserInfoByEmpId(string empId)
72.{
73.string sequel = "SP_SelectAllFromUserinformatoinById";
74.SqlParameter[] paras = new SqlParameter[] { new SqlParameter("@UID", empId) };
75.DataTable dt = SqlHelper.ExecuteDataSet(Configuration.ConnectionString, CommandType.StoredProcedure, sequel, paras).Tables[0];
76.if (dt.Rows.Count == 0)
77.{
78.return null;
79.}
80.else
81.{
82.DataRow row = dt.Rows[0];
83.return GetEntity(row);
84.}
85.}
86./// <summary>
87./// 更新用户信息
88./// </summary>
89./// <param name="ui">用户实体</param>
90./// <returns>影响行数</returns>
91.public static int UpdateUserInfo(StudyCSharp.Entity.UserInformation ui)
92.{
93.string sequel = "SP_UpdateUserinformatoin";
94.SqlParameter[] paras = (SqlParameter[])ValueParas(ui);
95.int result = SqlHelper.ExecuteNonQuery(Configuration.ConnectionString, CommandType.StoredProcedure, sequel, paras);
96.return result;
97.}
98./// <summary>
99./// 将DataView转换为泛型实体对象
100./// </summary>
101./// <param name="dv">DataView</param>
102./// <returns>泛型实体对象</returns>
103.private static List<StudyCSharp.Entity.UserInformation> LoadListFromDataView(DataView dv)
104.{
105.List<StudyCSharp.Entity.UserInformation> list = new List<StudyCSharp.Entity.UserInformation>();
106.for (int index = 0; index <= dv.Count - 1; index++)
107.{
108.list.Add(GetEntity(dv[index].Row));
109.}
110.return list;
111.}
112./// <summary>
113./// 从DataReader中读取数据映射到实体类的属性中
114./// </summary>
115./// <remarks></remarks>
116.private static StudyCSharp.Entity.UserInformation GetEntity(IDataReader dataReader)
117.{
118.StudyCSharp.Entity.UserInformation _obj = new StudyCSharp.Entity.UserInformation();
119.if (!dataReader["ID"].Equals(DBNull.Value))
120._obj.ID = Convert.ToInt32(dataReader["ID"]);
121.if (!dataReader["UserName"].Equals(DBNull.Value))
122._obj.UserName = Convert.ToString(dataReader["UserName"]);
123.if (!dataReader["UserPassword"].Equals(DBNull.Value))
124._obj.UserPassword = Convert.ToString(dataReader["UserPassword"]);
125.return _obj;
126.}
127./// <summary>
128./// 从行中读取数据映射到实体类的属性中
129./// </summary>
130./// <remarks></remarks>
131.private static StudyCSharp.Entity.UserInformation GetEntity(DataRow row)
132.{
133.StudyCSharp.Entity.UserInformation _obj = new StudyCSharp.Entity.UserInformation();
134.if (!row["ID"].Equals(DBNull.Value))
135._obj.ID = Convert.ToInt32(row["ID"]);
136.if (!row["UserName"].Equals(DBNull.Value))
137._obj.UserName = Convert.ToString(row["UserName"]);
138.if (!row["UserPassword"].Equals(DBNull.Value))
139._obj.UserPassword = Convert.ToString(row["UserPassword"]);
140.return _obj;
141.}
142./// <summary>
143./// 该数据访问对象的属性值装载到数据库更新参数数组Insert用
144./// </summary>
145./// <remarks></remarks>
146.private static IDbDataParameter[] ValueParas(StudyCSharp.Entity.UserInformation _obj)
147.{
148.SqlParameter[] paras = new SqlParameter[3];
149.paras[0] = new SqlParameter("@ID", _obj.ID);
150.paras[1] = new SqlParameter("@UserName", _obj.UserName);
151.paras[2] = new SqlParameter("@UserPassword", _obj.UserPassword);
152.paras[0].DbType = DbType.Int32;
153.paras[1].DbType = DbType.String;
154.paras[2].DbType = DbType.String;
155.return paras;
156.}
157.}
158.}
下篇解析三层架构的DAL及BLL还有WEB之间的关系和调用。
好的，上一篇文章我们讲到了DAL层的配置，并赋上了代码，接下来我们就要来讲解一下这些代码
本文出自：http://www.cnntec.com 作者：AZ猫 转发请注明出处，违者必究
我们接着来分析DAL层倒底做了什么。 首先，大家可以看见，在每个方法里第一行里，我都有定义一个字符串变量，引用类型，并且对这个字符串变量赋了不同的值。 我们一个方法一个方法的来解读
1./// <summary>
2. /// 用户登录验证
3. /// </summary>
4. /// <param name="userName">用户名</param>
5. /// <param name="userPassword">密码</param>
6. /// <returns>布尔值True成功</returns>
7. public static bool UserLogin(string userName, string userPassword)
8. {
9. string sequel = "SP_UserLogin";
10. SqlParameter[] paras = new SqlParameter[]
11. {
12. new SqlParameter("@UserLoginName", userName),
13. new SqlParameter("@UserPassword",userPassword)
14. };
15. int result =(int)SqlHelper.ExecuteScalar(Configuration.ConnectionString, CommandType.StoredProcedure, sequel, paras);
16. if (result > 0)
17. {
18. return true;
19. }
20. else
21. {
22. return false;
23. }
24. }
在上面的代码中，我们定义了字符串变量sequel，赋值"SP_UserLogin"，这是一个存储过程的名字。
言下之意，即这个方法中，我们要调用一个存储过程。
SqlParameter[]数组是什么呢？这个就是我们要传给存储过程的参数。
在这里调用存储过程有什么好处呢？
调用存储过程有几个好处，第一提高运行的效率，第二方便进行维护。
运行存储过程的效率要高于运行SQL的效率，而且将web压力转到数据库，有利于web与数据库的负载均衡。
当然，存储过程一般是要执行逻辑的运算和物理的运算，单单一条select * from table是没有任何区别的。
第二点我们提到了维护方便，为什么呢？
因为一但我们要改变SQL的逻辑，我们只需要去更改存储过程并更新就OK了，省去了，我们去更改CS文件，再编译，再替换DLL文件的麻烦。如果项目，分布源代码管理同时更新还相当麻烦。
接着分析，我们又定义了一个整型的变量result直观的从英文翻译过来我们可以看懂，这是结果，在这里，这个变量获取的是 SqlHelper.ExecuteScalar返回的值。表示返回第一行第列的值，至于SqlHelper.ExecuteScalar的调用详细我就 不再解释了大家可以去看之后我要发布的源码里的SQLHelper.cs类。 这个返回值，为什么大于0返回true反之返回false，是因为我们存储过程的返回值。
大家可以看脚本，存储过程SP_UserLogin我们返回的是count(id)，即查询用户的凭证在数据库中是否有效，如果总数id为0，表示用户传数的参数查询的用户名或密码是无效的，我们数据库中没有这个用户。
OK，我们再看后面的几个方法，insert和update都有整型的返回值result，那么这个result所获得的却是SqlHelper.ExecuteNonQuery方法返回的结果，这个结果是什么呢？ 对于Insert操作来说，结果存储过程，返回来的是刚插入的那条数据的唯一索引。 对于update操作来说，返回的结果则是这次操作所影响的行数。
在DAL层中，主要是针对数据进行操作，目前我们是操作的MSSQL数据库的数据。也就是对数据库中的数据进行增，删，改，查。
接下来，我们就要讲讲DAL联合Entity及数据层连合实体类的操作。 先看如下代码：
1./// <summary>
2. /// 将DataView转换为泛型实体对象
3. /// </summary>
4. /// <param name="dv">DataView</param>
5. /// <returns>泛型实体对象</returns>
6. private static List<StudyCSharp.Entity.UserInformation> LoadListFromDataView(DataView dv)
7. {
8. List<StudyCSharp.Entity.UserInformation> list = new List<StudyCSharp.Entity.UserInformation>();
9. for (int index = 0; index <= dv.Count - 1; index++)
10. {
11. list.Add(GetEntity(dv[index].Row));
12. }
13. return list;
14. }
15.
16. /// <summary>
17. /// 从DataReader中读取数据映射到实体类的属性中
18. /// </summary>
19. /// <remarks></remarks>
20. private static StudyCSharp.Entity.UserInformation GetEntity(IDataReader dataReader)
21. {
22. StudyCSharp.Entity.UserInformation _obj = new StudyCSharp.Entity.UserInformation();
23. if (!dataReader["ID"].Equals(DBNull.Value))
24. _obj.ID = Convert.ToInt32(dataReader["ID"]);
25. if (!dataReader["UserName"].Equals(DBNull.Value))
26. _obj.UserName = Convert.ToString(dataReader["UserName"]);
27. if (!dataReader["UserPassword"].Equals(DBNull.Value))
28. _obj.UserPassword = Convert.ToString(dataReader["UserPassword"]);
29. return _obj;
30. }
31. /// <summary>
32. /// 从行中读取数据映射到实体类的属性中
33. /// </summary>
34. /// <remarks></remarks>
35. private static StudyCSharp.Entity.UserInformation GetEntity(DataRow row)
36. {
37. StudyCSharp.Entity.UserInformation _obj = new StudyCSharp.Entity.UserInformation();
38. if (!row["ID"].Equals(DBNull.Value))
39. _obj.ID = Convert.ToInt32(row["ID"]);
40. if (!row["UserName"].Equals(DBNull.Value))
41. _obj.UserName = Convert.ToString(row["UserName"]);
42. if (!row["UserPassword"].Equals(DBNull.Value))
43. _obj.UserPassword = Convert.ToString(row["UserPassword"]);
44. return _obj;
45. }
46.
47. /// <summary>
48. /// 该数据访问对象的属性值装载到数据库更新参数数组Insert用
49. /// </summary>
50. /// <remarks></remarks>
51. private static IDbDataParameter[] ValueParas(StudyCSharp.Entity.UserInformation _obj)
52. {
53. SqlParameter[] paras = new SqlParameter[3];
54. paras[0] = new SqlParameter("@ID", _obj.ID);
55. paras[1] = new SqlParameter("@UserName", _obj.UserName);
56. paras[2] = new SqlParameter("@UserPassword", _obj.UserPassword);
57.
58. paras[0].DbType = DbType.Int32;
59. paras[1].DbType = DbType.String;
60. paras[2].DbType = DbType.String;
61.
62. return paras;
63. }
在如上代码中，第一个方法
1.private static List<StudyCSharp.Entity.UserInformation> LoadListFromDataView(DataView dv)
返回值为List<T>泛型对象，UserInformation的实体对象。 通过
1.private static StudyCSharp.Entity.UserInformation GetEntity(DataRow row)
方法，将数据库中取出的数据，存放到这个List泛型对象中去。后面我们在读述UI层的时候会读出显示的调用方法。
最主要咱们来看看下面这段代码是干神马用的。
1./// <summary>
2./// 该数据访问对象的属性值装载到数据库更新参数数组Insert用
3./// </summary>
4./// <remarks></remarks>
5.private static IDbDataParameter[] ValueParas(StudyCSharp.Entity.UserInformation _obj)
6.{
7.SqlParameter[] paras = new SqlParameter[3];
8.paras[0] = new SqlParameter("@ID", _obj.ID);
9.paras[1] = new SqlParameter("@UserName", _obj.UserName);
10.paras[2] = new SqlParameter("@UserPassword", _obj.UserPassword);
11.
12.paras[0].DbType = DbType.Int32;
13.paras[1].DbType = DbType.String;
14.paras[2].DbType = DbType.String;
15.
16.return paras;
17.}
看完这个方法，我们先说调用。 代码如下：
1.SqlParameter[] paras = (SqlParameter[])ValueParas(ui);
这里有一个强制的转换，转为将ValuePatas(实体)方法返回IDbDataParameter[]类型强制转换为SqlParameter[]类型。 为什么要这样做呢？
可能聪明的朋友已经注意到了。 IDbDataParameter[] 是一个通用参数接口，我们不但可以把它转成SqlParameter也可以转换OralceParameter或者DBParameter等等。聪明的朋 友又注意到了吧。我们在DAL层下为什么会有SQLHelper.cs，为什么不能有 OracleHelper,MySqlHelper,AccessSqlHelper等等，对的。如果我们向DAL下加入这些Helper并在 web.config中作出相应的数据库配置，我们不但可以在DAL调用mssql还可以调用oracle,mysql,access等等数据库。这是DAL层支持多数据库的技术所在。
OK，我们对DAL层的解析就到这里为止了，如果还有什么不明白的地方可以到CNNTEC的技术群问我。我一定会耐心的给你讲解。