转基于.NET平台的分层架构实战

using System;

namespace NGuestBook.Entity
{
///

/// 实体类-管理员
///

    [Serializable]
     public class AdminInfo
    {
         private int id;
         private string name;
         private string password;

         public int ID
        {
             get { return this .id; }
             set { this .id = value; }
        }

         public string Name
        {
             get { return this .name; }
             set { this .name = value; }
        }

         public string Password
        {
             get { return this .password; }
             set { this .password = value; }
        }
    }
}

using System;

namespace NGuestBook.Entity
{
///

/// 实体类-留言
///

    [Serializable]
     public class MessageInfo
    {
         private int id;
         private string guestName;
         private string guestEmail;
         private string content;
         private DateTime time;
         private string reply;
         private string isPass;

         public int ID
        {
             get { return this .id; }
             set { this .id = value; }
        }

         public string GuestName
        {
             get { return this .guestName; }
             set { this .guestName = value; }
        }

         public string GuestEmail
        {
             get { return this .guestEmail; }
             set { this .guestEmail = value; }
        }

         public string Content
        {
             get { return this .content; }
             set { this .content = value; }
        }

         public DateTime Time
        {
             get { return this .time; }
             set { this .time = value; }
        }

         public string Reply
        {
             get { return this .reply; }
             set { this .reply = value; }
        }

         public string IsPass
        {
             get { return this .isPass; }
             set { this .isPass = value; }
        }
    }
}

using System;

namespace NGuestBook.Entity
{
///

/// 实体类-评论
///

    [Serializable]
     public class CommentInfo
    {
         private int id;
         private string content;
         private DateTime time;
         private int message;

         public int ID
        {
             get { return this .id; }
             set { this .id = value; }
        }

         public string Content
        {
             get { return this .content; }
             set { this .content = value; }
        }

         public DateTime Time
        {
             get { return this .time; }
             set { this .time = value; }
        }

         public int Message
        {
             get { return this .message; }
             set { this .message = value; }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;
using NGuestBook.Entity;

namespace NGuestBook.IBLL
{
///

/// 业务逻辑层接口-管理员
///

     public interface IAdminBLL
    {
         ///

/// 添加管理员
///

         /// 新管理员实体类
         /// 是否成功
         bool Add(AdminInfo admin);

         ///

/// 删除管理员
///

         /// 欲删除的管理员的ID
         /// 是否成功
         bool Remove( int id);

         ///

/// 修改管理员密码
///

         /// 欲修改密码的管理员的ID
         /// 新密码
         /// 是否成功
         bool ChangePassword( int id, string password);

         ///

/// 管理员登录
///

         /// 管理员登录名
         /// 管理员密码
         /// 如果登录成功，则返回相应管理员的实体类，否则返回null
        AdminInfo Login( string name, string password);

         ///

/// 取得全部管理员信息
///

         /// 管理员实体类集合
        IList < AdminInfo > GetAll();
    }
}

using System;
using System.Collections.Generic;
using System.Text;
using NGuestBook.Entity;
namespace NGuestBook.IBLL
{
///

/// 业务逻辑层接口-留言
///

     public interface IMessageBLL
    {
         ///

/// 添加留言
///

         /// 新留言实体类
         /// 是否成功
         bool Add(MessageInfo message);

         ///

/// 删除留言
///

         /// 欲删除的留言的ID
         /// 是否成功
         bool Remove( int id);

         ///

/// 回复留言
///

         /// 要回复的留言的ID
         /// 回复信息
         /// 是否成功
         bool Revert( int id, string reply);

         ///

/// 将留言通过验证
///

         /// 通过验证的留言的ID
         /// 是否成功
         bool Pass( int id);

         ///

/// 按分页取得留言信息
///

         /// 每页显示几条留言
         /// 当前页码
         /// 留言实体类集合
        IList < MessageInfo > GetByPage( int pageSize, int pageNumber);
    }
}

using System;
using System.Collections.Generic;
using System.Text;
using NGuestBook.Entity;

namespace NGuestBook.IBLL
{
///

/// 业务逻辑层接口-评论
///

     public interface ICommentBLL
    {
         ///

/// 添加评论
///

         /// 新评论实体类
         /// 是否成功
         bool Add(CommentInfo comment);

         ///

/// 删除评论
///

         /// 欲删除的评论的ID
         /// 是否成功
         bool Remove( int id);

         ///

/// 取得指定留言的全部评论
///

         /// 指定留言的ID
         /// 评论实体类集合
        IList < CommentInfo > GetByMessage( int messageId);
    }
}

using System;
using System.Collections.Generic;
using System.Text;
using NGuestBook.Entity;

namespace NGuestBook.IDAL
{
///

/// 数据访问层接口-管理员
///

     public interface IAdminDAL
    {
         ///

/// 插入管理员
///

         /// 管理员实体类
         /// 是否成功
         bool Insert(AdminInfo admin);

         ///

/// 删除管理员
///

         /// 欲删除的管理员的ID
         /// 是否成功
         bool Delete( int id);

         ///

/// 更新管理员信息
///

         /// 管理员实体类
         /// 是否成功
         bool Update(AdminInfo admin);

         ///

/// 按ID取得管理员信息
///

         /// 管理员ID
         /// 管理员实体类
        AdminInfo GetByID( int id);

         ///

/// 按管理员名取得管理员信息
///

         /// 管理员名
         /// 管理员实体类
        AdminInfo GetByName( string name);

         ///

/// 按用户名及密码取得管理员信息
///

         /// 用户名
         /// 密码
         /// 管理员实体类，不存在时返回null
        AdminInfo GetByNameAndPassword( string name, string password);

         ///

/// 取得全部管理员信息
///

         /// 管理员实体类集合
        IList < AdminInfo > GetAll();
    }
}

using System;
using System.Collections.Generic;
using System.Text;
using NGuestBook.Entity;

namespace NGuestBook.IDAL
{
///

/// 数据访问层接口-留言
///

     public interface IMessageDAL
    {
         ///

/// 插入留言
///

         /// 留言实体类
         /// 是否成功
         bool Insert(MessageInfo message);

         ///

/// 删除留言
///

         /// 欲删除的留言的ID
         /// 是否成功
         bool Delete( int id);

         ///

/// 更新留言信息
///

         /// 留言实体类
         /// 是否成功
         bool Update(MessageInfo message);

         ///

/// 按ID取得留言信息
///

         /// 留言ID
         /// 留言实体类
        MessageInfo GetByID( int id);

         ///

/// 按分页取得留言信息
///

         /// 每页显示几条留言
         /// 当前页码
         /// 留言实体类集合
        IList < MessageInfo > GetByPage( int pageSize, int pageNumber);
    }
}

using System;
using System.Collections.Generic;
using System.Text;
using NGuestBook.Entity;

namespace NGuestBook.IDAL
{
///

/// 数据访问层接口-评论
///

     public interface ICommentDAL
    {
         ///

/// 插入评论
///

         /// 评论实体类
         /// 是否成功
         bool Insert(CommentInfo comment);

         ///

/// 删除评论
///

         /// 欲删除的评论的ID
         /// 是否成功
         bool Delete( int id);

         ///

/// 取得指定留言的全部评论
///

         /// 指定留言的ID
         /// 评论实体类集合
        IList < CommentInfo > GetByMessage( int messageId);
    }
}

using System;
using System.Web;
using System.Web.Caching;

namespace NGuestBook.Utility
{
///

/// 辅助类，用于缓存操作
///

     public sealed class CacheAccess
    {
         ///

/// 将对象加入到缓存中
///

         /// 缓存键
         /// 缓存对象
         /// 缓存依赖项
         public static void SaveToCache( string cacheKey, object cacheObject, CacheDependency dependency)
        {
            Cache cache = HttpRuntime.Cache;
            cache.Insert(cacheKey, cacheObject, dependency);
        }

         ///

/// 从缓存中取得对象，不存在则返回null
///

         /// 缓存键
         /// 获取的缓存对象
         public static object GetFromCache( string cacheKey)
        {
            Cache cache = HttpRuntime.Cache;

             return cache[cacheKey];
        }
    }
}

using System;
using System.Configuration;
using System.Reflection;
using System.Web;
using System.Web.Caching;
using NGuestBook.Utility;

namespace NGuestBook.Factory
{
///

     /// 依赖注入提供者
     /// 使用反射机制实现
     ///

     public sealed class DependencyInjector
    {
         ///

         /// 取得数据访问层对象
         /// 首先检查缓存中是否存在，如果不存在，则利用反射机制返回对象
         ///

         /// 数据访问类名称
         /// 数据访问层对象
         public static object GetDALObject( string className)
        {
             ///

             /// 取得数据访问层名称，首先检查缓存，不存在则到配置文件中读取
             /// 缓存依赖项为Web.Config文件
             ///

             object dal = CacheAccess.GetFromCache( " DAL " );
             if (dal == null )
            {
                CacheDependency fileDependency = new CacheDependency(HttpContext.Current.Server.MapPath( " Web.Config " ));
                dal = ConfigurationManager.AppSettings[ " DAL " ];
                CacheAccess.SaveToCache( " DAL " , dal, fileDependency);
            }

             ///

/// 取得数据访问层对象
///

             string dalName = ( string )dal;
             string fullClassName = dalName + " . " + className;
             object dalObject = CacheAccess.GetFromCache(className);
             if (dalObject == null )
            {
                CacheDependency fileDependency = new CacheDependency(HttpContext.Current.Server.MapPath( " Web.Config " ));
                dalObject = Assembly.Load(dalName).CreateInstance(fullClassName);
                CacheAccess.SaveToCache(className, dalObject, fileDependency);
            }

             return dalObject;
        }

         ///

         /// 取得业务逻辑层对象
         /// 首先检查缓存中是否存在，如果不存在，则利用反射机制返回对象
         ///

         /// 业务逻辑类名称
         /// 业务逻辑层对象
         public static object GetBLLObject( string className)
        {
             ///

             /// 取得业务逻辑层名称，首先检查缓存，不存在则到配置文件中读取
             /// 缓存依赖项为Web.Config文件
             ///

             object bll = CacheAccess.GetFromCache( " BLL " );
             if (bll == null )
            {
                CacheDependency fileDependency = new CacheDependency(HttpContext.Current.Server.MapPath( " Web.Config " ));
                bll = ConfigurationManager.AppSettings[ " BLL " ];
                CacheAccess.SaveToCache( " BLL " , bll, fileDependency);
            }

             ///

/// 取得业务逻辑层对象
///

             string bllName = ( string )bll;
             string fullClassName = bllName + " . " + className;
             object bllObject = CacheAccess.GetFromCache(className);
             if (bllObject == null )
            {
                CacheDependency fileDependency = new CacheDependency(HttpContext.Current.Server.MapPath( " Web.Config " ));
                bllObject = Assembly.Load(bllName).CreateInstance(fullClassName);
                CacheAccess.SaveToCache(className, bllObject, fileDependency);
            }

             return bllObject;
        }
    }
}

using System;
using NGuestBook.IDAL;

namespace NGuestBook.Factory
{
///

     /// 数据访问层工厂，用于获取相应的数据访问层对象
     /// 使用Abstract Factory设计模式+Facace设计模式+反射机制+缓存机制设计
     ///

     public sealed class DALFactory
    {
         ///

/// 获取管理员数据访问层对象
///

         /// 管理员数据访问层对象
         public static IAdminDAL CreateAdminDAL()
        {
             return (IAdminDAL)DependencyInjector.GetDALObject( " AdminDAL " );
        }

         ///

/// 获取留言数据访问层对象
///

         /// 留言数据访问层对象
         public static IMessageDAL CreateMessageDAL()
        {
             return (IMessageDAL)DependencyInjector.GetDALObject( " MessageDAL " );
        }

         ///

/// 获取评论数据访问层对象
///

         /// 评论数据访问层对象
         public static ICommentDAL CreateCommentDAL()
        {
             return (ICommentDAL)DependencyInjector.GetDALObject( " CommentDAL " );
        }
    }
}

using System;
using NGuestBook.IBLL;

namespace NGuestBook.Factory
{
/**/ ///

     /// 业务逻辑层工厂，用于获取相应的业务逻辑层对象
     /// 使用Abstract Factory设计模式+Facace设计模式+反射机制+缓存机制设计
     ///

     public sealed class BLLFactory
    {
         /**/ ///

/// 获取管理员业务逻辑层对象
///

         /// 管理员业务逻辑层对象
         public static IAdminBLL CreateAdminBLL()
        {
             return (IAdminBLL)DependencyInjector.GetBLLObject( " AdminBLL " );
        }

         /**/ ///

/// 获取留言业务逻辑层对象
///

         /// 留言业务逻辑层对象
         public static IMessageBLL CreateMessageBLL()
        {
             return (IMessageBLL)DependencyInjector.GetBLLObject( " MessageBLL " );
        }

         /**/ ///

/// 获取评论业务逻辑层对象
///

         /// 评论业务逻辑层对象
         public static ICommentBLL CreateCommentBLL()
        {
             return (ICommentBLL)DependencyInjector.GetBLLObject( " CommentBLL " );
        }
    }
}

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

经过上面篇文章的介绍，整个系统的框架算是基本搭建完了，下面，我们要具体实现各个层次。关于数据访问层的实现，我准备讨论三种实现方式，这一篇文章讨论第一种：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:

1 using System;
2 using System.Web;
3 using System.Web.Caching;
4 using System.Configuration;
5 using System.Data;
6 using System.Data.OleDb;
7 using NGuestBook.Utility;
8
9 namespace NGuestBook.AccessDAL
10 {
11 ///

12 /// Access数据库操作助手
13 ///

14      public sealed class AccessDALHelper
15     {
16          ///

17          /// 读取Access数据库的连接字符串
18          /// 首先从缓存里读取，如果不存在则到配置文件中读取，并放入缓存
19          ///

20          /// Access数据库的连接字符串
21          private static string GetConnectionString()
22         {
23              if (CacheAccess.GetFromCache( " AccessConnectionString " ) != null )
24             {
25                  return CacheAccess.GetFromCache( " AccessConnectionString " ).ToString();
26             }
27              else
28             {
29                  string dbPath = ConfigurationManager.AppSettings[ " AccessPath " ];
30                  string dbAbsolutePath = HttpContext.Current.Server.MapPath(dbPath);
31                  string connectionString = ConfigurationManager.AppSettings[ " AccessConnectionString " ];
32
33                 CacheDependency fileDependency = new CacheDependency(HttpContext.Current.Server.MapPath( " Web.Config " ));
34                 CacheAccess.SaveToCache( " AccessConnectionString " , connectionString.Replace( " {DBPath} " lt;/span>, dbAbsolutePath), fileDependency);
35
36                return connectionString.Replace("{DBPath}", dbAbsolutePath);
37            }
38        }
39
40        ///

41 /// 执行SQL语句并且不返回任何值
42 ///

43        /// 所执行的SQL命令
44        /// 参数集合
45        public static void ExecuteSQLNonQuery(string SQLCommand,OleDbParameter[] parameters)
46        {
47            OleDbConnection connection = new OleDbConnection(GetConnectionString());
48            OleDbCommand command = new OleDbCommand(SQLCommand, connection);
49
50            for (int i = 0; i < parameters.Length; i++)
51            {
52                command.Parameters.Add(parameters[i]);
53            }
54
55            connection.Open();
56            command.ExecuteNonQuery();
57            connection.Close();
58        }
59
60        ///

61 /// 执行SQL语句并返回包含查询结果的DataReader
62 ///

63        /// 所执行的SQL命令
64        /// 参数集合
65        ///
66        public static OleDbDataReader ExecuteSQLDataReader(string SQLCommand,OleDbParameter[] parameters)
67        {
68            OleDbConnection connection = new OleDbConnection(GetConnectionString());
69            OleDbCommand command = new OleDbCommand(SQLCommand, connection);
70
71            for (int i = 0; i < parameters.Length; i++)
72            {
73                command.Parameters.Add(parameters[i]);
74            }
75
76            connection.Open();
77            OleDbDataReader dataReader = command.ExecuteReader();
78            //connection.Close();
79
80            return dataReader;
81        }
82    }
83}

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

AdminDAL:

  1 using System;
  2 using System.Collections.Generic;
  3 using System.Text;
  4 using System.Data;
  5 using System.Data.OleDb;
  6 using NGuestBook.IDAL;
  7 using NGuestBook.Entity;
   8
  9 namespace NGuestBook.AccessDAL
10 {
11      public class AdminDAL : IAdminDAL
12     {
13          ///

14 /// 插入管理员
15 ///

16          /// 管理员实体类
17          /// 是否成功
18          public bool Insert(AdminInfo admin)
19         {
20              string SQLCommand = " insert into [TAdmin]([Name],[Password]) values(@name,@password) " ;
21             OleDbParameter[] parameters = {
22                  new OleDbParameter( " name " ,admin.Name),
23                  new OleDbParameter( " password " ,admin.Password)
24             };
25
26              try
27             {
28                 AccessDALHelper.ExecuteSQLNonQuery(SQLCommand, parameters);
29                  return true ;
30             }
31              catch
32             {
33                  return false ;
34             }
35         }
36
37          ///

38 /// 删除管理员
39 ///

40          /// 欲删除的管理员的ID
41          /// 是否成功
42          public bool Delete( int id)
43         {
44              string SQLCommand = " delete from [TAdmin] where [ID]=@id " ;
45             OleDbParameter[] parameters = {
46                  new OleDbParameter( " id " ,id)
47             };
48
49              try
50             {
51                 AccessDALHelper.ExecuteSQLNonQuery(SQLCommand, parameters);
52                  return true ;
53             }
54              catch
55             {
56                  return false ;
57             }
58         }
59
60          ///

61 /// 更新管理员信息
62 ///

63          /// 管理员实体类
64          /// 是否成功
65          public bool Update(AdminInfo admin)
66         {
67              string SQLCommand = " update [TAdmin] set [Name]=@name,[Password]=@password where [ID]=@id " ;
68             OleDbParameter[] parameters = {
69                  new OleDbParameter( " id " ,admin.ID),
70                  new OleDbParameter( " name " ,admin.Name),
71                  new OleDbParameter( " password " ,admin.Password)
72             };
73
74              try
75             {
76                 AccessDALHelper.ExecuteSQLNonQuery(SQLCommand, parameters);
77                  return true ;
78             }
79              catch
80             {
81                  return false ;
82             }
83         }
84
85          ///

86 /// 按ID取得管理员信息
87 ///

88          /// 管理员ID
89          /// 管理员实体类
90          public AdminInfo GetByID( int id)
91         {
92              string SQLCommand = " select * from [TAdmin] where [ID]=@id " ;
93             OleDbParameter[] parameters = {
94                  new OleDbParameter( " id " ,id)
95             };
96
97              try
98             {
99                 OleDbDataReader dataReader = AccessDALHelper.ExecuteSQLDataReader(SQLCommand, parameters);
100                  if ( ! dataReader.HasRows)
101                 {
102                      throw new Exception();
103                 }
104
105                 AdminInfo admin = new AdminInfo();
106                 dataReader.Read();
107                 admin.ID = ( int )dataReader[ " ID " ];
108                 admin.Name = ( string )dataReader[ " Name " ];
109                 admin.Password = ( string )dataReader[ " Password " ];
110
111                  return admin;
112             }
113              catch
114             {
115                  return null ;
116             }
117         }
118
119          ///

120 /// 按用户名及密码取得管理员信息
121 ///

122          /// 用户名
123          /// 密码
124          /// 管理员实体类，不存在时返回null
125          public AdminInfo GetByNameAndPassword( string name, string password)
126         {
127              string SQLCommand = " select * from [TAdmin] where [Name]=@name and [Password]=@password " ;
128             OleDbParameter[] parameters = {
129                  new OleDbParameter( " name " ,name),
130                  new OleDbParameter( " password " ,password),
131             };
132
133              try
134             {
135                 OleDbDataReader dataReader = AccessDALHelper.ExecuteSQLDataReader(SQLCommand, parameters);
136                  if ( ! dataReader.HasRows)
137                 {
138                      throw new Exception();
139                 }
140
141                 AdminInfo admin = new AdminInfo();
142                 dataReader.Read();
143                 admin.ID = ( int )dataReader[ " ID " ];
144                 admin.Name = ( string )dataReader[ " Name " ];
145                 admin.Password = ( string )dataReader[ " Password " ];
146
147                  return admin;
148             }
149              catch
150             {
151                  return null ;
152             }
153         }
154
155          ///

156 /// 按管理员名取得管理员信息
157 ///

158          /// 管理员名
159          /// 管理员实体类
160          public AdminInfo GetByName( string name)
161         {
162              string SQLCommand = " select * from [TAdmin] where [Name]=@name " ;
163             OleDbParameter[] parameters = {
164                  new OleDbParameter( " name " ,name),
165             };
166
167              try
168             {
169                 OleDbDataReader dataReader = AccessDALHelper.ExecuteSQLDataReader(SQLCommand, parameters);
170                  if ( ! dataReader.HasRows)
171                 {
172                      throw new Exception();
173                 }
174
175                 AdminInfo admin = new AdminInfo();
176                 dataReader.Read();
177                 admin.ID = ( int )dataReader[ " ID " ];
178                 admin.Name = ( string )dataReader[ " Name " ];
179                 admin.Password = ( string )dataReader[ " Password " ];
180
181                  return admin;
182             }
183              catch
184             {
185                  return null ;
186             }
187         }
188
189          ///

190 /// 取得全部管理员信息
191 ///

192          /// 管理员实体类集合
193          public IList < AdminInfo > GetAll()
194         {
195              string SQLCommand = " select * from [TAdmin] " ;
196              try
197             {
198                 OleDbDataReader dataReader = AccessDALHelper.ExecuteSQLDataReader(SQLCommand, null );
199                  if ( ! dataReader.HasRows)
200                 {
201                      throw new Exception();
202                 }
203
204                 IList < AdminInfo > adminCollection = new List < AdminInfo > ();
205                  int i = 0 ;
206                  while (dataReader.Read())
207                 {
208                     AdminInfo admin = new AdminInfo();
209                     admin.ID = ( int )dataReader[ " ID " ];
210                     admin.Name = ( string )dataReader[ " Name " ];
211                     admin.Password = ( string )dataReader[ " Password " ];
212
213                     adminCollection.Add(admin);
214                     i ++ ;
215                 }
216
217                  return adminCollection;
218             }
219              catch
220             {
221                  return null ;
222             }
223         }
224     }
225 }

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

基于.NET平台的分层架构实战（八）——数据访问层的第二种实现：SQLServer+存储过程

在上一篇中，讨论了使用SQL构建数据访问层的方法，并且针对的是Access数据库。而这一篇中，将要创建一个针对SQLServer数据库的数据访问层，并且配合存储过程实现。

曾经有朋友问我使用SQL和存储过程在效率上的差别，惭愧的是我对这方面没有研究，也没有实际做过测试。通过查阅资料，发现在一般情况下，存储过程的效率由于使用SQL，但是也不绝对，也发现有的朋友测试时发现在特定情况下SQL的效率优于存储过程，所以这个问题不能一概而论。

好，废话不多说，这里先列出使用存储过程构建数据访问层的一般步骤：
1.创建新工程
2.创建数据库
3.编写相应存储过程
4.编写数据库辅助类
5.实现数据访问层

创建新工程
在开始所有开发工作前，我们需要在解决方案下新建一个工程，叫SQLServerDAL，用于存放所有SQLServer数据访问层的代码。

创建数据库
首先，我们要根据前文设计的数据库，在SQLServer中创建相应的数据库及数据表。我使用的是SQLServer2005，使用企业管理器创建，创建方法不再赘述。

编写存储过程
数据库创建完成后，我们就要编写存储过程了。由于数据访问层接口已经确定，所以需要哪些存储过程也很好确定。例如数据访问层接口中有一个添加管理员方法，那么就一定有一个存储过程实现这个功能。
还是以管理员模块为例，经过简单分析，需要一下存储过程：

插入管理员记录
删除管理员记录
更新管理员信息
按ID取得管理员记录
按用户名及密码取得管理员记录
按用户名取得管理员记录
取得全部管理员记录

创建这些存储过程的SQL代码如下：

set ANSI_NULLS ON
set QUOTED_IDENTIFIER ON
GO
-- =============================================
-- Author:
-- Create date: <2008-07-04>
-- Description:    <插入管理员记录>
-- =============================================
CREATE PROCEDURE [ dbo ] . [ Pr_InsertAdmin ]
(
      @Name Nvarchar ( 20 ),
      @Password Nvarchar ( 50 )
)
AS
INSERT INTO TAdmin
(
     [ Name ] ,
     [ Password ]
)
VALUES
(
     @Name ,
     @Password
)

set ANSI_NULLS ON
set QUOTED_IDENTIFIER ON
GO
-- =============================================
-- Author:
-- Create date: <2008-07-04>
-- Description:    <删除管理员记录>
-- =============================================
CREATE PROCEDURE [ dbo ] . [ Pr_DeleteAdmin ]
(
      @ID Int
)
AS
DELETE FROM TAdmin
WHERE [ ID ] = @ID

set ANSI_NULLS ON
set QUOTED_IDENTIFIER ON
GO
-- =============================================
-- Author:
-- Create date: <2008-07-04>
-- Description:    <修改管理员记录>
-- =============================================
CREATE PROCEDURE [ dbo ] . [ Pr_UpdateAdmin ]
(
      @ID Int ,
      @Name Nvarchar ( 20 ),
      @Password Nvarchar ( 50 )
)
AS
UPDATE TAdmin
SET
[ Name ] = @Name ,
[ Password ] = @Password
WHERE [ ID ] = @ID

set ANSI_NULLS ON
set QUOTED_IDENTIFIER ON
GO
-- =============================================
-- Author:
-- Create date: <2008-07-04>
-- Description:    <按ID取得管理员信息>
-- =============================================
CREATE PROCEDURE [ dbo ] . [ Pr_GetAdminByID ]
(
      @ID Int
)
AS
SELECT * FROM TAdmin
WHERE [ ID ] = @ID

set ANSI_NULLS ON
set QUOTED_IDENTIFIER ON
GO
-- =============================================
-- Author:
-- Create date: <2008-07-04>
-- Description:    <按用户名及密码取得管理员信息>
-- =============================================
CREATE PROCEDURE [ dbo ] . [ Pr_GetAdminByNameAndPassword ]
(
      @Name Nvarchar ( 20 ),
      @Password Nvarchar ( 50 )
)
AS
SELECT * FROM TAdmin
WHERE [ Name ] = @Name
AND [ Password ] = @Password

set ANSI_NULLS ON
set QUOTED_IDENTIFIER ON
GO
-- =============================================
-- Author:
-- Create date: <2008-07-04>
-- Description:    <按用户名取得管理员信息>
-- =============================================
CREATE PROCEDURE [ dbo ] . [ Pr_GetAdminByName ]
(
      @Name Nvarchar ( 20 )
)
AS
SELECT * FROM TAdmin
WHERE [ Name ] = @Name

set ANSI_NULLS ON
set QUOTED_IDENTIFIER ON
GO
-- =============================================
-- Author:
-- Create date: <2008-07-04>
-- Description: <取得全部管理员信息>
-- =============================================
CREATE PROCEDURE [ dbo ] . [ Pr_GetAllAdmin ]
AS
SELECT * FROM TAdmin

编写数据库辅助类
由于访问数据库的代码很相似，这里我们仍需要编写一个数据库辅助类，来将常用代码封装起来，方便复用。虽然在这里只使用到了存储过程，但是为了扩展性考虑，这个数据库辅助类仍然包含了通过SQL访问数据库的方法。具体实现如下：

SQLServerDALHelper.cs:

1 using System;
2 using System.Collections.Generic;
3 using System.Configuration;
4 using System.Data;
5 using System.Data.SqlClient;
6
7 namespace NGuestBook.SQLServerDAL
8 {
9 ///

10 /// SQLServer数据库操作助手
11 ///

12      public sealed class SQLServerDALHelper
13     {
14          ///

15 /// 用于连接SQLServer数据库的连接字符串，存于Web.config中
16 ///

17 private static readonly string _sqlConnectionString = ConfigurationManager.AppSettings[ " SQLServerConnectionString " ];
18
19 ///

20 /// 执行SQL命令，不返回任何值
21 ///

22          /// SQL命令
23          public static void ExecuteSQLNonQurey( string sql)
24         {
25             SqlConnection connection = new SqlConnection(_sqlConnectionString);
26             SqlCommand command = new SqlCommand(sql,connection);
27             connection.Open();
28             command.ExecuteNonQuery();
29             connection.Close();
30         }
31
32          ///

33 /// 执行SQL命令，并返回SqlDataReader
34 ///

35          /// SQL命令
36          /// 包含查询结果的SqlDataReader
37          public static SqlDataReader ExecuteSQLReader( string sql)
38         {
39             SqlConnection connection = new SqlConnection(_sqlConnectionString);
40             SqlCommand command = new SqlCommand(sql, connection);
41             connection.Open();
42             SqlDataReader sqlReader = command.ExecuteReader();
43              // connection.Close();
44
45              return sqlReader;
46         }
47
48          ///

49 /// 执行存储过程，不返回任何值
50 ///

51          /// 存储过程名
52          /// 参数
53          public static void ExecuteProcedureNonQurey( string storedProcedureName,IDataParameter[] parameters)
54         {
55             SqlConnection connection = new SqlConnection(_sqlConnectionString);
56             SqlCommand command = new SqlCommand(storedProcedureName,connection);
57             command.CommandType = CommandType.StoredProcedure;
58              if (parameters != null )
59             {
60                  foreach (SqlParameter parameter in parameters)
61                 {
62                     command.Parameters.Add(parameter);
63                 }
64             }
65             connection.Open();
66             command.ExecuteNonQuery();
67             connection.Close();
68         }
69
70          ///

71 /// 执行存储，并返回SqlDataReader
72 ///

73          /// 存储过程名
74          /// 参数
75          /// 包含查询结果的SqlDataReader
76          public static SqlDataReader ExecuteProcedureReader( string storedProcedureName,IDataParameter[] parameters)
77         {
78             SqlConnection connection = new SqlConnection(_sqlConnectionString);
79             SqlCommand command = new SqlCommand(storedProcedureName,connection);
80             command.CommandType = CommandType.StoredProcedure;
81              if (parameters != null )
82             {
83                  foreach (SqlParameter parameter in parameters)
84                 {
85                     command.Parameters.Add(parameter);
86                 }
87             }
88             connection.Open();
89             SqlDataReader sqlReader = command.ExecuteReader();
90              // connection.Close();
91
92              return sqlReader;
93         }
94     }
95 }

实现数据访问层
最后仍以管理员模块为例，看一下具体数据访问层的实现。

AdminDAL.cs:

  1 using System;
  2 using System.Collections.Generic;
  3 using System.Text;
  4 using System.Data;
  5 using System.Data.SqlClient;
  6 using NGuestBook.IDAL;
  7 using NGuestBook.Entity;
   8
  9 namespace NGuestBook.SQLServerDAL
10 {
11      public class AdminDAL : IAdminDAL
12     {
13          ///

14 /// 插入管理员
15 ///

16          /// 管理员实体类
17          /// 是否成功
18          public bool Insert(AdminInfo admin)
19         {
20             SqlParameter[] parameters =
21                 {
22                      new SqlParameter( " @Name " ,SqlDbType.NVarChar),
23                      new SqlParameter( " @Password " ,SqlDbType.NVarChar)
24                 };
25             parameters[ 0 ].Value = admin.Name;
26             parameters[ 1 ].Value = admin.Password;
27              try
28             {
29                 SQLServerDALHelper.ExecuteProcedureNonQurey( " Pr_InsertAdmin " , parameters);
30                  return true ;
31             }
32              catch
33             {
34                  return false ;
35             }
36         }
37
38          ///

39 /// 删除管理员
40 ///

41          /// 欲删除的管理员的ID
42          /// 是否成功
43          public bool Delete( int id)
44         {
45             SqlParameter[] parameters =
46                 {
47                      new SqlParameter( " @ID " ,SqlDbType.Int)
48                 };
49             parameters[ 0 ].Value = id;
50              try
51             {
52                 SQLServerDALHelper.ExecuteProcedureNonQurey( " Pr_DeleteAdmin " , parameters);
53                  return true ;
54             }
55              catch
56             {
57                  return false ;
58             }
59         }
60
61          ///

62 /// 更新管理员信息
63 ///

64          /// 管理员实体类
65          /// 是否成功
66          public bool Update(AdminInfo admin)
67         {
68             SqlParameter[] parameters =
69                 {
70                      new SqlParameter( " @ID " ,SqlDbType.Int),
71                      new SqlParameter( " @Name " ,SqlDbType.NVarChar),
72                      new SqlParameter( " @Password " ,SqlDbType.NVarChar)
73                 };
74             parameters[ 0 ].Value = admin.ID;
75             parameters[ 1 ].Value = admin.Name;
76             parameters[ 2 ].Value = admin.Password;
77              try
78             {
79                 SQLServerDALHelper.ExecuteProcedureNonQurey( " Pr_UpdateAdmin " , parameters);
80                  return true ;
81             }
82              catch
83             {
84                  return false ;
85             }
86         }
87
88          ///

89 /// 按ID取得管理员信息
90 ///

91          /// 管理员ID
92          /// 管理员实体类
93          public AdminInfo GetByID( int id)
94         {
95             SqlParameter[] parameters =
96                 {
97                      new SqlParameter( " @ID " ,SqlDbType.Int)
98                 };
99             parameters[ 0 ].Value = id;
100             SqlDataReader dataReader = null ;
101              try
102             {
103                 dataReader = SQLServerDALHelper.ExecuteProcedureReader( " GetAdminByID " , parameters);
104                 dataReader.Read();
105                 AdminInfo admin = new AdminInfo();
106                 admin.ID = ( int )dataReader[ " ID " ];
107                 admin.Name = ( string )dataReader[ " Name " ];
108                 admin.Password = ( string )dataReader[ " Password " ];
109
110                  return admin;
111             }
112              catch
113             {
114                  return null ;
115             }
116              finally
117             {
118                 dataReader.Close();
119             }
120         }
121
122          ///

123 /// 按用户名及密码取得管理员信息
124 ///

125          /// 用户名
126          /// 密码
127          /// 管理员实体类，不存在时返回null
128          public AdminInfo GetByNameAndPassword( string name, string password)
129         {
130             SqlParameter[] parameters =
131                 {
132                      new SqlParameter( " @Name " ,SqlDbType.NVarChar),
133                      new SqlParameter( " @Password " ,SqlDbType.NVarChar)
134                 };
135             parameters[ 0 ].Value = name;
136             parameters[ 1 ].Value = password;
137             SqlDataReader dataReader = null ;
138              try
139             {
140                 dataReader = SQLServerDALHelper.ExecuteProcedureReader( " GetAdminByNameAndPassword " , parameters);
141                 dataReader.Read();
142                 AdminInfo admin = new AdminInfo();
143                 admin.ID = ( int )dataReader[ " ID " ];
144                 admin.Name = ( string )dataReader[ " Name " ];
145                 admin.Password = ( string )dataReader[ " Password " ];
146
147                  return admin;
148             }
149              catch
150             {
151                  return null ;
152             }
153              finally
154             {
155                 dataReader.Close();
156             }
157         }
158
159          ///

160 /// 按管理员名取得管理员信息
161 ///

162          /// 管理员名
163          /// 管理员实体类
164          public AdminInfo GetByName( string name)
165         {
166             SqlParameter[] parameters =
167                 {
168                      new SqlParameter( " @Name " ,SqlDbType.NVarChar)
169                 };
170             parameters[ 0 ].Value = name;
171             SqlDataReader dataReader = null ;
172              try
173             {
174                 dataReader = SQLServerDALHelper.ExecuteProcedureReader( " GetAdminByName " , parameters);
175                 dataReader.Read();
176                 AdminInfo admin = new AdminInfo();
177                 admin.ID = ( int )dataReader[ " ID " ];
178                 admin.Name = ( string )dataReader[ " Name " ];
179                 admin.Password = ( string )dataReader[ " Password " ];
180
181                  return admin;
182             }
183              catch
184             {
185                  return null ;
186             }
187              finally
188             {
189                 dataReader.Close();
190             }
191         }
192
193          ///

194 /// 取得全部管理员信息
195 ///

196          /// 管理员实体类集合
197          public IList < AdminInfo > GetAll()
198         {
199             SqlDataReader dataReader = null ;
200              try
201             {
202                 dataReader = SQLServerDALHelper.ExecuteProcedureReader( " GetAllAdmin " , null );
203                 IList < AdminInfo > adminCollection = new List < AdminInfo > ();
204                  while (dataReader.Read())
205                 {
206                     AdminInfo admin = new AdminInfo();
207                     admin.ID = ( int )dataReader[ " ID " ];
208                     admin.Name = ( string )dataReader[ " Name " ];
209                     admin.Password = ( string )dataReader[ " Password " ];
210                     adminCollection.Add(admin);
211                 }
212
213                  return adminCollection;
214             }
215              catch
216             {
217                  return null ;
218             }
219              finally
220             {
221                 dataReader.Close();
222             }
223         }
224     }
225 }

基于.NET平台的分层架构实战（九）——数据访问层的第三种实现：基于NBear框架的ORM实现

前面的文章讨论了使用SQL语句和存储过程两种数据访问层的实现方式，这一篇里，将讨论使用ORM方式实现数据访问层的方法。

对象-关系映射（Object/Relation Mapping，简称ORM），是随着面向对象的软件开发方法发展而产生的。面向对象的开发方法是当今企业级应用开发环境中的主流开发方法，关系数据库是企业级应用环境中永久存放数据的主流数据存储系统。对象和关系数据是业务实体的两种表现形式，业务实体在内存中表现为对象，在数据库中表现为关系数据。内存中的对象之间存在关联和继承关系，而在数据库中，关系数据无法直接表达多对多关联和继承关系。因此，对象-关系映射(ORM)系统一般以中间件的形式存在，主要实现程序对象到关系数据库数据的映射。

目前.NET平台上有许多ORM框架可供选择，如NBear、NHibernate等等。这里我们选择NBear实现ORM。

NBear是由博客园的Teddy's Knowledge Base团队开发的一个开源框架，主要用来提高.NET平台的开发效率，其中包含了ORM、IoC、MVP等多个组件，这里仅仅用到其中的ORM功能。关于NBear的详细使用方法本文不再详述，请参考NBear入门教程。NBear的最新版本下载地址为http://files.cnblogs.com/hjf1223/NBearV3.7.2.11_src.rar。

下面我们一步一步实现数据访问层的ORM实现。

1.创建实体设计工程
使用NBear实现ORM功能，首先要创建一个实体设计工程，这个工程最终不会应用到系统中，但是必须通过它来生成NBear实体类以及配置文件。
首先，我们在解决方案下新建一个工程，名字为NBearEntityDesign，并为这个工程添加到文件NBear.Common.Design.dll的引用，这个文件在NBear文件包的dist目录下。
完成后，在这个工程下新建一个C#文件，名为EntityDesign.cs，这个文件就是设计文件，根据对实体和数据库的设计，编写完整代码如下：

EntityDesign.cs:

1 using System;
2 using System.Collections.Generic;
3 using System.Text;
4 using NBear.Common.Design;
5
6 namespace NGuestBook.NBearEntityDesign
7 {
8      public interface TAdmin : Entity
9     {
10         [PrimaryKey]
11          int ID { get ; }
12         [SqlType( " nvarchar(20) " )]
13          string Name { get ; set ; }
14         [SqlType( " nvarchar(50) " )]
15          string Password { get ; set ; }
16     }
17
18      public interface TComment : Entity
19     {
20         [PrimaryKey]
21          int ID { get ; }
22         [SqlType( " ntext " )]
23          string Content { get ; set ; }
24         DateTime Time { get ; set ; }
25          int MessageID { get ; set ; }
26     }
27
28      public interface TMessage : Entity
29     {
30         [PrimaryKey]
31          int ID { get ; }
32         [SqlType( " nvarchar(20) " )]
33          string GuestName { get ; set ; }
34         [SqlType( " nvarchar(100) " )]
35          string GuestEmail { get ; set ; }
36         [SqlType( " ntext " )]
37          string Content { get ; set ; }
38         DateTime Time { get ; set ; }
39         [SqlType( " ntext " )]
40          string Reply { get ; set ; }
41         [SqlType( " nvarchar(10) " )]
42          string IsPass { get ; set ; }
43     }
44 }

设计完后，将这个工程编译备用。

2.创建NBear专用实体类及配置文件
在NBear文件包的dist目录下，有一个NBear.Tools.EntityDesignToEntity.exe程序，打开它，点击“Browse”按钮，选择刚才编译生成的NGuestBook.NBearEntityDesign.dll文件，并在Output Namespace文本框里输入相应的命名空间，这里我们应输入“NGuestBook.NBearDAL”。然后点击“Generate Entities”按钮，这时会在底下的文本框里生成NBear专用实体类代码。
在解决方案下新建一个工程NBearDAL，用于存放所有ORM数据访问层的实现代码。在这个工程下新建Entities.cs，将刚才自动生成的代码覆盖掉这个文件的代码，专用实体类就做好了。
另外，需要给工程NBearDAL添加到NBear.Common.dll和NBear.Data.dll的引用，这两个文件都在dist目录下。
点击“Generate Configuration”按钮，这时会生成配置代码。在Web工程下新建文件NBearConfig.xml，将生成的代码复制到这个文件里保存。
最后还要修改一下Web.config文件。增加如下配置代码：

然后再在节点下增加如下项：

其中connectionString是连接字符串，根据个人不同情况进行修改。这里使用的是SQLServer2005。
因为数据库在上一篇中已经创建好了，这里就不需要创建数据库了。

3.编写转换器
这里出现了一个矛盾：业务逻辑层和表示层需要使用通用的实体类，如AdminInfo，而NBear需要使用专用实体类。怎么解决这个矛盾呢？我这里使用的方法是一个我称之为“转换器”的方法。即为没一个实体写一个专门的转换器，实现两种实体类的转换。这里以管理员实体为例，这个转换器写在NBearDAL工程下的AdminConvertor.cs文件中。具体代码如下：

AdminConvertor.cs:

1 using System;
2 using NGuestBook.Entity;
3
4 namespace NGuestBook.NBearDAL
5 {
6 ///

7 /// 实体类转换器-管理员
8 ///

9      public sealed class AdminConvertor
10     {
11          ///

12 /// 由普通管理员实体类转化为NBear专用管理员实体类
13 ///

14          /// 普通实体类
15          /// NBear专用实体类
16          public static TAdmin CommonEntityToNBearEntity(AdminInfo commonEntity)
17         {
18             TAdmin nbaerEntity = new TAdmin();
19             nbaerEntity.ID = commonEntity.ID;
20             nbaerEntity.Name = commonEntity.Name;
21             nbaerEntity.Password = commonEntity.Password;
22
23              return nbaerEntity;
24         }
25
26          ///

27 /// 由NBear专用管理员实体类转化为普通管理员实体类
28 ///

29          /// NBear专用实体类
30          /// 普通实体类
31          public static AdminInfo NBearEntityToCommonEntity(TAdmin nbearEntity)
32         {
33             AdminInfo commonEntity = new AdminInfo();
34             commonEntity.ID = nbearEntity.ID;
35             commonEntity.Name = nbearEntity.Name;
36             commonEntity.Password = nbearEntity.Password;
37
38              return commonEntity;
39         }
40     }
41 }

4.实现数据访问层
做完上述工作，我们就可以来实现数据访问层了。借助于NBear框架的支持，我们可以非常方便的使用ORM方式访问数据库。关于NBear的细节，这里不再赘述，以管理员为例，具体代码如下：

AdminDAL.cs:

  1 using System;
  2 using System.Collections.Generic;
  3 using System.Text;
  4 using System.Data.Common;
  5 using NGuestBook.IDAL;
  6 using NGuestBook.Entity;
  7 using NBear.Common;
  8 using NBear.Data;
   9
10 namespace NGuestBook.NBearDAL
11 {
12      public class AdminDAL : IAdminDAL
13     {
14          ///

15 /// 插入管理员
16 ///

17          /// 管理员实体类
18          /// 是否成功
19          public bool Insert(AdminInfo admin)
20         {
21             Gateway.SetDefaultDatabase( " NBearConnectionString " );
22             DbTransaction transcation = Gateway.Default.BeginTransaction();
23              try
24             {
25                 Gateway.Default.Save < TAdmin > (AdminConvertor.CommonEntityToNBearEntity(admin));
26                 transcation.Commit();
27                  return true ;
28             }
29              catch
30             {
31                 transcation.Rollback();
32                  return false ;
33             }
34              finally
35             {
36                 Gateway.Default.CloseTransaction(transcation);
37             }
38         }
39
40          ///

41 /// 删除管理员
42 ///

43          /// 欲删除的管理员的ID
44          /// 是否成功
45          public bool Delete( int id)
46         {
47             Gateway.SetDefaultDatabase( " NBearConnectionString " );
48             DbTransaction transcation = Gateway.Default.BeginTransaction();
49              try
50             {
51                 Gateway.Default.Delete < TAdmin > (id);
52                 transcation.Commit();
53                  return true ;
54             }
55              catch
56             {
57                 transcation.Rollback();
58                  return false ;
59             }
60              finally
61             {
62                 Gateway.Default.CloseTransaction(transcation);
63             }
64         }
65
66          ///

67 /// 更新管理员信息
68 ///

69          /// 管理员实体类
70          /// 是否成功
71          public bool Update(AdminInfo admin)
72         {
73             Gateway.SetDefaultDatabase( " NBearConnectionString " );
74             DbTransaction transcation = Gateway.Default.BeginTransaction();
75             PropertyItem[] properties = {
76                  new PropertyItem( " Name " ),
77                  new PropertyItem( " Password " )
78             };
79              object [] values = {
80                 admin.Name,
81                 admin.Password
82             };
83              try
84             {
85                 Gateway.Default.Update < TAdmin > (properties, values, null , transcation);
86                 transcation.Commit();
87                  return true ;
88             }
89              catch
90             {
91                 transcation.Rollback();
92                  return false ;
93             }
94              finally
95             {
96                 Gateway.Default.CloseTransaction(transcation);
97             }
98         }
99
100          ///

101 /// 按ID取得管理员信息
102 ///

103          /// 管理员ID
104          /// 管理员实体类
105          public AdminInfo GetByID( int id)
106         {
107             Gateway.SetDefaultDatabase( " NBearConnectionString " );
108             TAdmin tAdmin = Gateway.Default.Find < TAdmin > (TAdmin._.ID == id);
109              return tAdmin == null ? null : AdminConvertor.NBearEntityToCommonEntity(tAdmin);
110         }
111
112          ///

113 /// 按用户名及密码取得管理员信息
114 ///

115          /// 用户名
116          /// 密码
117          /// 管理员实体类，不存在时返回null
118          public AdminInfo GetByNameAndPassword( string name, string password)
119         {
120             Gateway.SetDefaultDatabase( " NBearConnectionString " );
121             TAdmin tAdmin = Gateway.Default.Find < TAdmin > (TAdmin._.Name == name && TAdmin._.Password == password);
122              return tAdmin == null ? null : AdminConvertor.NBearEntityToCommonEntity(tAdmin);
123         }
124
125          ///

126 /// 按管理员名取得管理员信息
127 ///

128          /// 管理员名
129          /// 管理员实体类
130          public AdminInfo GetByName( string name)
131         {
132             Gateway.SetDefaultDatabase( " NBearConnectionString " );
133             TAdmin tAdmin = Gateway.Default.Find < TAdmin > (TAdmin._.Name == name);
134              return tAdmin == null ? null : AdminConvertor.NBearEntityToCommonEntity(tAdmin);
135         }
136
137          ///

138 /// 取得全部管理员信息
139 ///

140          /// 管理员实体类集合
141          public IList < AdminInfo > GetAll()
142         {
143             IList < AdminInfo > adminCollection = new List < AdminInfo > ();
144             Gateway.SetDefaultDatabase( " NBearConnectionString " );
145             TAdmin[] tAdminCollection = Gateway.Default.FindArray < TAdmin > ( null , TAdmin._.ID.Desc);
146              foreach (TAdmin tAdmin in tAdminCollection)
147             {
148                 adminCollection.Add(AdminConvertor.NBearEntityToCommonEntity(tAdmin));
149             }
150              return adminCollection;
151         }
152     }
153 }

基于.NET平台的分层架构实战（十）——业务逻辑层的实现

在这一篇文章中，将实现一个NGuestBook的业务逻辑层。

在实际应用中，业务逻辑层是至关重要的，他承载着整个系统最核心的部分，也是客户最关注的部分。这一部分的实现，通常需要技术专家和领域专家通力合作。当然，在本文章系列的Demo中，由于业务逻辑的简单性，这里看的可能还不是很明显。

在本篇文章的业务逻辑层实现中，业务逻辑层主要承担了以下职责：

1.对不同数据访问层的封装。使得表示层可以不关心具体的数据访问层。

2.业务逻辑数据的填充与转换。如管理员口令的加密。

3.核心业务的实现。这里很多业务逻辑只有一行代码，即一个业务逻辑方法恰好对应一个数据访问方法，但是也有通过多个数据访问方法实现业务的。如AdminBLL中的ChangePassword方法就调用了AdminDAL的GetByID和Update两个方法。另外，虽然许多方法只调用一个数据访问方法，但是从命名看也能看出两者着眼点的不同。如AdminDAL中的GetByNameAndPassword，这个名字显然是从数据库的角度看问题——指按照指定的Name和Password两个字段的值取出相应信息，至于这样做的业务意义它不需要知道。而AdminBLL中，调用它的方法叫Login，这是从业务角度看问题——即这个方法是管理员登录。

下面分步骤实现业务逻辑层：

1.建立工程
在这个架构中，业务逻辑层是可以替换的。及业务逻辑层不是直接耦合于表示层，而是通过依赖注入机制实现。所以，我们这里将这个业务逻辑层不直接命名为BLL，而是新建一个叫SimpleBLL的工程，放置我们这个业务逻辑层的相关代码。

2.配置依赖注入
业务逻辑层要通过反射工厂加载相应的数据访问层，这样就需要在Web.config中配置需要使用的数据访问层。打开Web.config，找到appSettings节点下的“DAL”项，将其中的value赋予我们要使用的数据访问层工程名称，例如：要使用NBearDAL，则这一项应该这样写：

3.编写散列加密工具类
因为在业务逻辑层的多处需要用到散列加密，所以在Utility工程下写一个辅助类Encryptor，完成这个工作，这个辅助类的具体代码如下：

Encryptor.cs:

1 using System;
2 using System.Collections.Generic;
3 using System.Text;
4
5 namespace NGuestBook.Utility
6 {
7 ///

8 /// 辅助类-用于对敏感数据进行Hash散列，达到加密效果
9 ///

10      public sealed class Encryptor
11     {
12          ///

13 /// 使用MD5算法求Hash散列
14 ///

15          /// 明文
16          /// 散列值
17          public static string MD5Encrypt( string text)
18         {
19              return System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(text, " MD5 " );
20         }
21
22          ///

23 /// 使用SHA1算法求Hash散列
24 ///

25          /// 明文
26          /// 散列值
27          public static string SHA1Encrypt( string text)
28         {
29              return System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(text, " SHA1 " );
30         }
31     }
32 }

4.实现业务逻辑层
有了上述准备工作和以前实现的组件，业务逻辑层的实现非常直观。这里仅以管理员为例，展示如何实现业务逻辑层。
AdminBLL类建立在SimpleBLL工程下的AdminBLL.cs文件中，实现了IAdminBLL接口，需具体代码如下：

AdminBLL.cs:

1 using System;
2 using System.Collections.Generic;
3 using System.Text;
4 using NGuestBook.Entity;
5 using NGuestBook.Factory;
6 using NGuestBook.IBLL;
7 using NGuestBook.IDAL;
8 using NGuestBook.Utility;
9
10 namespace NGuestBook.IBLL
11 {
12 ///

13 /// 业务逻辑层接口-管理员
14 ///

15      public class AdminBLL : IAdminBLL
16     {
17          ///

18 /// 添加管理员
19 ///

20          /// 新管理员实体类
21          /// 是否成功
22          public bool Add(AdminInfo admin)
23         {
24             admin.Password = Encryptor.MD5Encrypt(admin.Password);
25              return DALFactory.CreateAdminDAL().Insert(admin);
26         }
27
28          ///

29 /// 删除管理员
30 ///

31          /// 欲删除的管理员的ID
32          /// 是否成功
33          public bool Remove( int id)
34         {
35              return DALFactory.CreateAdminDAL().Delete(id);
36         }
37
38          ///

39 /// 修改管理员密码
40 ///

41          /// 欲修改密码的管理员的ID
42          /// 新密码
43          /// 是否成功
44          public bool ChangePassword( int id, string password)
45         {
46             password = Encryptor.MD5Encrypt(password);
47             AdminInfo admin = DALFactory.CreateAdminDAL().GetByID(id);
48             admin.Password = password;
49              return DALFactory.CreateAdminDAL().Update(admin);
50         }
51
52          ///

53 /// 管理员登录
54 ///

55          /// 管理员登录名
56          /// 管理员密码
57          /// 如果登录成功，则返回相应管理员的实体类，否则返回null
58          public AdminInfo Login( string name, string password)
59         {
60             password = Encryptor.MD5Encrypt(password);
61              return DALFactory.CreateAdminDAL().GetByNameAndPassword(name, password);
62         }
63
64          ///

65 /// 取得全部管理员信息
66 ///

67          /// 管理员实体类集合
68          public IList < AdminInfo > GetAll()
69         {
70              return DALFactory.CreateAdminDAL().GetAll();
71         }
72     }
73 }

基于.NET平台的分层架构实战（十一）——表示层的实现

在这篇文章中，将讨论一下表示层的实现方法。

表示层是一个系统的“门脸”，不论你的系统设计的多么优秀，代码多么漂亮，系统的可扩展性多么高，但是最终用户接触到的大多是表示层的东西。所以，表示层的优劣对于用户最终对系统的评价至关重要。一般来说，表示层的优劣有一下两个评价指标：

1.美观。即外观设计漂亮，能给人美的感觉。

2.易用。即具有良好的用户体验，用户用起来舒服、顺手。

表示层的设计牵扯到很多非技术性问题，如美工、用户心理学等问题，但是在这篇文章中，将不过多涉及这些问题，一来是我的水平有限，二来是这些内容和本系列文章的关系不是很密切。这里将主要从技术实现的角度讨论表示层的设计。

一般来说，表示层的职责有以下两点：

1.接受用户的输入。

2.向用户呈现信息。

总体来说，就是与用户的交互。

而表示层的实现技术也是多种多样的，如C/S架构下一般使用Windows窗体技术（甚至是命令行窗体），而B/S架构下主要是使用Web页的形式实现。而且在Ajax技术出现以后，又分出了同步模型的B/S架构实现和异步模型的B/S架构实现。在这篇文章中，将主要讨论同步模型下B/S架构的表示层实现，而基于Ajax技术的异步模型将在下一篇中讨论。

另外，提到表示层的实现，大家一定会想到MVC这个词，不错MVC已经成为表示层设计的经典模式。J2EE平台上的Struts和最近微软推出的ASP.NET MVC都是实现MVC模式的框架。但是为了突出本系列文章的的重点——分层，而且也为了照顾初学者。这里将不设计MVC模式，而是用传统的ASP.NET编程模型来完成表示层的设计。

一下的所有讨论，将围绕“管理员登录”这个用例展开。下面我们来逐步实现管理员登录的表示层设计。

1.设计界面

为实现这个功能，我们首先要有一个Web页面。设计好的页面如下图所示：（时间所迫，制作过于简陋，各位见谅）

图11.1、管理员登录界面

首先，我们要在“Web”工程下建立一个新的aspx文件，叫做Login.aspx，这就是管理员登录的Web页面。完成后这个文件的代码如下：

Login.aspx:

1<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Login.aspx.cs" Inherits="Login" %>
2
3
4
5
6
7    NGuestBook-管理员登录
8
9
10
11
12

33
34
35

可以看到，在这个文件里，主要是各种页面元素的结构，但是他们的外观却没有定义。我们注意到，在这个文件的开头引用了两个外部的CSS文件，那里才是定义外观的地方。其中Common.css是全局通用外观，而Login.aspx.css是这个页面的专用外观。

这是我提倡的一种表示层设计的方法。即将结构与表现分离，其思想很类似目前的“标准化网页设计”（有人称之为DIV+CSS布局），其核心思想是一样的，只不过我这里没那么严格，并且适当的地方可以考虑使用Table布局。我的一般方法是这样的：aspx文件中只存储页面结构，不存在任何与外观有关的代码。在工程中可以有一个专门的文件夹放置CSS文件，除了通用样式外，每个文件有与自己同名的CSS文件，如Login.asxp配套的就是Login.aspx.css，这样，就可以使得结构与表现相分离。

在我的工程中，有一个Styles文件夹，专门存放CSS文件。下面把Common.css和Login.aspx.css文件的代码附上：

Common.css

1*{}{
2    margin:0;
3    padding:0;
4}
5
6h1,h2,h3,h4,h5,h6{}{
7    font-size:12px;
8}
9
10#container{}{
11    width:100%;
12}

Login.aspx.css

1#box{}{
2    width:40%;
3    margin:200px auto auto auto;
4    border:3px solid #036;
5}
6
7h1{}{
8    margin:1px;
9    padding:5px 0;
10    font-size:14px;
11    color:#FFF;
12    background:#036;
13    text-align:center;
14}
15
16#forms{}{
17    margin:20px auto;
18    font-size:12px;
19    color:#036;
20}
21
22#forms input{}{
23    margin:10px;
24    border:0;
25    border-bottom:1px solid #036;
26    width:160px;
27}
28
29#buttons{}{
30    margin-bottom:20px;
31    text-align:center;
32}
33
34#buttons input{}{
35    margin:0 10px;
36}

2.表示逻辑

页面搞定了，但是要想页面发挥作用，还要有表示逻辑才行。我们登录的表示逻辑是这样的：首先根据用户输入的用户名和密码，检查是否是系统管理员（系统管理员只有一个，其用户名和密码定义在Web.config中，系统管理员可以添加、修改和删除普通管理员），如果是，则在Session中存储相应信息，并以系统管理员的身份登录后台管理页面。如果不是，则检查是否是普通管理员，如果是，则将此管理员的信息存储到Session中，以普通管理员身份返回主页。如果不是，则显示登录失败的提示。

当然，这里身份的控制还需要在后台页面和主页那边有Session检查才能完成。例如，当请求后台页时，要检查Session中相应信息是否完整，如果不完整则是非法请求，不允许访问此页面。而在主页也是，如果Session相应项中有普通管理员的信息，表明当前用户是管理员，要显示修改、回复、删除等按钮，否则是游客，则不显示这些按钮。

我们首先要配置系统管理员的用户名和密码，打开Web.config，在节点下添加如下项：

这里很明显，前一个是系统管理员的用户名，这里设为“admin”，而后一项为密码，设为“123456”

由于一般情况下Web.config是不允许请求的，所以这里不用担心密码泄露。

普通管理员登录的业务已经在业务逻辑层实现了，表示层可以直接调用。而系统管理员的判断、Session的操作检查及页面跳转都放在表示层里。而这一套逻辑，都放在“Submit”这个button控件的Click事件中，具体代码参考如下：

Login.aspx.cs:

1using System;
2using System.Data;
3using System.Configuration;
4using System.Collections;
5using System.Web;
6using System.Web.Security;
7using System.Web.UI;
8using System.Web.UI.WebControls;
9using System.Web.UI.WebControls.WebParts;
10using System.Web.UI.HtmlControls;
11using NGuestBook.Entity;
12using NGuestBook.IBLL;
13using NGuestBook.Factory;
14
15public partial class Login : System.Web.UI.Page
16{
17    protected void Page_Load(object sender, EventArgs e)
18    {
19
20    }
21    protected void Cancel_Click(object sender, EventArgs e)
22    {
23        this.Name.Text = "";
24        this.Password.Text = "";
25    }
26    protected void Submit_Click(object sender, EventArgs e)
27    {
28        string administratorName = ConfigurationManager.AppSettings["AdministartorName"];
29        string administratorPassword = ConfigurationManager.AppSettings["AdministartorPassword"];
30
31        //如果是系统管理员，则以系统管理员身份登录到后台
32        if (this.Name.Text == administratorName && this.Password.Text == administratorPassword)
33        {
34            Session["Administrator"] = "Administrator";
35            Response.Redirect("~/Manage.aspx");
36            return;
37        }
38
39        //判断是否为普通管理员，如果是，则以管理员身份登录到留言本，否则显示登录失败
40        AdminInfo admin = BLLFactory.CreateAdminBLL().Login(this.Name.Text, this.Password.Text);
41        if (admin != null)
42        {
43            Session["Admin"] = admin;
44            Response.Redirect("~/Default.aspx");
45        }
46        else
47        {
48            Response.Redirect("~/Error.aspx?errMsg=登录失败");
49        }
50    }
51}

转基于.NET平台的分层架构实战

基于.NET平台的分层架构实战（一）——综述

基于.NET平台的分层架构实战（二）——需求分析与数据库设计

基于.NET平台的分层架构实战（三）——架构概要设计

基于.NET平台的分层架构实战（四）——实体类的设计与实现

基于.NET平台的分层架构实战（五）——接口的设计与实现

基于.NET平台的分层架构实战（六）——依赖注入机制及IoC的设计与实现

基于.NET平台的分层架构实战（八）——数据访问层的第二种实现：SQLServer+存储过程

基于.NET平台的分层架构实战（九）——数据访问层的第三种实现：基于NBear框架的ORM实现

基于.NET平台的分层架构实战（十一）——表示层的实现

NGuestBook管理员登录

你可能感兴趣的:(软件架构,ASP.NET)

用户名：
密码：

转 基于.NET平台的分层架构实战

基于.NET平台的分层架构实战（一）——综述

基于.NET平台的分层架构实战（二）——需求分析与数据库设计

基于.NET平台的分层架构实战（三）——架构概要设计

基于.NET平台的分层架构实战（四）——实体类的设计与实现

基于.NET平台的分层架构实战（五）——接口的设计与实现

基于.NET平台的分层架构实战（六）——依赖注入机制及IoC的设计与实现

基于.NET平台的分层架构实战（八）——数据访问层的第二种实现：SQLServer+存储过程

基于.NET平台的分层架构实战（九）——数据访问层的第三种实现：基于NBear框架的ORM实现

基于.NET平台的分层架构实战（十一）——表示层的实现

NGuestBook管理员登录

你可能感兴趣的:(软件架构,ASP.NET)

转基于.NET平台的分层架构实战